mirror of
https://github.com/ComputerScienceHouse/proxstar.git
synced 2025-02-12 21:11:53 +00:00
16088 lines
506 KiB
PL/PgSQL
Generated
16088 lines
506 KiB
PL/PgSQL
Generated
CREATE DATABASE proxstar; CREATE DATABASE starrs; CREATE ROLE proxstar; CREATE ROLE starrs;
|
|
|
|
--
|
|
-- NOTE:
|
|
--
|
|
-- File paths need to be edited. Search for $$PATH$$ and
|
|
-- replace it with the path to the directory containing
|
|
-- the extracted data files.
|
|
--
|
|
--
|
|
-- PostgreSQL database dump
|
|
--
|
|
|
|
-- Dumped from database version 12.6
|
|
-- Dumped by pg_dump version 12.6
|
|
|
|
SET statement_timeout = 0;
|
|
SET lock_timeout = 0;
|
|
SET idle_in_transaction_session_timeout = 0;
|
|
SET client_encoding = 'UTF8';
|
|
SET standard_conforming_strings = on;
|
|
SELECT pg_catalog.set_config('search_path', '', false);
|
|
SET check_function_bodies = false;
|
|
SET xmloption = content;
|
|
SET client_min_messages = warning;
|
|
SET row_security = off;
|
|
|
|
DROP DATABASE proxstar;
|
|
--
|
|
-- Name: proxstar; Type: DATABASE; Schema: -; Owner: postgres
|
|
--
|
|
|
|
CREATE DATABASE proxstar WITH TEMPLATE = template0 ENCODING = 'UTF8' LC_COLLATE = 'en_US.UTF-8' LC_CTYPE = 'en_US.UTF-8';
|
|
|
|
|
|
ALTER DATABASE proxstar OWNER TO postgres;
|
|
|
|
\connect proxstar
|
|
|
|
SET statement_timeout = 0;
|
|
SET lock_timeout = 0;
|
|
SET idle_in_transaction_session_timeout = 0;
|
|
SET client_encoding = 'UTF8';
|
|
SET standard_conforming_strings = on;
|
|
SELECT pg_catalog.set_config('search_path', '', false);
|
|
SET check_function_bodies = false;
|
|
SET xmloption = content;
|
|
SET client_min_messages = warning;
|
|
SET row_security = off;
|
|
|
|
--
|
|
-- Name: plperl; Type: PROCEDURAL LANGUAGE; Schema: -; Owner: postgres
|
|
--
|
|
|
|
CREATE OR REPLACE PROCEDURAL LANGUAGE plperl;
|
|
|
|
|
|
ALTER PROCEDURAL LANGUAGE plperl OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: plperl_call_handler(); Type: FUNCTION; Schema: public; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION public.plperl_call_handler() RETURNS language_handler
|
|
LANGUAGE c
|
|
AS '$libdir/plperl', 'plperl_call_handler';
|
|
|
|
|
|
ALTER FUNCTION public.plperl_call_handler() OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: plpgsql_call_handler(); Type: FUNCTION; Schema: public; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION public.plpgsql_call_handler() RETURNS language_handler
|
|
LANGUAGE c
|
|
AS '$libdir/plpgsql', 'plpgsql_call_handler';
|
|
|
|
|
|
ALTER FUNCTION public.plpgsql_call_handler() OWNER TO postgres;
|
|
|
|
SET default_tablespace = '';
|
|
|
|
SET default_table_access_method = heap;
|
|
|
|
--
|
|
-- Name: allowed_users; Type: TABLE; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
CREATE TABLE public.allowed_users (
|
|
id character varying(32) NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE public.allowed_users OWNER TO proxstar;
|
|
|
|
--
|
|
-- Name: ignored_pools; Type: TABLE; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
CREATE TABLE public.ignored_pools (
|
|
id character varying(32) NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE public.ignored_pools OWNER TO proxstar;
|
|
|
|
--
|
|
-- Name: pool_cache; Type: TABLE; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
CREATE TABLE public.pool_cache (
|
|
pool character varying(32) NOT NULL,
|
|
vms text[] NOT NULL,
|
|
num_vms integer NOT NULL,
|
|
usage json NOT NULL,
|
|
limits json NOT NULL,
|
|
percents json NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE public.pool_cache OWNER TO proxstar;
|
|
|
|
--
|
|
-- Name: template; Type: TABLE; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
CREATE TABLE public.template (
|
|
id integer NOT NULL,
|
|
name character varying(32) NOT NULL,
|
|
username text NOT NULL,
|
|
password text NOT NULL,
|
|
disk integer NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE public.template OWNER TO proxstar;
|
|
|
|
--
|
|
-- Name: template_id_seq; Type: SEQUENCE; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
CREATE SEQUENCE public.template_id_seq
|
|
START WITH 1
|
|
INCREMENT BY 1
|
|
NO MINVALUE
|
|
NO MAXVALUE
|
|
CACHE 1;
|
|
|
|
|
|
ALTER TABLE public.template_id_seq OWNER TO proxstar;
|
|
|
|
--
|
|
-- Name: template_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
ALTER SEQUENCE public.template_id_seq OWNED BY public.template.id;
|
|
|
|
|
|
--
|
|
-- Name: usage_limit; Type: TABLE; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
CREATE TABLE public.usage_limit (
|
|
id character varying(32) NOT NULL,
|
|
cpu integer NOT NULL,
|
|
mem integer NOT NULL,
|
|
disk integer NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE public.usage_limit OWNER TO proxstar;
|
|
|
|
--
|
|
-- Name: vm_expiration; Type: TABLE; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
CREATE TABLE public.vm_expiration (
|
|
id integer NOT NULL,
|
|
expire_date date NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE public.vm_expiration OWNER TO proxstar;
|
|
|
|
--
|
|
-- Name: vm_expiration_id_seq; Type: SEQUENCE; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
CREATE SEQUENCE public.vm_expiration_id_seq
|
|
START WITH 1
|
|
INCREMENT BY 1
|
|
NO MINVALUE
|
|
NO MAXVALUE
|
|
CACHE 1;
|
|
|
|
|
|
ALTER TABLE public.vm_expiration_id_seq OWNER TO proxstar;
|
|
|
|
--
|
|
-- Name: vm_expiration_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
ALTER SEQUENCE public.vm_expiration_id_seq OWNED BY public.vm_expiration.id;
|
|
|
|
|
|
--
|
|
-- Name: template id; Type: DEFAULT; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
ALTER TABLE ONLY public.template ALTER COLUMN id SET DEFAULT nextval('public.template_id_seq'::regclass);
|
|
|
|
|
|
--
|
|
-- Name: vm_expiration id; Type: DEFAULT; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
ALTER TABLE ONLY public.vm_expiration ALTER COLUMN id SET DEFAULT nextval('public.vm_expiration_id_seq'::regclass);
|
|
|
|
|
|
--
|
|
-- Name: allowed_users allowed_users_pkey; Type: CONSTRAINT; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
ALTER TABLE ONLY public.allowed_users
|
|
ADD CONSTRAINT allowed_users_pkey PRIMARY KEY (id);
|
|
|
|
|
|
--
|
|
-- Name: ignored_pools ignored_pools_pkey; Type: CONSTRAINT; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
ALTER TABLE ONLY public.ignored_pools
|
|
ADD CONSTRAINT ignored_pools_pkey PRIMARY KEY (id);
|
|
|
|
|
|
--
|
|
-- Name: pool_cache pool_cache_pkey; Type: CONSTRAINT; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
ALTER TABLE ONLY public.pool_cache
|
|
ADD CONSTRAINT pool_cache_pkey PRIMARY KEY (pool);
|
|
|
|
|
|
--
|
|
-- Name: template template_pkey; Type: CONSTRAINT; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
ALTER TABLE ONLY public.template
|
|
ADD CONSTRAINT template_pkey PRIMARY KEY (id);
|
|
|
|
|
|
--
|
|
-- Name: usage_limit usage_limit_pkey; Type: CONSTRAINT; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
ALTER TABLE ONLY public.usage_limit
|
|
ADD CONSTRAINT usage_limit_pkey PRIMARY KEY (id);
|
|
|
|
|
|
--
|
|
-- Name: vm_expiration vm_expiration_pkey; Type: CONSTRAINT; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
ALTER TABLE ONLY public.vm_expiration
|
|
ADD CONSTRAINT vm_expiration_pkey PRIMARY KEY (id);
|
|
|
|
|
|
--
|
|
-- Name: allowed_users; Type: TABLE; Schema: public; Owner: proxstar
|
|
--
|
|
|
|
CREATE TABLE public.shared_pools (
|
|
name VARCHAR(32) PRIMARY KEY,
|
|
members VARCHAR(32)[]
|
|
);
|
|
|
|
|
|
ALTER TABLE public.shared_pools OWNER TO proxstar;
|
|
|
|
--
|
|
-- Name: DATABASE proxstar; Type: ACL; Schema: -; Owner: postgres
|
|
--
|
|
|
|
GRANT ALL ON DATABASE proxstar TO proxstar;
|
|
|
|
|
|
--
|
|
-- PostgreSQL database dump complete
|
|
--
|
|
|
|
--
|
|
-- NOTE:
|
|
--
|
|
-- File paths need to be edited. Search for $$PATH$$ and
|
|
-- replace it with the path to the directory containing
|
|
-- the extracted data files.
|
|
--
|
|
--
|
|
-- PostgreSQL database dump
|
|
--
|
|
|
|
-- Dumped from database version 12.6
|
|
-- Dumped by pg_dump version 12.6
|
|
|
|
SET statement_timeout = 0;
|
|
SET lock_timeout = 0;
|
|
SET idle_in_transaction_session_timeout = 0;
|
|
SET client_encoding = 'UTF8';
|
|
SET standard_conforming_strings = on;
|
|
SELECT pg_catalog.set_config('search_path', '', false);
|
|
SET check_function_bodies = false;
|
|
SET xmloption = content;
|
|
SET client_min_messages = warning;
|
|
SET row_security = off;
|
|
|
|
DROP DATABASE starrs;
|
|
--
|
|
-- Name: starrs; Type: DATABASE; Schema: -; Owner: starrs
|
|
--
|
|
|
|
CREATE DATABASE starrs WITH TEMPLATE = template0 ENCODING = 'UTF8' LC_COLLATE = 'en_US.UTF-8' LC_CTYPE = 'en_US.UTF-8';
|
|
|
|
|
|
ALTER DATABASE starrs OWNER TO starrs;
|
|
|
|
\connect starrs
|
|
|
|
SET statement_timeout = 0;
|
|
SET lock_timeout = 0;
|
|
SET idle_in_transaction_session_timeout = 0;
|
|
SET client_encoding = 'UTF8';
|
|
SET standard_conforming_strings = on;
|
|
SELECT pg_catalog.set_config('search_path', '', false);
|
|
SET check_function_bodies = false;
|
|
SET xmloption = content;
|
|
SET client_min_messages = warning;
|
|
SET row_security = off;
|
|
|
|
--
|
|
-- Name: DATABASE starrs; Type: COMMENT; Schema: -; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON DATABASE starrs IS 'STARRS network management application';
|
|
|
|
|
|
--
|
|
-- Name: api; Type: SCHEMA; Schema: -; Owner: starrs
|
|
--
|
|
|
|
CREATE SCHEMA api;
|
|
|
|
|
|
ALTER SCHEMA api OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: SCHEMA api; Type: COMMENT; Schema: -; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON SCHEMA api IS 'Interaction with clients';
|
|
|
|
|
|
--
|
|
-- Name: dhcp; Type: SCHEMA; Schema: -; Owner: starrs
|
|
--
|
|
|
|
CREATE SCHEMA dhcp;
|
|
|
|
|
|
ALTER SCHEMA dhcp OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: SCHEMA dhcp; Type: COMMENT; Schema: -; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON SCHEMA dhcp IS 'Configuration for stateful addressing';
|
|
|
|
|
|
--
|
|
-- Name: dns; Type: SCHEMA; Schema: -; Owner: starrs
|
|
--
|
|
|
|
CREATE SCHEMA dns;
|
|
|
|
|
|
ALTER SCHEMA dns OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: SCHEMA dns; Type: COMMENT; Schema: -; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON SCHEMA dns IS 'All DNS records for the controlled zones/domains';
|
|
|
|
|
|
--
|
|
-- Name: ip; Type: SCHEMA; Schema: -; Owner: starrs
|
|
--
|
|
|
|
CREATE SCHEMA ip;
|
|
|
|
|
|
ALTER SCHEMA ip OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: SCHEMA ip; Type: COMMENT; Schema: -; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON SCHEMA ip IS 'Network resources available for devices';
|
|
|
|
|
|
--
|
|
-- Name: libvirt; Type: SCHEMA; Schema: -; Owner: starrs
|
|
--
|
|
|
|
CREATE SCHEMA libvirt;
|
|
|
|
|
|
ALTER SCHEMA libvirt OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: SCHEMA libvirt; Type: COMMENT; Schema: -; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON SCHEMA libvirt IS 'Libvirt interaction with VM hosts';
|
|
|
|
|
|
--
|
|
-- Name: management; Type: SCHEMA; Schema: -; Owner: starrs
|
|
--
|
|
|
|
CREATE SCHEMA management;
|
|
|
|
|
|
ALTER SCHEMA management OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: SCHEMA management; Type: COMMENT; Schema: -; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON SCHEMA management IS 'Application configuration and data';
|
|
|
|
|
|
--
|
|
-- Name: network; Type: SCHEMA; Schema: -; Owner: starrs
|
|
--
|
|
|
|
CREATE SCHEMA network;
|
|
|
|
|
|
ALTER SCHEMA network OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: SCHEMA network; Type: COMMENT; Schema: -; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON SCHEMA network IS 'Data on special network devices';
|
|
|
|
|
|
--
|
|
-- Name: systems; Type: SCHEMA; Schema: -; Owner: starrs
|
|
--
|
|
|
|
CREATE SCHEMA systems;
|
|
|
|
|
|
ALTER SCHEMA systems OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: SCHEMA systems; Type: COMMENT; Schema: -; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON SCHEMA systems IS 'User machine data for devices on the network';
|
|
|
|
|
|
--
|
|
-- Name: plperl; Type: PROCEDURAL LANGUAGE; Schema: -; Owner: postgres
|
|
--
|
|
|
|
CREATE OR REPLACE PROCEDURAL LANGUAGE plperl;
|
|
|
|
|
|
ALTER PROCEDURAL LANGUAGE plperl OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: plperlu; Type: PROCEDURAL LANGUAGE; Schema: -; Owner: postgres
|
|
--
|
|
|
|
CREATE OR REPLACE PROCEDURAL LANGUAGE plperlu;
|
|
|
|
|
|
ALTER PROCEDURAL LANGUAGE plperlu OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: plpython3u; Type: PROCEDURAL LANGUAGE; Schema: -; Owner: postgres
|
|
--
|
|
|
|
CREATE OR REPLACE PROCEDURAL LANGUAGE plpython3u;
|
|
|
|
|
|
ALTER PROCEDURAL LANGUAGE plpython3u OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: dhcpd_class_options; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_class_options AS (
|
|
option text,
|
|
value text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_class_options OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_class_options; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_class_options IS 'Get class options for the dhcpd.conf';
|
|
|
|
|
|
--
|
|
-- Name: dhcpd_classes; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_classes AS (
|
|
class text,
|
|
comment text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_classes OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_classes; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_classes IS 'Class information for dhcpd.conf';
|
|
|
|
|
|
--
|
|
-- Name: dhcpd_dns_keys; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_dns_keys AS (
|
|
keyname text,
|
|
key text,
|
|
enctype text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_dns_keys OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_dns_keys; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_dns_keys IS 'Get all dns key information for dhcpd';
|
|
|
|
|
|
--
|
|
-- Name: dhcpd_dynamic_hosts; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_dynamic_hosts AS (
|
|
hostname character varying(63),
|
|
zone text,
|
|
mac macaddr,
|
|
owner text,
|
|
class text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_dynamic_hosts OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: dhcpd_global_options; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_global_options AS (
|
|
option text,
|
|
value text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_global_options OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_global_options; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_global_options IS 'Get all global DHCPD config directives';
|
|
|
|
|
|
--
|
|
-- Name: dhcpd_keys; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_keys AS (
|
|
keyname text,
|
|
key text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_keys OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_keys; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_keys IS 'get the keys of the DHCP enabled subnet zones';
|
|
|
|
|
|
--
|
|
-- Name: dhcpd_range_options; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_range_options AS (
|
|
option text,
|
|
value text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_range_options OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_range_options; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_range_options IS 'range options for the dhcpd.conf';
|
|
|
|
|
|
--
|
|
-- Name: dhcpd_range_settings; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_range_settings AS (
|
|
setting text,
|
|
value text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_range_settings OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_range_settings; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_range_settings IS 'range settings for the dhcpd.conf';
|
|
|
|
|
|
--
|
|
-- Name: dhcpd_static_hosts; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_static_hosts AS (
|
|
hostname character varying(63),
|
|
zone text,
|
|
mac macaddr,
|
|
address inet,
|
|
owner text,
|
|
class text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_static_hosts OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_static_hosts; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_static_hosts IS 'Dynamic host information for the dhcpd.conf';
|
|
|
|
|
|
--
|
|
-- Name: dhcpd_subnet_options; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_subnet_options AS (
|
|
option text,
|
|
value text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_subnet_options OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_subnet_options; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_subnet_options IS 'Subnet options for the dhcpd.conf';
|
|
|
|
|
|
--
|
|
-- Name: dhcpd_subnet_ranges; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_subnet_ranges AS (
|
|
name text,
|
|
first_ip inet,
|
|
last_ip inet,
|
|
class text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_subnet_ranges OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_subnet_ranges; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_subnet_ranges IS 'list all dynamic ranges within a subnet';
|
|
|
|
|
|
--
|
|
-- Name: dhcpd_subnet_settings; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_subnet_settings AS (
|
|
setting text,
|
|
value text
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_subnet_settings OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_subnet_settings; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_subnet_settings IS 'Subnet settings for the dhcpd.conf';
|
|
|
|
|
|
--
|
|
-- Name: dhcpd_zones; Type: TYPE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dhcp.dhcpd_zones AS (
|
|
zone text,
|
|
keyname text,
|
|
primary_ns inet
|
|
);
|
|
|
|
|
|
ALTER TYPE dhcp.dhcpd_zones OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE dhcpd_zones; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dhcp.dhcpd_zones IS 'Zone information for dhcpd';
|
|
|
|
|
|
--
|
|
-- Name: zone_audit_data; Type: TYPE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE dns.zone_audit_data AS (
|
|
host text,
|
|
ttl integer,
|
|
type text,
|
|
address inet,
|
|
port integer,
|
|
weight integer,
|
|
priority integer,
|
|
preference integer,
|
|
target text,
|
|
text text,
|
|
contact text,
|
|
serial text,
|
|
refresh integer,
|
|
retry integer,
|
|
expire integer,
|
|
minimum integer
|
|
);
|
|
|
|
|
|
ALTER TYPE dns.zone_audit_data OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE zone_audit_data; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE dns.zone_audit_data IS 'All DNS zone data for auditing purposes';
|
|
|
|
|
|
--
|
|
-- Name: domain_data; Type: TYPE; Schema: libvirt; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE libvirt.domain_data AS (
|
|
domain text,
|
|
state text,
|
|
definition text
|
|
);
|
|
|
|
|
|
ALTER TYPE libvirt.domain_data OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: domains; Type: TYPE; Schema: libvirt; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE libvirt.domains AS (
|
|
host_name text,
|
|
domain_name text,
|
|
state text,
|
|
definition text,
|
|
date_created timestamp without time zone,
|
|
date_modified timestamp without time zone,
|
|
last_modifier text
|
|
);
|
|
|
|
|
|
ALTER TYPE libvirt.domains OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: search_data; Type: TYPE; Schema: management; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE management.search_data AS (
|
|
datacenter text,
|
|
availability_zone text,
|
|
system_name text,
|
|
location text,
|
|
asset text,
|
|
"group" text,
|
|
platform text,
|
|
mac macaddr,
|
|
address inet,
|
|
config text,
|
|
system_owner text,
|
|
system_last_modifier text,
|
|
range text,
|
|
hostname character varying(63),
|
|
cname_alias character varying(63),
|
|
srv_alias character varying(63),
|
|
zone text,
|
|
dns_owner text,
|
|
dns_last_modifier text
|
|
);
|
|
|
|
|
|
ALTER TYPE management.search_data OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: cam; Type: TYPE; Schema: network; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE network.cam AS (
|
|
mac macaddr,
|
|
ifindex integer,
|
|
vlan integer
|
|
);
|
|
|
|
|
|
ALTER TYPE network.cam OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: switchports; Type: TYPE; Schema: network; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE network.switchports AS (
|
|
system_name text,
|
|
name text,
|
|
"desc" text,
|
|
ifindex integer,
|
|
alias text,
|
|
admin_state boolean,
|
|
oper_state boolean,
|
|
date_created timestamp without time zone,
|
|
date_modified timestamp without time zone,
|
|
last_modifier text,
|
|
vlan integer
|
|
);
|
|
|
|
|
|
ALTER TYPE network.switchports OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: os_distribution; Type: TYPE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE systems.os_distribution AS (
|
|
name text,
|
|
count integer,
|
|
percentage integer
|
|
);
|
|
|
|
|
|
ALTER TYPE systems.os_distribution OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE os_distribution; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE systems.os_distribution IS 'OS distribution statistics';
|
|
|
|
|
|
--
|
|
-- Name: os_family_distribution; Type: TYPE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TYPE systems.os_family_distribution AS (
|
|
family text,
|
|
count integer,
|
|
percentage integer
|
|
);
|
|
|
|
|
|
ALTER TYPE systems.os_family_distribution OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TYPE os_family_distribution; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TYPE systems.os_family_distribution IS 'OS distribution statistics';
|
|
|
|
|
|
--
|
|
-- Name: add_libvirt_domain(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.add_libvirt_domain(input_host text, input_domain text) RETURNS SETOF libvirt.domains
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "system"."systems" WHERE "system_name" = input_host) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied: Not owner of host!';
|
|
END IF;
|
|
|
|
IF (SELECT "owner" FROM "system"."systems" WHERE "system_name" = input_domain) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied: Not owner of domain!';
|
|
END IF;
|
|
END IF;
|
|
|
|
IF (SELECT "type" FROM "systems"."systems" WHERE "system_name" = input_host) != 'VM Host' THEN
|
|
RAISE EXCEPTION 'Host type mismatch. You need a VM Host.';
|
|
END IF;
|
|
|
|
IF (SELECT "type" FROM "systems"."systems" WHERE "system_name" = input_domain) != 'Virtual Machine' THEN
|
|
RAISE EXCEPTION 'Domain type mismatch. You need a Virtual Machine.';
|
|
END IF;
|
|
|
|
INSERT INTO "libvirt"."domains" ("host_name", "domain_name") VALUES (input_host, input_domain);
|
|
|
|
RETURN QUERY (SELECT * FROM "libvirt"."domains" WHERE "domain_name" = input_domain);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.add_libvirt_domain(input_host text, input_domain text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION add_libvirt_domain(input_host text, input_domain text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.add_libvirt_domain(input_host text, input_domain text) IS 'Assign a VM to a host';
|
|
|
|
|
|
--
|
|
-- Name: change_username(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.change_username(old_username text, new_username text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Only admins can change usernames';
|
|
END IF;
|
|
|
|
-- Perform update
|
|
UPDATE "dhcp"."class_options" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "ip"."range_uses" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "ip"."subnets" SET "owner" = new_username WHERE "owner" = old_username;
|
|
UPDATE "ip"."subnets" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "ip"."ranges" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dns"."ns" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "systems"."os_family" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "systems"."interface_addresses" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dhcp"."classes" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "systems"."systems" SET "owner" = new_username WHERE "owner" = old_username;
|
|
UPDATE "systems"."systems" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dhcp"."subnet_options" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dhcp"."config_types" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "systems"."os" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dns"."cname" SET "owner" = new_username WHERE "owner" = old_username;
|
|
UPDATE "dns"."cname" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dns"."srv" SET "owner" = new_username WHERE "owner" = old_username;
|
|
UPDATE "dns"."srv" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dns"."mx" SET "owner" = new_username WHERE "owner" = old_username;
|
|
UPDATE "dns"."mx" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dns"."zones" SET "owner" = new_username WHERE "owner" = old_username;
|
|
UPDATE "dns"."zones" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dns"."soa" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dns"."keys" SET "owner" = new_username WHERE "owner" = old_username;
|
|
UPDATE "dns"."keys" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "ip"."addresses" SET "owner" = new_username WHERE "owner" = old_username;
|
|
UPDATE "ip"."addresses" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dns"."txt" SET "owner" = new_username WHERE "owner" = old_username;
|
|
UPDATE "dns"."txt" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dns"."zone_txt" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "management"."log_master" SET "user" = new_username WHERE "user" = old_username;
|
|
UPDATE "dns"."a" SET "owner" = new_username WHERE "owner" = old_username;
|
|
UPDATE "dns"."a" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "systems"."interfaces" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "management"."configuration" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dhcp"."range_options" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dhcp"."global_options" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dns"."types" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "dns"."zone_a" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "network"."snmp" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "systems"."architectures" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "systems"."platforms" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "systems"."datacenters" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "systems"."availability_zones" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "management"."group_members" SET "user" = new_username WHERE "user" = old_username;
|
|
UPDATE "management"."groups" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "management"."group_members" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "network"."cam_cache" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
UPDATE "network"."vlans" SET "last_modifier" = new_username WHERE "last_modifier" = old_username;
|
|
PERFORM api.syslog('changed user "'||old_username||'" to "'||new_username);
|
|
|
|
-- Done
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.change_username(old_username text, new_username text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION change_username(old_username text, new_username text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.change_username(old_username text, new_username text) IS 'Change all references to an old username to a new one';
|
|
|
|
|
|
--
|
|
-- Name: check_dns_hostname(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.check_dns_hostname(input_hostname text, input_zone text) RETURNS boolean
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER := 0;
|
|
BEGIN
|
|
RowCount := RowCount + (SELECT COUNT(*) FROM "dns"."a" WHERE "hostname" = input_hostname AND "zone" = input_zone);
|
|
RowCount := RowCount + (SELECT COUNT(*) FROM "dns"."srv" WHERE "alias" = input_hostname AND "zone" = input_zone);
|
|
RowCount := RowCount + (SELECT COUNT(*) FROM "dns"."cname" WHERE "alias" = input_hostname AND "zone" = input_zone);
|
|
|
|
IF RowCount = 0 THEN
|
|
RETURN FALSE;
|
|
ELSE
|
|
RETURN TRUE;
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.check_dns_hostname(input_hostname text, input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION check_dns_hostname(input_hostname text, input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.check_dns_hostname(input_hostname text, input_zone text) IS 'Check if a hostname is available in a given zone';
|
|
|
|
|
|
--
|
|
-- Name: clear_expired_addresses(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.clear_expired_addresses() RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
SystemData RECORD;
|
|
BEGIN
|
|
--FOR SystemData IN (SELECT "system_name" FROM "systems"."systems" WHERE "systems"."systems"."renew_date" = current_date) LOOP
|
|
-- PERFORM "api"."remove_system"(SystemData.system_name);
|
|
--END LOOP;
|
|
FOR SystemData IN (SELECT "address" FROM "systems"."interface_addresses" WHERE "renew_date" <= current_date) LOOP
|
|
PERFORM "api"."remove_interface_address"(SystemData.address);
|
|
END LOOP;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.clear_expired_addresses() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION clear_expired_addresses(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.clear_expired_addresses() IS 'Remove all expired addresses.';
|
|
|
|
|
|
--
|
|
-- Name: control_libvirt_domain(text, text, text, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.control_libvirt_domain(sysuri text, syspassword text, domain text, action text) RETURNS text
|
|
LANGUAGE plpython3u
|
|
AS $$
|
|
#!/usr/bin/python
|
|
|
|
import libvirt
|
|
import sys
|
|
|
|
def request_credentials(credentials, data):
|
|
for credential in credentials:
|
|
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
|
|
return 0
|
|
elif credential[0] == libvirt.VIR_CRED_NOECHOPROMPT:
|
|
credential[4] = syspassword
|
|
else:
|
|
return -1
|
|
|
|
return 0
|
|
|
|
auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT], request_credentials, None]
|
|
conn = libvirt.openAuth(sysuri, auth, 0)
|
|
|
|
dom = conn.lookupByName(domain)
|
|
|
|
if action == 'destroy':
|
|
dom.destroy()
|
|
elif action == 'shutdown':
|
|
dom.shutdown()
|
|
elif action == 'reboot':
|
|
dom.reboot(0)
|
|
elif action == 'reset':
|
|
dom.reset(0)
|
|
elif action == 'resume':
|
|
dom.resume()
|
|
elif action == 'restore':
|
|
dom.restore()
|
|
elif action == 'suspend':
|
|
dom.suspend()
|
|
elif action == 'save':
|
|
dom.save()
|
|
elif action == 'create':
|
|
dom.create()
|
|
else:
|
|
sys.exit("Invalid action")
|
|
|
|
conn.close()
|
|
state_names = { libvirt.VIR_DOMAIN_RUNNING : "running",
|
|
libvirt.VIR_DOMAIN_BLOCKED : "idle",
|
|
libvirt.VIR_DOMAIN_PAUSED : "paused",
|
|
libvirt.VIR_DOMAIN_SHUTDOWN : "in shutdown",
|
|
libvirt.VIR_DOMAIN_SHUTOFF : "shut off",
|
|
libvirt.VIR_DOMAIN_CRASHED : "crashed",
|
|
libvirt.VIR_DOMAIN_NOSTATE : "no state" }
|
|
return state_names[dom.info()[0]]
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.control_libvirt_domain(sysuri text, syspassword text, domain text, action text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: create_address_range(inet, inet, cidr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_address_range(input_first_ip inet, input_last_ip inet, input_subnet cidr) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
Owner TEXT;
|
|
RangeAddresses RECORD;
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "ip"."subnets" WHERE "subnet" = input_subnet) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on subnet %. You are not owner',input_subnet;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check if subnet exists
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."subnets"
|
|
WHERE "ip"."subnets"."subnet" = input_subnet;
|
|
IF (RowCount < 1) THEN
|
|
RAISE EXCEPTION 'Subnet (%) does not exist.',input_subnet;
|
|
END IF;
|
|
|
|
-- Check if addresses are within subnet
|
|
IF NOT input_first_ip << input_subnet THEN
|
|
RAISE EXCEPTION 'First address (%) not within subnet (%)',input_first_ip,input_subnet;
|
|
END IF;
|
|
|
|
IF NOT input_last_ip << input_subnet THEN
|
|
RAISE EXCEPTION 'Last address (%) not within subnet (%)',input_last_ip,input_subnet;
|
|
END IF;
|
|
|
|
-- Check if autogen'd
|
|
IF (SELECT "autogen" FROM "ip"."subnets" WHERE "ip"."subnets"."subnet" = input_subnet LIMIT 1) IS TRUE THEN
|
|
RAISE EXCEPTION 'Subnet (%) addresses were autogenerated. Cannot create new addresses.',input_subnet;
|
|
END IF;
|
|
|
|
-- Get owner
|
|
SELECT "ip"."subnets"."owner" INTO Owner
|
|
FROM "ip"."subnets"
|
|
WHERE "ip"."subnets"."subnet" = input_subnet;
|
|
|
|
-- Create addresses
|
|
FOR RangeAddresses IN SELECT api.get_range_addresses(input_first_ip,input_last_ip) LOOP
|
|
INSERT INTO "ip"."addresses" ("address","owner") VALUES (RangeAddresses.get_range_addresses,Owner);
|
|
END LOOP;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_address_range:"'||input_first_ip||'","'||input_last_ip||'","'||input_subnet||'"');
|
|
PERFORM api.syslog('WARNING! Potential deprecated function in use!');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_address_range(input_first_ip inet, input_last_ip inet, input_subnet cidr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_address_range(input_first_ip inet, input_last_ip inet, input_subnet cidr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_address_range(input_first_ip inet, input_last_ip inet, input_subnet cidr) IS 'Create a range of addresses from a non-autogened subnet (intended for DHCPv6)';
|
|
|
|
|
|
--
|
|
-- Name: get_current_user(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_current_user() RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT "username"
|
|
FROM "user_privileges"
|
|
WHERE "privilege" = 'USERNAME');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_current_user() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_current_user(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_current_user() IS 'Get the username of the current session';
|
|
|
|
|
|
SET default_tablespace = '';
|
|
|
|
SET default_table_access_method = heap;
|
|
|
|
--
|
|
-- Name: availability_zones; Type: TABLE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE systems.availability_zones (
|
|
datacenter text NOT NULL,
|
|
zone text NOT NULL,
|
|
comment text,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE systems.availability_zones OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE availability_zones; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE systems.availability_zones IS 'Availability zones within datacenters';
|
|
|
|
|
|
--
|
|
-- Name: create_availability_zone(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_availability_zone(input_datacenter text, input_zone text, input_comment text) RETURNS SETOF systems.availability_zones
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied to create availability zone: not admin';
|
|
END IF;
|
|
|
|
-- Create availability_zones
|
|
INSERT INTO "systems"."availability_zones" ("datacenter","zone","comment") VALUES (input_datacenter, input_zone, input_comment);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_availability_zone:"'||input_datacenter||'","'||input_zone||'"');
|
|
RETURN QUERY (SELECT * FROM "systems"."availability_zones" WHERE "datacenter" = input_datacenter AND "zone" = input_zone);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_availability_zone(input_datacenter text, input_zone text, input_comment text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_availability_zone(input_datacenter text, input_zone text, input_comment text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_availability_zone(input_datacenter text, input_zone text, input_comment text) IS 'Create a new availability zone';
|
|
|
|
|
|
--
|
|
-- Name: datacenters; Type: TABLE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE systems.datacenters (
|
|
datacenter text NOT NULL,
|
|
comment text,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE systems.datacenters OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE datacenters; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE systems.datacenters IS 'Regional locations for systems';
|
|
|
|
|
|
--
|
|
-- Name: create_datacenter(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_datacenter(input_name text, input_comment text) RETURNS SETOF systems.datacenters
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied to create datacenter: not admin';
|
|
END IF;
|
|
|
|
-- Create datacenter
|
|
INSERT INTO "systems"."datacenters" ("datacenter","comment") VALUES (input_name,input_comment);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_datacenter:"'||input_name||'"');
|
|
RETURN QUERY (SELECT * FROM "systems"."datacenters" WHERE "datacenter" = input_name);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_datacenter(input_name text, input_comment text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_datacenter(input_name text, input_comment text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_datacenter(input_name text, input_comment text) IS 'Create a new datacenter';
|
|
|
|
|
|
--
|
|
-- Name: classes; Type: TABLE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dhcp.classes (
|
|
class text NOT NULL,
|
|
comment text,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dhcp.classes OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE classes; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dhcp.classes IS 'DHCP classes allow configuration of hosts in certain ways';
|
|
|
|
|
|
--
|
|
-- Name: create_dhcp_class(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dhcp_class(input_class text, input_comment text) RETURNS SETOF dhcp.classes
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to create dhcp class denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Validate input
|
|
input_class := api.validate_nospecial(input_class);
|
|
|
|
-- Create new class
|
|
INSERT INTO "dhcp"."classes" ("class","comment") VALUES (input_class,input_comment);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dhcp_class:"'||input_class||'"');
|
|
RETURN QUERY (SELECT * FROM "dhcp"."classes" WHERE "class" = input_class);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dhcp_class(input_class text, input_comment text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dhcp_class(input_class text, input_comment text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dhcp_class(input_class text, input_comment text) IS 'Create a new DHCP class';
|
|
|
|
|
|
--
|
|
-- Name: class_options; Type: TABLE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dhcp.class_options (
|
|
option text NOT NULL,
|
|
value text NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
class text NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dhcp.class_options OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE class_options; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dhcp.class_options IS 'Options to apply to a specific DHCP class (like Netbooting)';
|
|
|
|
|
|
--
|
|
-- Name: create_dhcp_class_option(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dhcp_class_option(input_class text, input_option text, input_value text) RETURNS SETOF dhcp.class_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to create dhcp class option denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Create class option
|
|
INSERT INTO "dhcp"."class_options"
|
|
("class","option","value") VALUES
|
|
(input_class,input_option,input_value);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dhcp_class_option:"'||input_class||'","'||input_option||'","'||input_value||'"');
|
|
RETURN QUERY (SELECT * FROM "dhcp"."class_options" WHERE "class" = input_class AND "option" = input_option AND "value" = input_value);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dhcp_class_option(input_class text, input_option text, input_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dhcp_class_option(input_class text, input_option text, input_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dhcp_class_option(input_class text, input_option text, input_value text) IS 'Create a new DHCP class option';
|
|
|
|
|
|
--
|
|
-- Name: global_options; Type: TABLE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dhcp.global_options (
|
|
option text NOT NULL,
|
|
value text NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dhcp.global_options OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE global_options; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dhcp.global_options IS 'Global DHCP options that affect all objects';
|
|
|
|
|
|
--
|
|
-- Name: create_dhcp_global_option(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dhcp_global_option(input_option text, input_value text) RETURNS SETOF dhcp.global_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to create dhcp class option denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Create class option
|
|
INSERT INTO "dhcp"."global_options"
|
|
("option","value") VALUES (input_option,input_value);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dhcp_global_option:"'||input_option||'","'||input_value||'"');
|
|
RETURN QUERY (SELECT * FROM "dhcp"."global_options" WHERE "option" = input_option AND "value" = input_value);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dhcp_global_option(input_option text, input_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dhcp_global_option(input_option text, input_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dhcp_global_option(input_option text, input_value text) IS 'Create a new DHCP global option';
|
|
|
|
|
|
--
|
|
-- Name: range_options; Type: TABLE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dhcp.range_options (
|
|
option text NOT NULL,
|
|
name text NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
value text NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dhcp.range_options OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE range_options; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dhcp.range_options IS 'DHCP options that apply to a specific range';
|
|
|
|
|
|
--
|
|
-- Name: create_dhcp_range_option(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dhcp_range_option(input_range text, input_option text, input_value text) RETURNS SETOF dhcp.range_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission to create dhcp range option denied for user %. You are not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Check if range is marked for DHCP
|
|
IF (SELECT "use" FROM "ip"."ranges" WHERE "name" = input_range) !~* 'ROAM' THEN
|
|
RAISE EXCEPTION 'Range % is not marked for DHCP configuration',input_range;
|
|
END IF;
|
|
|
|
-- Create option
|
|
INSERT INTO "dhcp"."range_options" ("name","option","value","last_modifier")
|
|
VALUES (input_range, input_option, input_value, api.get_current_user());
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dhcp_range_option:"'||input_range||'","'||input_option||'","'||input_value||'"');
|
|
RETURN QUERY (SELECT * FROM "dhcp"."range_options" WHERE "name" = input_range AND "option" = input_option AND "value" = input_value);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dhcp_range_option(input_range text, input_option text, input_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dhcp_range_option(input_range text, input_option text, input_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dhcp_range_option(input_range text, input_option text, input_value text) IS 'Create a DHCP range option';
|
|
|
|
|
|
--
|
|
-- Name: subnet_options; Type: TABLE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dhcp.subnet_options (
|
|
option text NOT NULL,
|
|
value text NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
subnet cidr NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dhcp.subnet_options OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE subnet_options; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dhcp.subnet_options IS 'Options to apply to an entire subnet';
|
|
|
|
|
|
--
|
|
-- Name: create_dhcp_subnet_option(cidr, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dhcp_subnet_option(input_subnet cidr, input_option text, input_value text) RETURNS SETOF dhcp.subnet_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to create dhcp subnet option denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Create subnet option
|
|
INSERT INTO "dhcp"."subnet_options"
|
|
("subnet","option","value") VALUES
|
|
(input_subnet,input_option,input_value);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dhcp_subnet_option:"'||input_subnet||'","'||input_option||'","'||input_value||'"');
|
|
RETURN QUERY (SELECT * FROM "dhcp"."subnet_options" WHERE "subnet" = input_subnet AND "option" = input_option AND "value" = input_value);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dhcp_subnet_option(input_subnet cidr, input_option text, input_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dhcp_subnet_option(input_subnet cidr, input_option text, input_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dhcp_subnet_option(input_subnet cidr, input_option text, input_value text) IS 'Create DHCP subnet option';
|
|
|
|
|
|
--
|
|
-- Name: get_site_configuration(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_site_configuration(input_directive text) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT "value" FROM "management"."configuration" WHERE "option" = input_directive);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_site_configuration(input_directive text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_site_configuration(input_directive text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_site_configuration(input_directive text) IS 'Get a site configuration directive';
|
|
|
|
|
|
--
|
|
-- Name: a; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.a (
|
|
hostname character varying(63) NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
address inet NOT NULL,
|
|
type text NOT NULL,
|
|
ttl integer DEFAULT (api.get_site_configuration('DNS_DEFAULT_TTL'::text))::integer NOT NULL,
|
|
owner text NOT NULL,
|
|
zone text DEFAULT api.get_site_configuration('DNS_DEFAULT_ZONE'::text) NOT NULL,
|
|
reverse boolean DEFAULT true NOT NULL,
|
|
CONSTRAINT dns_a_hostname CHECK (((hostname)::text !~ '_'::text)),
|
|
CONSTRAINT dns_a_type_check CHECK ((type ~ '^A|AAAA$'::text))
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.a OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE a; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.a IS 'DNS forward address records';
|
|
|
|
|
|
--
|
|
-- Name: create_dns_address(inet, text, text, integer, text, boolean, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dns_address(input_address inet, input_hostname text, input_zone text, input_ttl integer, input_type text, input_reverse boolean, input_owner text) RETURNS SETOF dns.a
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Set owner
|
|
IF input_owner IS NULL THEN
|
|
input_owner := api.get_current_user();
|
|
END IF;
|
|
|
|
-- Set zone
|
|
IF input_zone IS NULL THEN
|
|
input_zone := api.get_site_configuration('DNS_DEFAULT_ZONE');
|
|
END IF;
|
|
|
|
-- Fill TTL
|
|
IF input_ttl IS NULL THEN
|
|
input_ttl := api.get_site_configuration('DNS_DEFAULT_TTL');
|
|
END IF;
|
|
|
|
-- Autofill Type
|
|
IF input_type IS NULL THEN
|
|
IF family(input_address) = 4 THEN
|
|
input_type := 'A';
|
|
ELSEIF family(input_address) = 6 THEN
|
|
input_type := 'AAAA';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check type
|
|
IF input_type !~* '^A|AAAA$' THEN
|
|
RAISE EXCEPTION 'Bad type % given',input_type;
|
|
END IF;
|
|
|
|
-- Lower
|
|
input_hostname := lower(input_hostname);
|
|
|
|
-- Validate type
|
|
IF family(input_address) = 4 AND input_type !~* '^A$' THEN
|
|
RAISE EXCEPTION 'IPv4 Address/Type mismatch';
|
|
ELSEIF family(input_address) = 6 AND input_type !~* '^AAAA$' THEN
|
|
RAISE EXCEPTION 'IPv6 Address/Type mismatch';
|
|
END IF;
|
|
|
|
-- User can only specify TTL if address is static
|
|
IF (SELECT "config" FROM "systems"."interface_addresses" WHERE "address" = input_address) !~* 'static' AND input_ttl != (SELECT "value"::integer/2 AS "ttl" FROM "dhcp"."subnet_options" WHERE "option"='default-lease-time' AND "subnet" >> input_address) THEN
|
|
RAISE EXCEPTION 'You can only specify a TTL other than the default if your address is configured statically';
|
|
END IF;
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
-- Shared zone
|
|
IF (SELECT "shared" FROM "dns"."zones" WHERE "zone" = input_zone) IS FALSE THEN
|
|
RAISE EXCEPTION 'Zone is not shared and you are not admin';
|
|
END IF;
|
|
-- You own the system
|
|
IF (SELECT "write" FROM api.get_system_permissions(api.get_interface_address_system(input_address))) IS FALSE THEN
|
|
RAISE EXCEPTION 'Permission denied';
|
|
END IF;
|
|
-- You specified another owner
|
|
IF input_owner != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only admins can define a different owner (%).',input_owner;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Validate hostname
|
|
IF api.validate_domain(input_hostname,input_zone) IS FALSE THEN
|
|
RAISE EXCEPTION 'Invalid hostname (%) and domain (%)',input_hostname,input_zone;
|
|
END IF;
|
|
|
|
-- Create record
|
|
INSERT INTO "dns"."a" ("hostname","zone","address","ttl","type","owner","reverse") VALUES
|
|
(input_hostname,input_zone,input_address,input_ttl,input_type,input_owner,input_reverse);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dns_address:"'||input_address||'","'||input_hostname||'","'||input_zone||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."a" WHERE "address" = input_address AND "hostname" = input_hostname AND "zone" = input_zone);
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dns_address(input_address inet, input_hostname text, input_zone text, input_ttl integer, input_type text, input_reverse boolean, input_owner text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dns_address(input_address inet, input_hostname text, input_zone text, input_ttl integer, input_type text, input_reverse boolean, input_owner text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dns_address(input_address inet, input_hostname text, input_zone text, input_ttl integer, input_type text, input_reverse boolean, input_owner text) IS 'create a new A or AAAA record';
|
|
|
|
|
|
--
|
|
-- Name: cname; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.cname (
|
|
alias character varying(63) NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
hostname character varying(63) NOT NULL,
|
|
address inet NOT NULL,
|
|
ttl integer DEFAULT (api.get_site_configuration('DNS_DEFAULT_TTL'::text))::integer NOT NULL,
|
|
owner text NOT NULL,
|
|
type text DEFAULT 'CNAME'::text NOT NULL,
|
|
zone text DEFAULT api.get_site_configuration('DNS_DEFAULT_ZONE'::text) NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.cname OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE cname; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.cname IS 'CNAME records';
|
|
|
|
|
|
--
|
|
-- Name: create_dns_cname(text, text, text, integer, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dns_cname(input_alias text, input_target text, input_zone text, input_ttl integer, input_owner text) RETURNS SETOF dns.cname
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Validate input
|
|
IF api.validate_domain(input_alias,NULL) IS FALSE THEN
|
|
RAISE EXCEPTION 'Invalid alias (%)',input_alias;
|
|
END IF;
|
|
|
|
-- Set owner
|
|
IF input_owner IS NULL THEN
|
|
input_owner := api.get_current_user();
|
|
END IF;
|
|
|
|
-- Set zone
|
|
IF input_zone IS NULL THEN
|
|
input_zone := api.get_site_configuration('DNS_DEFAULT_ZONE');
|
|
END IF;
|
|
|
|
-- Fill TTL
|
|
IF input_ttl IS NULL THEN
|
|
input_ttl := api.get_site_configuration('DNS_DEFAULT_TTL');
|
|
END IF;
|
|
|
|
-- Lower
|
|
input_target := lower(input_target);
|
|
input_alias := lower(input_alias);
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
-- You specified another owner
|
|
IF input_owner != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only administrators can define a different owner (%).',input_owner;
|
|
END IF;
|
|
-- You own the system
|
|
IF (SELECT "write" FROM api.get_system_permissions(api.get_interface_address_system((SELECT "address" FROM "dns"."a" WHERE "hostname" = input_target AND "zone" = input_zone)))) IS FALSE THEN
|
|
RAISE EXCEPTION 'Permission denied';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check for in use
|
|
IF (SELECT api.check_dns_hostname(input_alias, input_zone)) IS TRUE THEN
|
|
RAISE EXCEPTION 'Record with this hostname and zone already exists';
|
|
END IF;
|
|
|
|
-- Create record
|
|
INSERT INTO "dns"."cname" ("alias","hostname","zone","ttl","owner") VALUES
|
|
(input_alias, input_target, input_zone, input_ttl, input_owner);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dns_cname:"'||input_alias||'","'||input_target||'","'||input_zone||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."cname" WHERE "alias" = input_alias AND "hostname" = input_target AND "zone" = input_zone);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dns_cname(input_alias text, input_target text, input_zone text, input_ttl integer, input_owner text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dns_cname(input_alias text, input_target text, input_zone text, input_ttl integer, input_owner text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dns_cname(input_alias text, input_target text, input_zone text, input_ttl integer, input_owner text) IS 'create a new dns cname record for a host';
|
|
|
|
|
|
--
|
|
-- Name: keys; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.keys (
|
|
keyname text NOT NULL,
|
|
key text NOT NULL,
|
|
enctype text NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
comment text,
|
|
owner text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.keys OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE keys; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.keys IS 'Zone keys';
|
|
|
|
|
|
--
|
|
-- Name: create_dns_key(text, text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dns_key(input_keyname text, input_key text, input_enctype text, input_owner text, input_comment text) RETURNS SETOF dns.keys
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Validate input
|
|
input_keyname := api.validate_nospecial(input_keyname);
|
|
|
|
-- Fill in owner
|
|
IF input_owner IS NULL THEN
|
|
input_owner := api.get_current_user();
|
|
END IF;
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF input_owner != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only administrators can define a different owner (%).',input_owner;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Create new key
|
|
INSERT INTO "dns"."keys"
|
|
("keyname","key","enctype","comment","owner") VALUES
|
|
(input_keyname,input_key,input_enctype,input_comment,input_owner);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dns_key:"'||input_keyname||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."keys" WHERE "keyname" = input_keyname AND "key" = input_key);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dns_key(input_keyname text, input_key text, input_enctype text, input_owner text, input_comment text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dns_key(input_keyname text, input_key text, input_enctype text, input_owner text, input_comment text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dns_key(input_keyname text, input_key text, input_enctype text, input_owner text, input_comment text) IS 'Create new DNS key';
|
|
|
|
|
|
--
|
|
-- Name: mx; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.mx (
|
|
preference integer NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
hostname character varying(63) NOT NULL,
|
|
address inet NOT NULL,
|
|
ttl integer DEFAULT (api.get_site_configuration('DNS_DEFAULT_TTL'::text))::integer NOT NULL,
|
|
owner text NOT NULL,
|
|
zone text DEFAULT api.get_site_configuration('DNS_DEFAULT_ZONE'::text) NOT NULL,
|
|
type text NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.mx OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE mx; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.mx IS 'Mail servers (MX records)';
|
|
|
|
|
|
--
|
|
-- Name: create_dns_mailserver(text, text, integer, integer, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dns_mailserver(input_hostname text, input_zone text, input_preference integer, input_ttl integer, input_owner text) RETURNS SETOF dns.mx
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Set owner
|
|
IF input_owner IS NULL THEN
|
|
input_owner := api.get_current_user();
|
|
END IF;
|
|
|
|
-- Set zone
|
|
IF input_zone IS NULL THEN
|
|
input_zone := api.get_site_configuration('DNS_DEFAULT_ZONE');
|
|
END IF;
|
|
|
|
-- Fill TTL
|
|
IF input_ttl IS NULL THEN
|
|
input_ttl := api.get_site_configuration('DNS_DEFAULT_TTL');
|
|
END IF;
|
|
|
|
-- Lower
|
|
input_hostname := lower(input_hostname);
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
-- You own the zone
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on zone %. You are not owner.',input_zone;
|
|
END IF;
|
|
-- You specified a different owner
|
|
IF input_owner != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only administrators can define a different owner (%).',input_owner;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Create record
|
|
INSERT INTO "dns"."mx" ("hostname","zone","preference","ttl","owner","type") VALUES
|
|
(input_hostname,input_zone,input_preference,input_ttl,input_owner,'MX');
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dns_mailserver:"'||input_hostname||'","'||input_zone||'","'||input_preference||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."mx" WHERE "hostname" = input_hostname AND "zone" = input_zone AND "preference" = input_preference);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dns_mailserver(input_hostname text, input_zone text, input_preference integer, input_ttl integer, input_owner text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dns_mailserver(input_hostname text, input_zone text, input_preference integer, input_ttl integer, input_owner text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dns_mailserver(input_hostname text, input_zone text, input_preference integer, input_ttl integer, input_owner text) IS 'Create a new mailserver MX record for a zone';
|
|
|
|
|
|
--
|
|
-- Name: ns; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.ns (
|
|
zone text NOT NULL,
|
|
ttl integer DEFAULT (api.get_site_configuration('DNS_DEFAULT_TTL'::text))::integer NOT NULL,
|
|
type text DEFAULT 'NS'::text NOT NULL,
|
|
nameserver text NOT NULL,
|
|
address inet NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.ns OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE ns; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.ns IS 'Nameservers (to be inserted as NS records)';
|
|
|
|
|
|
--
|
|
-- Name: create_dns_ns(text, text, inet, integer); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dns_ns(input_zone text, input_nameserver text, input_address inet, input_ttl integer) RETURNS SETOF dns.ns
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Set zone
|
|
IF input_zone IS NULL THEN
|
|
input_zone := api.get_site_configuration('DNS_DEFAULT_ZONE');
|
|
END IF;
|
|
|
|
-- Fill TTL
|
|
IF input_ttl IS NULL THEN
|
|
input_ttl := api.get_site_configuration('DNS_DEFAULT_TTL');
|
|
END IF;
|
|
|
|
-- Lower
|
|
input_nameserver := lower(input_nameserver);
|
|
input_zone := lower(input_zone);
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
-- You own the zone
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on zone %. You are not owner.',input_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Create record
|
|
INSERT INTO "dns"."ns" ("zone","ttl","nameserver","address") VALUES
|
|
(input_zone,input_ttl,input_nameserver,input_address);
|
|
|
|
-- Update TTLs of other zone records since they all need to be the same
|
|
UPDATE "dns"."ns" SET "ttl" = input_ttl WHERE "zone" = input_zone;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dns_ns:"'||input_nameserver||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."ns" WHERE "zone" = input_zone AND "nameserver" = input_nameserver);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dns_ns(input_zone text, input_nameserver text, input_address inet, input_ttl integer) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dns_ns(input_zone text, input_nameserver text, input_address inet, input_ttl integer); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dns_ns(input_zone text, input_nameserver text, input_address inet, input_ttl integer) IS 'create a new NS record for a zone';
|
|
|
|
|
|
--
|
|
-- Name: soa; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.soa (
|
|
zone text DEFAULT api.get_site_configuration('DNS_DEFAULT_ZONE'::text) NOT NULL,
|
|
nameserver text DEFAULT ('ns1.'::text || api.get_site_configuration('DNS_DEFAULT_ZONE'::text)) NOT NULL,
|
|
ttl integer DEFAULT (api.get_site_configuration('DNS_DEFAULT_TTL'::text))::integer NOT NULL,
|
|
contact text DEFAULT ('hostmaster.'::text || api.get_site_configuration('DNS_DEFAULT_ZONE'::text)) NOT NULL,
|
|
serial text DEFAULT '0000000000'::text NOT NULL,
|
|
refresh integer DEFAULT 3600 NOT NULL,
|
|
retry integer DEFAULT 600 NOT NULL,
|
|
expire integer DEFAULT 172800 NOT NULL,
|
|
minimum integer DEFAULT 43200 NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.soa OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE soa; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.soa IS 'SOA records for DNS zones';
|
|
|
|
|
|
--
|
|
-- Name: create_dns_soa(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dns_soa(input_zone text) RETURNS SETOF dns.soa
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to create SOA % denied for user %. Not admin.',input_zone,api.get_current_user();
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Create soa
|
|
INSERT INTO "dns"."soa" SELECT * FROM api.query_dns_soa(input_zone);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dns_soa:"'||input_zone||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."soa" WHERE "zone" = input_zone);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dns_soa(input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dns_soa(input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dns_soa(input_zone text) IS 'Create a new DNS soa';
|
|
|
|
|
|
--
|
|
-- Name: srv; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.srv (
|
|
alias character varying(63) NOT NULL,
|
|
priority integer DEFAULT 0 NOT NULL,
|
|
weight integer DEFAULT 0 NOT NULL,
|
|
port integer NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
hostname character varying(63) NOT NULL,
|
|
address inet NOT NULL,
|
|
ttl integer DEFAULT (api.get_site_configuration('DNS_DEFAULT_TTL'::text))::integer NOT NULL,
|
|
owner text NOT NULL,
|
|
type text DEFAULT 'SRV'::text NOT NULL,
|
|
zone text DEFAULT api.get_site_configuration('DNS_DEFAULT_ZONE'::text) NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.srv OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE srv; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.srv IS 'SRV records';
|
|
|
|
|
|
--
|
|
-- Name: create_dns_srv(text, text, text, integer, integer, integer, integer, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dns_srv(input_alias text, input_target text, input_zone text, input_priority integer, input_weight integer, input_port integer, input_ttl integer, input_owner text) RETURNS SETOF dns.srv
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Validate input
|
|
IF api.validate_srv(input_alias) IS FALSE THEN
|
|
RAISE EXCEPTION 'Invalid alias (%)',input_alias;
|
|
END IF;
|
|
|
|
-- Set owner
|
|
IF input_owner IS NULL THEN
|
|
input_owner := api.get_current_user();
|
|
END IF;
|
|
|
|
-- Set zone
|
|
IF input_zone IS NULL THEN
|
|
input_zone := api.get_site_configuration('DNS_DEFAULT_ZONE');
|
|
END IF;
|
|
|
|
-- Fill TTL
|
|
IF input_ttl IS NULL THEN
|
|
input_ttl := api.get_site_configuration('DNS_DEFAULT_TTL');
|
|
END IF;
|
|
|
|
-- Lower
|
|
input_target := lower(input_target);
|
|
input_alias := lower(input_alias);
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
-- You own the zone
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on zone %. You are not owner.',input_zone;
|
|
END IF;
|
|
-- You specified another owner
|
|
IF input_owner != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only administrators can define a different owner (%).',input_owner;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Create record
|
|
INSERT INTO "dns"."srv" ("alias","hostname","zone","priority","weight","port","ttl","owner") VALUES
|
|
(input_alias, input_target, input_zone, input_priority, input_weight, input_port, input_ttl, input_owner);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dns_srv:"'||input_alias||'","'||input_target||'","'||input_zone||'","'||input_priority||'","'||input_weight||'","'||input_port||'","'||input_ttl||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."srv" WHERE "alias" = input_alias AND "hostname" = input_target AND "zone" = input_zone AND "priority" = input_priority AND "weight" = input_weight AND "port" = input_port);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dns_srv(input_alias text, input_target text, input_zone text, input_priority integer, input_weight integer, input_port integer, input_ttl integer, input_owner text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dns_srv(input_alias text, input_target text, input_zone text, input_priority integer, input_weight integer, input_port integer, input_ttl integer, input_owner text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dns_srv(input_alias text, input_target text, input_zone text, input_priority integer, input_weight integer, input_port integer, input_ttl integer, input_owner text) IS 'create a new dns srv record for a zone';
|
|
|
|
|
|
--
|
|
-- Name: txt; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.txt (
|
|
text text NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
hostname character varying(63) NOT NULL,
|
|
address inet NOT NULL,
|
|
type text DEFAULT 'TXT'::text NOT NULL,
|
|
ttl integer DEFAULT (api.get_site_configuration('DNS_DEFAULT_TTL'::text))::integer NOT NULL,
|
|
owner text NOT NULL,
|
|
zone text DEFAULT api.get_site_configuration('DNS_DEFAULT_ZONE'::text) NOT NULL,
|
|
CONSTRAINT dns_txt_type_check CHECK ((type ~* '^TXT$'::text))
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.txt OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE txt; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.txt IS 'TXT records for hosts';
|
|
|
|
|
|
--
|
|
-- Name: create_dns_txt(text, text, text, integer, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dns_txt(input_hostname text, input_zone text, input_text text, input_ttl integer, input_owner text) RETURNS SETOF dns.txt
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Set owner
|
|
IF input_owner IS NULL THEN
|
|
input_owner := api.get_current_user();
|
|
END IF;
|
|
|
|
-- Set zone
|
|
IF input_zone IS NULL THEN
|
|
input_zone := api.get_site_configuration('DNS_DEFAULT_ZONE');
|
|
END IF;
|
|
|
|
-- Fill TTL
|
|
IF input_ttl IS NULL THEN
|
|
input_ttl := api.get_site_configuration('DNS_DEFAULT_TTL');
|
|
END IF;
|
|
|
|
-- Lower
|
|
input_hostname := lower(input_hostname);
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
-- You own the zone
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on zone %. You are not owner.',input_zone;
|
|
END IF;
|
|
-- You specified a different owner
|
|
IF input_owner != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only administrators can define a different owner (%).',input_owner;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Create record
|
|
INSERT INTO "dns"."txt" ("hostname","zone","text","ttl","owner") VALUES
|
|
(input_hostname,input_zone,input_text,input_ttl,input_owner);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dns_txt:"'||input_hostname||'","'||input_zone||'","'||input_text||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."txt" WHERE "hostname" = input_hostname AND "zone" = input_zone AND "text" = input_text);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dns_txt(input_hostname text, input_zone text, input_text text, input_ttl integer, input_owner text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dns_txt(input_hostname text, input_zone text, input_text text, input_ttl integer, input_owner text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dns_txt(input_hostname text, input_zone text, input_text text, input_ttl integer, input_owner text) IS 'create a new dns TXT record for a host';
|
|
|
|
|
|
--
|
|
-- Name: zones; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.zones (
|
|
zone text DEFAULT api.get_site_configuration('DNS_DEFAULT_ZONE'::text) NOT NULL,
|
|
forward boolean NOT NULL,
|
|
keyname text NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
owner text NOT NULL,
|
|
comment text,
|
|
shared boolean DEFAULT false NOT NULL,
|
|
ddns boolean DEFAULT false NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.zones OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE zones; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.zones IS 'Authoritative DNS zones';
|
|
|
|
|
|
--
|
|
-- Name: create_dns_zone(text, text, boolean, boolean, text, text, boolean); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dns_zone(input_zone text, input_keyname text, input_forward boolean, input_shared boolean, input_owner text, input_comment text, input_ddns boolean) RETURNS SETOF dns.zones
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Validate input
|
|
IF api.validate_domain(NULL,input_zone) IS FALSE THEN
|
|
RAISE EXCEPTION 'Invalid domain (%)',input_zone;
|
|
END IF;
|
|
|
|
-- Fill in owner
|
|
IF input_owner IS NULL THEN
|
|
input_owner = api.get_current_user();
|
|
END IF;
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to create zone % denied for user %. Not admin.',input_zone,api.get_current_user();
|
|
END IF;
|
|
|
|
-- Create zone
|
|
INSERT INTO "dns"."zones" ("zone","keyname","forward","comment","owner","shared","ddns") VALUES
|
|
(input_zone,input_keyname,input_forward,input_comment,input_owner,input_shared,input_ddns);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dns_zone:"'||input_zone||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."zones" WHERE "zone" = input_zone);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dns_zone(input_zone text, input_keyname text, input_forward boolean, input_shared boolean, input_owner text, input_comment text, input_ddns boolean) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dns_zone(input_zone text, input_keyname text, input_forward boolean, input_shared boolean, input_owner text, input_comment text, input_ddns boolean); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dns_zone(input_zone text, input_keyname text, input_forward boolean, input_shared boolean, input_owner text, input_comment text, input_ddns boolean) IS 'Create a new DNS zone';
|
|
|
|
|
|
--
|
|
-- Name: zone_a; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.zone_a (
|
|
hostname text,
|
|
zone text DEFAULT api.get_site_configuration('DNS_DEFAULT_ZONE'::text) NOT NULL,
|
|
type text NOT NULL,
|
|
address inet NOT NULL,
|
|
ttl integer DEFAULT (api.get_site_configuration('DNS_DEFAULT_TTL'::text))::integer NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
CONSTRAINT dns_zone_a_type_check CHECK ((type ~ '^A|AAAA$'::text))
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.zone_a OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE zone_a; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.zone_a IS 'Zone address records';
|
|
|
|
|
|
--
|
|
-- Name: create_dns_zone_a(text, inet, integer); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dns_zone_a(input_zone text, input_address inet, input_ttl integer) RETURNS SETOF dns.zone_a
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Set zone
|
|
IF input_zone IS NULL THEN
|
|
input_zone := api.get_site_configuration('DNS_DEFAULT_ZONE');
|
|
END IF;
|
|
|
|
-- Fill TTL
|
|
IF input_ttl IS NULL THEN
|
|
input_ttl := api.get_site_configuration('DNS_DEFAULT_TTL');
|
|
END IF;
|
|
|
|
-- Check dynamic
|
|
IF input_address << api.get_site_configuration('DYNAMIC_SUBNET')::cidr THEN
|
|
RAISE EXCEPTION 'Zone A cannot be dynamic';
|
|
END IF;
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
-- You own the zone
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'DNS zone % is not shared and you are not owner. Permission denied.',input_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Create record
|
|
INSERT INTO "dns"."zone_a" ("zone","address","ttl") VALUES
|
|
(input_zone,input_address,input_ttl);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_dns_zone_a:"'||input_zone||'","'||input_address||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_a" WHERE "zone" = input_zone AND "address" = input_address);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dns_zone_a(input_zone text, input_address inet, input_ttl integer) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dns_zone_a(input_zone text, input_address inet, input_ttl integer); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dns_zone_a(input_zone text, input_address inet, input_ttl integer) IS 'create a new zone A or AAAA record';
|
|
|
|
|
|
--
|
|
-- Name: zone_txt; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.zone_txt (
|
|
text text NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
hostname character varying(63),
|
|
type text DEFAULT 'TXT'::text NOT NULL,
|
|
ttl integer DEFAULT (api.get_site_configuration('DNS_DEFAULT_TTL'::text))::integer NOT NULL,
|
|
zone text DEFAULT api.get_site_configuration('DNS_DEFAULT_ZONE'::text) NOT NULL,
|
|
address inet DEFAULT '0.0.0.0'::inet
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.zone_txt OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE zone_txt; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.zone_txt IS 'TXT records for zones';
|
|
|
|
|
|
--
|
|
-- Name: create_dns_zone_txt(text, text, text, integer); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_dns_zone_txt(input_hostname text, input_zone text, input_text text, input_ttl integer) RETURNS SETOF dns.zone_txt
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Set zone
|
|
IF input_zone IS NULL THEN
|
|
input_zone := api.get_site_configuration('DNS_DEFAULT_ZONE');
|
|
END IF;
|
|
|
|
-- Fill TTL
|
|
IF input_ttl IS NULL THEN
|
|
input_ttl := api.get_site_configuration('DNS_DEFAULT_TTL');
|
|
END IF;
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
-- You own the zone
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on zone %. You are not owner.',input_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Lower
|
|
input_hostname := lower(input_hostname);
|
|
|
|
-- Create record
|
|
INSERT INTO "dns"."zone_txt" ("hostname","zone","text","ttl") VALUES
|
|
(input_hostname,input_zone,input_text,input_ttl);
|
|
|
|
-- Update TTLs for other null hostname records since they all need to be the same.
|
|
IF input_hostname IS NULL THEN
|
|
UPDATE "dns"."zone_txt" SET "ttl" = input_ttl WHERE "hostname" IS NULL AND "zone" = input_zone;
|
|
END IF;
|
|
|
|
-- Done
|
|
IF input_hostname IS NULL THEN
|
|
PERFORM api.syslog('create_dns_zone_txt:"'||input_zone||'","'||input_text||'","'||input_ttl);
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" WHERE "hostname" IS NULL AND "zone" = input_zone AND "text" = input_text);
|
|
ELSE
|
|
PERFORM api.syslog('create_dns_zone_txt:"'||input_hostname||'","'||input_zone||'","'||input_text||'","'||input_ttl);
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" WHERE "hostname" = input_hostname AND "zone" = input_zone AND "text" = input_text);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_dns_zone_txt(input_hostname text, input_zone text, input_text text, input_ttl integer) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_dns_zone_txt(input_hostname text, input_zone text, input_text text, input_ttl integer); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_dns_zone_txt(input_hostname text, input_zone text, input_text text, input_ttl integer) IS 'create a new dns zone_txt record for a host';
|
|
|
|
|
|
--
|
|
-- Name: groups; Type: TABLE; Schema: management; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE management.groups (
|
|
"group" text NOT NULL,
|
|
comment text,
|
|
privilege text DEFAULT 'USER'::text NOT NULL,
|
|
renew_interval interval DEFAULT (api.get_site_configuration('DEFAULT_RENEW_INTERVAL'::text))::interval NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
CONSTRAINT management_group_privilege_check CHECK ((privilege ~* '^ADMIN|USER|PROGRAM$'::text))
|
|
);
|
|
|
|
|
|
ALTER TABLE management.groups OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE groups; Type: COMMENT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE management.groups IS 'Groups of users with different privilege levels';
|
|
|
|
|
|
--
|
|
-- Name: create_group(text, text, text, interval); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_group(input_group text, input_privilege text, input_comment text, input_interval interval) RETURNS SETOF management.groups
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can create groups.';
|
|
END IF;
|
|
|
|
IF input_interval IS NULL THEN
|
|
input_interval := api.get_site_configuration('DEFAULT_RENEW_INTERVAL');
|
|
END IF;
|
|
|
|
INSERT INTO "management"."groups" ("group","privilege","comment","renew_interval")
|
|
VALUES (input_group, input_privilege, input_comment, input_interval);
|
|
|
|
PERFORM api.syslog('create_group:"'||input_group||'","'||input_privilege||'","'||input_interval||'"');
|
|
RETURN QUERY (SELECT * FROM "management"."groups" WHERE "group" = input_group);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_group(input_group text, input_privilege text, input_comment text, input_interval interval) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_group(input_group text, input_privilege text, input_comment text, input_interval interval); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_group(input_group text, input_privilege text, input_comment text, input_interval interval) IS 'Create a user group';
|
|
|
|
|
|
--
|
|
-- Name: group_members; Type: TABLE; Schema: management; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE management.group_members (
|
|
"group" text NOT NULL,
|
|
"user" text NOT NULL,
|
|
privilege text NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
CONSTRAINT management_group_member_privilege_check CHECK ((privilege ~* '^ADMIN|USER|PROGRAM$'::text))
|
|
);
|
|
|
|
|
|
ALTER TABLE management.group_members OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE group_members; Type: COMMENT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE management.group_members IS 'Map usernames to groups';
|
|
|
|
|
|
--
|
|
-- Name: create_group_member(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_group_member(input_group text, input_user text, input_privilege text) RETURNS SETOF management.group_members
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF api.get_current_user() NOT IN (SELECT * FROM api.get_group_admins(input_group)) THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can create groups.';
|
|
END IF;
|
|
END IF;
|
|
|
|
INSERT INTO "management"."group_members" ("group","user","privilege")
|
|
VALUES (input_group, input_user, input_privilege);
|
|
|
|
PERFORM api.syslog('create_group_member:"'||input_group||'","'||input_user||'","'||input_privilege||'"');
|
|
RETURN QUERY (SELECT * FROM "management"."group_members" WHERE "group" = input_group AND "user" = input_user);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_group_member(input_group text, input_user text, input_privilege text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_group_member(input_group text, input_user text, input_privilege text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_group_member(input_group text, input_user text, input_privilege text) IS 'Assign a user to a group';
|
|
|
|
|
|
--
|
|
-- Name: group_settings; Type: TABLE; Schema: management; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE management.group_settings (
|
|
"group" text NOT NULL,
|
|
privilege text DEFAULT 'USER'::text NOT NULL,
|
|
provider text NOT NULL,
|
|
hostname text,
|
|
id text,
|
|
username text,
|
|
password text,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE management.group_settings OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE group_settings; Type: COMMENT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE management.group_settings IS 'Authentication and provider settings for groups';
|
|
|
|
|
|
--
|
|
-- Name: create_group_settings(text, text, text, text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_group_settings(input_group text, input_provider text, input_id text, input_hostname text, input_username text, input_password text, input_privilege text) RETURNS SETOF management.group_settings
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can create group provider settings';
|
|
END IF;
|
|
|
|
-- Check provider
|
|
IF input_provider !~* 'local|vcloud|ldap|ad' THEN
|
|
RAISE EXCEPTION 'Invalid provider given: %',input_provider;
|
|
END IF;
|
|
|
|
-- NULLs
|
|
IF input_provider ~* 'vcloud|ldap|ad' THEN
|
|
IF input_hostname IS NULL THEN
|
|
RAISE EXCEPTION 'Need to give a hostname.';
|
|
END IF;
|
|
IF input_id IS NULL THEN
|
|
RAISE EXCEPTION 'Need to give an ID.';
|
|
END IF;
|
|
IF input_username IS NULL THEN
|
|
RAISE EXCEPTION 'Need to give a username.';
|
|
END IF;
|
|
if input_password IS NULL THEN
|
|
RAISE EXCEPTION 'Need to give a password.';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check privilege level
|
|
IF input_privilege!~* 'USER|ADMIN' THEN
|
|
RAISE EXCEPTION 'Invalid privilege given: %',input_privilege;
|
|
END IF;
|
|
|
|
INSERT INTO "management"."group_settings" ("group","provider","id","hostname","username","password","privilege")
|
|
VALUES (input_group, input_provider, input_id,input_hostname, input_username, input_password, input_privilege);
|
|
|
|
--PERFORM api.syslog('create_group_settings:"'||input_group||'","'||input_provider||'","'||input_id||'","'||input_hostname||'","'||input_username||'","'||input_privilege||'"');
|
|
RETURN QUERY (SELECT * FROM "management"."group_settings" WHERE "group" = input_group);
|
|
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_group_settings(input_group text, input_provider text, input_id text, input_hostname text, input_username text, input_password text, input_privilege text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_group_settings(input_group text, input_provider text, input_id text, input_hostname text, input_username text, input_password text, input_privilege text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_group_settings(input_group text, input_provider text, input_id text, input_hostname text, input_username text, input_password text, input_privilege text) IS 'Create authentication settings';
|
|
|
|
|
|
--
|
|
-- Name: interfaces; Type: TABLE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE systems.interfaces (
|
|
mac macaddr NOT NULL,
|
|
comment text,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
system_name text,
|
|
name text NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE systems.interfaces OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE interfaces; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE systems.interfaces IS 'Systems have interfaces that connect to the network. This corresponds to your physical hardware.';
|
|
|
|
|
|
--
|
|
-- Name: create_interface(text, macaddr, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_interface(input_system_name text, input_mac macaddr, input_name text, input_comment text) RETURNS SETOF systems.interfaces
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."systems" WHERE "system_name" = input_system_name) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on system %. You are not owner.',input_system_name;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Validate input
|
|
input_name := api.validate_name(input_name);
|
|
|
|
-- Create interface
|
|
INSERT INTO "systems"."interfaces"
|
|
("system_name","mac","comment","last_modifier","name") VALUES
|
|
(input_system_name,input_mac,input_comment,api.get_current_user(),input_name);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_interface:"'||input_mac||'"');
|
|
RETURN QUERY (SELECT * FROM "systems"."interfaces" WHERE "mac" = input_mac);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_interface(input_system_name text, input_mac macaddr, input_name text, input_comment text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_interface(input_system_name text, input_mac macaddr, input_name text, input_comment text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_interface(input_system_name text, input_mac macaddr, input_name text, input_comment text) IS 'Create a new interface on a system';
|
|
|
|
|
|
--
|
|
-- Name: interface_addresses; Type: TABLE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE systems.interface_addresses (
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
comment text,
|
|
address inet NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
config text NOT NULL,
|
|
family integer NOT NULL,
|
|
isprimary boolean NOT NULL,
|
|
renew_date date DEFAULT date((('now'::text)::date + (api.get_site_configuration('DEFAULT_RENEW_INTERVAL'::text))::interval)) NOT NULL,
|
|
mac macaddr NOT NULL,
|
|
class text NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE systems.interface_addresses OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE interface_addresses; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE systems.interface_addresses IS 'Interfaces are assigned IP addresses based on certain rules. If DHCP is being used, then a class may be specified.';
|
|
|
|
|
|
--
|
|
-- Name: create_interface_address(macaddr, inet, text, text, boolean, text, date); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_interface_address(input_mac macaddr, input_address inet, input_config text, input_class text, input_isprimary boolean, input_comment text, input_renew_date date) RETURNS SETOF systems.interface_addresses
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Renew
|
|
IF input_renew_date IS NULL THEN
|
|
input_renew_date := api.get_default_renew_date((SELECT "system_name" FROM "systems"."interfaces" WHERE "mac" = input_mac));
|
|
END IF;
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."interfaces"
|
|
JOIN "systems"."systems" ON "systems"."systems"."system_name" = "systems"."interfaces"."system_name"
|
|
WHERE "systems"."interfaces"."mac" = input_mac) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on interface %. You are not owner.',input_mac;
|
|
END IF;
|
|
|
|
IF input_renew_date != api.get_default_renew_date((SELECT "system_name" FROM "systems"."interfaces" WHERE "mac" = input_mac)) THEN
|
|
RAISE EXCEPTION 'Only administrators can specify a different renew date';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Fill in class
|
|
IF input_class IS NULL THEN
|
|
input_class = api.get_site_configuration('DHCPD_DEFAULT_CLASS');
|
|
END IF;
|
|
|
|
IF input_address << cidr(api.get_site_configuration('DYNAMIC_SUBNET')) AND input_config !~* 'dhcp' THEN
|
|
RAISE EXCEPTION 'Specifified address (%) is only for dynamic DHCP addresses',input_address;
|
|
END IF;
|
|
|
|
IF (SELECT "use" FROM "api"."get_ip_ranges"() WHERE "name" = (SELECT "api"."get_address_range"(input_address))) ~* 'ROAM' THEN
|
|
RAISE EXCEPTION 'Specified address (%) is contained within a Dynamic range',input_address;
|
|
END IF;
|
|
|
|
-- Create address
|
|
INSERT INTO "systems"."interface_addresses" ("mac","address","config","class","comment","last_modifier","isprimary","renew_date") VALUES
|
|
(input_mac,input_address,input_config,input_class,input_comment,api.get_current_user(),input_isprimary,input_renew_date);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_interface_address:"'||input_address||'"');
|
|
RETURN QUERY (SELECT * FROM "systems"."interface_addresses" WHERE "address" = input_address);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_interface_address(input_mac macaddr, input_address inet, input_config text, input_class text, input_isprimary boolean, input_comment text, input_renew_date date) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_interface_address(input_mac macaddr, input_address inet, input_config text, input_class text, input_isprimary boolean, input_comment text, input_renew_date date); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_interface_address(input_mac macaddr, input_address inet, input_config text, input_class text, input_isprimary boolean, input_comment text, input_renew_date date) IS 'create a new address on interface from a specified address';
|
|
|
|
|
|
--
|
|
-- Name: ranges; Type: TABLE; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE ip.ranges (
|
|
first_ip inet NOT NULL,
|
|
last_ip inet NOT NULL,
|
|
comment text,
|
|
use character varying(4) NOT NULL,
|
|
datacenter text DEFAULT api.get_site_configuration('DEFAULT_DATACENTER'::text) NOT NULL,
|
|
zone text NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
name text NOT NULL,
|
|
subnet cidr,
|
|
class text
|
|
);
|
|
|
|
|
|
ALTER TABLE ip.ranges OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE ranges; Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE ip.ranges IS 'Ranges of addresses can be reserved for specific purposes (Autoreg, Dynamics, etc)';
|
|
|
|
|
|
--
|
|
-- Name: create_ip_range(text, inet, inet, cidr, character varying, text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_ip_range(input_name text, input_first_ip inet, input_last_ip inet, input_subnet cidr, input_use character varying, input_class text, input_comment text, input_datacenter text, input_zone text) RETURNS SETOF ip.ranges
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "ip"."subnets" WHERE "subnet" = input_subnet) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on subnet %. You are not owner',input_subnet;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Validate input
|
|
input_name := api.validate_name(input_name);
|
|
|
|
-- Match subnet datacenter
|
|
IF (SELECT "datacenter" FROM "ip"."subnets" WHERE "subnet" = input_subnet) != input_datacenter THEN
|
|
RAISE EXCEPTION 'Subnet/Datacenter mismatch';
|
|
END IF;
|
|
|
|
-- Create new IP range
|
|
INSERT INTO "ip"."ranges" ("name", "first_ip", "last_ip", "subnet", "use", "comment", "class", "datacenter", "zone") VALUES
|
|
(input_name,input_first_ip,input_last_ip,input_subnet,input_use,input_comment,input_class,input_datacenter,input_zone);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_ip_range:"'||input_name||'"');
|
|
RETURN QUERY (SELECT * FROM "ip"."ranges" WHERE "name" = input_name);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_ip_range(input_name text, input_first_ip inet, input_last_ip inet, input_subnet cidr, input_use character varying, input_class text, input_comment text, input_datacenter text, input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_ip_range(input_name text, input_first_ip inet, input_last_ip inet, input_subnet cidr, input_use character varying, input_class text, input_comment text, input_datacenter text, input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_ip_range(input_name text, input_first_ip inet, input_last_ip inet, input_subnet cidr, input_use character varying, input_class text, input_comment text, input_datacenter text, input_zone text) IS 'Create a new range of IP addresses';
|
|
|
|
|
|
--
|
|
-- Name: subnets; Type: TABLE; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE ip.subnets (
|
|
subnet cidr NOT NULL,
|
|
comment text,
|
|
autogen boolean DEFAULT true NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
name text NOT NULL,
|
|
owner text NOT NULL,
|
|
zone text DEFAULT api.get_site_configuration('DNS_DEFAULT_ZONE'::text),
|
|
dhcp_enable boolean DEFAULT false NOT NULL,
|
|
datacenter text DEFAULT api.get_site_configuration('DEFAULT_DATACENTER'::text) NOT NULL,
|
|
vlan integer NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE ip.subnets OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE subnets; Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE ip.subnets IS 'Subnets for which this application has control';
|
|
|
|
|
|
--
|
|
-- Name: create_ip_subnet(cidr, text, text, boolean, boolean, text, text, text, integer); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_ip_subnet(input_subnet cidr, input_name text, input_comment text, input_autogen boolean, input_dhcp boolean, input_zone text, input_owner text, input_datacenter text, input_vlan integer) RETURNS SETOF ip.subnets
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
BEGIN
|
|
-- Validate input
|
|
input_name := api.validate_name(input_name);
|
|
|
|
-- Fill in owner
|
|
IF input_owner IS NULL THEN
|
|
input_owner := api.get_current_user();
|
|
END IF;
|
|
|
|
-- Fill in zone
|
|
IF input_zone IS NULL THEN
|
|
input_zone := api.get_site_configuration('DNS_DEFAULT_ZONE');
|
|
END IF;
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF input_dhcp IS TRUE THEN
|
|
RAISE EXCEPTION 'Permission to create DHCP-enabled subnet % denied for user %',input_subnet,api.get_current_user();
|
|
END IF;
|
|
IF input_owner != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only administrators can define a different owner (%).',input_owner;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Create new subnet
|
|
INSERT INTO "ip"."subnets"
|
|
("subnet","name","comment","autogen","owner","dhcp_enable","zone","datacenter","vlan") VALUES
|
|
(input_subnet,input_name,input_comment,input_autogen,input_owner,input_dhcp,input_zone,input_datacenter,input_vlan);
|
|
|
|
-- Create RDNS zone
|
|
PERFORM api.create_dns_zone(api.get_reverse_domain(input_subnet),(SELECT "keyname" FROM "dns"."zones" WHERE "zone" = input_zone),FALSE,TRUE,input_owner,'Reverse zone for subnet '||text(input_subnet),(SELECT "ddns" FROM "dns"."zones" WHERE "zone" = input_zone));
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_ip_subnet:"'||input_subnet||'"');
|
|
RETURN QUERY (SELECT * FROM "ip"."subnets" WHERE "subnet" = input_subnet);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_ip_subnet(input_subnet cidr, input_name text, input_comment text, input_autogen boolean, input_dhcp boolean, input_zone text, input_owner text, input_datacenter text, input_vlan integer) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_ip_subnet(input_subnet cidr, input_name text, input_comment text, input_autogen boolean, input_dhcp boolean, input_zone text, input_owner text, input_datacenter text, input_vlan integer); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_ip_subnet(input_subnet cidr, input_name text, input_comment text, input_autogen boolean, input_dhcp boolean, input_zone text, input_owner text, input_datacenter text, input_vlan integer) IS 'Create/activate a new subnet';
|
|
|
|
|
|
--
|
|
-- Name: hosts; Type: TABLE; Schema: libvirt; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE libvirt.hosts (
|
|
system_name text NOT NULL,
|
|
uri text NOT NULL,
|
|
password text,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE libvirt.hosts OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE hosts; Type: COMMENT; Schema: libvirt; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE libvirt.hosts IS 'VM hosts';
|
|
|
|
|
|
--
|
|
-- Name: create_libvirt_host(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_libvirt_host(input_system text, input_uri text, input_password text) RETURNS SETOF libvirt.hosts
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Only admins can create VM hosts';
|
|
END IF;
|
|
|
|
IF (SELECT "type" FROM "systems"."systems" WHERE "system_name" = input_system) != 'VM Host' THEN
|
|
RAISE EXCEPTION 'System type mismatch. You need a VM Host.';
|
|
END IF;
|
|
|
|
INSERT INTO "libvirt"."hosts" ("system_name","uri","password")
|
|
VALUES (input_system, input_uri, input_password);
|
|
|
|
RETURN QUERY (SELECT * FROM "libvirt"."hosts" WHERE "system_name" = input_system);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_libvirt_host(input_system text, input_uri text, input_password text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_libvirt_host(input_system text, input_uri text, input_password text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_libvirt_host(input_system text, input_uri text, input_password text) IS 'Create libvirt connection settings for a system';
|
|
|
|
|
|
--
|
|
-- Name: platforms; Type: TABLE; Schema: libvirt; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE libvirt.platforms (
|
|
platform_name text NOT NULL,
|
|
definition text NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE libvirt.platforms OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE platforms; Type: COMMENT; Schema: libvirt; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE libvirt.platforms IS 'Libvirt definitions for VM platforms';
|
|
|
|
|
|
--
|
|
-- Name: create_libvirt_platform(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_libvirt_platform(input_name text, input_definition text) RETURNS SETOF libvirt.platforms
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied: Not admin!';
|
|
END IF;
|
|
|
|
INSERT INTO "libvirt"."platforms" ("platform_name","definition") VALUES (input_name, input_definition);
|
|
|
|
RETURN QUERY (SELECT * FROM "libvirt"."platforms" WHERE "platform_name" = input_name);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_libvirt_platform(input_name text, input_definition text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_libvirt_platform(input_name text, input_definition text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_libvirt_platform(input_name text, input_definition text) IS 'Store a definition of a libvirt platform';
|
|
|
|
|
|
--
|
|
-- Name: snmp; Type: TABLE; Schema: network; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE network.snmp (
|
|
system_name text NOT NULL,
|
|
address inet NOT NULL,
|
|
ro_community text,
|
|
rw_community text,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE network.snmp OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE snmp; Type: COMMENT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE network.snmp IS 'SNMP community settings for network systems';
|
|
|
|
|
|
--
|
|
-- Name: create_network_snmp(text, inet, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_network_snmp(input_system text, input_address inet, input_ro text, input_rw text) RETURNS SETOF network.snmp
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Address
|
|
IF input_address IS NULL THEN
|
|
input_address := api.get_system_primary_address(input_system);
|
|
END IF;
|
|
|
|
-- Match address against system
|
|
IF(api.get_interface_address_system(input_address) != input_system) THEN
|
|
RAISE EXCEPTION 'Address % is not a part of the system %',input_address,input_system;
|
|
END IF;
|
|
|
|
-- Don't allow dynamic IPs
|
|
IF input_address << api.get_site_configuration('DYNAMIC_SUBNET')::cidr THEN
|
|
RAISE EXCEPTION 'System address cannot be dynamic';
|
|
END IF;
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."systems" WHERE "system_name" = input_system) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied: you are not owner';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Create it
|
|
INSERT INTO "network"."snmp" ("system_name","address","ro_community","rw_community")
|
|
VALUES (input_system, input_address, input_ro, input_rw);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_network_snmp:"'||input_system||'"');
|
|
RETURN QUERY (SELECT * FROM "network"."snmp" WHERE "system_name" = input_system);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_network_snmp(input_system text, input_address inet, input_ro text, input_rw text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_network_snmp(input_system text, input_address inet, input_ro text, input_rw text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_network_snmp(input_system text, input_address inet, input_ro text, input_rw text) IS 'Create a set of credentials for a system';
|
|
|
|
|
|
--
|
|
-- Name: platforms; Type: TABLE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE systems.platforms (
|
|
platform_name text NOT NULL,
|
|
architecture text NOT NULL,
|
|
disk text NOT NULL,
|
|
cpu text NOT NULL,
|
|
memory integer NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE systems.platforms OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE platforms; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE systems.platforms IS 'Platform templates of a system';
|
|
|
|
|
|
--
|
|
-- Name: create_platform(text, text, text, text, integer); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_platform(input_name text, input_architecture text, input_disk text, input_cpu text, input_memory integer) RETURNS SETOF systems.platforms
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied to create platform: not admin';
|
|
END IF;
|
|
|
|
INSERT INTO "systems"."platforms" ("platform_name","architecture","disk","cpu","memory")
|
|
VALUES (input_name, input_architecture, input_disk, input_cpu, input_memory);
|
|
|
|
PERFORM api.syslog('create_platform:"'||input_name||'"');
|
|
RETURN QUERY (SELECT * FROM "systems"."platforms" WHERE "platform_name" = input_name);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_platform(input_name text, input_architecture text, input_disk text, input_cpu text, input_memory integer) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_platform(input_name text, input_architecture text, input_disk text, input_cpu text, input_memory integer); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_platform(input_name text, input_architecture text, input_disk text, input_cpu text, input_memory integer) IS 'Create a new hardware platform';
|
|
|
|
|
|
--
|
|
-- Name: range_groups; Type: TABLE; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE ip.range_groups (
|
|
range_name text NOT NULL,
|
|
group_name text NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE ip.range_groups OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE range_groups; Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE ip.range_groups IS 'Associate ranges to groups of users';
|
|
|
|
|
|
--
|
|
-- Name: create_range_group(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_range_group(input_range text, input_group text) RETURNS SETOF ip.range_groups
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Only admins can assign range resources to groups';
|
|
END IF;
|
|
|
|
-- Create
|
|
INSERT INTO "ip"."range_groups" ("range_name","group_name") VALUES (input_range, input_group);
|
|
|
|
-- Return
|
|
PERFORM api.syslog('create_range_group:"'||input_range||'","'||input_group||'"');
|
|
RETURN QUERY (SELECT * FROM "ip"."range_groups" WHERE "group_name" = input_group AND "range_name" = input_range);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_range_group(input_range text, input_group text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_range_group(input_range text, input_group text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_range_group(input_range text, input_group text) IS 'Assign a range to a group';
|
|
|
|
|
|
--
|
|
-- Name: configuration; Type: TABLE; Schema: management; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE management.configuration (
|
|
option text NOT NULL,
|
|
value text NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE management.configuration OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE configuration; Type: COMMENT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE management.configuration IS 'Site specific configuration directives';
|
|
|
|
|
|
--
|
|
-- Name: create_site_configuration(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_site_configuration(input_directive text, input_value text) RETURNS SETOF management.configuration
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can create site directives';
|
|
END IF;
|
|
|
|
-- Create directive
|
|
INSERT INTO "management"."configuration" VALUES (input_directive, input_value);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_site_configuration:"'||input_directive||'","'||input_value||'"');
|
|
RETURN QUERY (SELECT * FROM "management"."configuration" WHERE "option" = input_directive AND "value" = input_value);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_site_configuration(input_directive text, input_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_site_configuration(input_directive text, input_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_site_configuration(input_directive text, input_value text) IS 'Create a new site configuration directive';
|
|
|
|
|
|
--
|
|
-- Name: systems; Type: TABLE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE systems.systems (
|
|
system_name text NOT NULL,
|
|
owner text NOT NULL,
|
|
"group" text DEFAULT api.get_site_configuration('DEFAULT_LOCAL_USER_GROUP'::text) NOT NULL,
|
|
comment text,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
type text,
|
|
os_name text,
|
|
last_modifier text NOT NULL,
|
|
platform_name text NOT NULL,
|
|
asset text,
|
|
datacenter text DEFAULT api.get_site_configuration('DEFAULT_DATACENTER'::text) NOT NULL,
|
|
location text
|
|
);
|
|
|
|
|
|
ALTER TABLE systems.systems OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE systems; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE systems.systems IS 'Systems are devices that connect to the network.';
|
|
|
|
|
|
--
|
|
-- Name: create_system(text, text, text, text, text, text, text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_system(input_system_name text, input_owner text, input_type text, input_os_name text, input_comment text, input_group text, input_platform text, input_asset text, input_datacenter text, input_location text) RETURNS SETOF systems.systems
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Validate input
|
|
input_system_name := api.validate_name(input_system_name);
|
|
|
|
-- Fill in username
|
|
IF input_owner IS NULL THEN
|
|
input_owner := api.get_current_user();
|
|
END IF;
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF input_owner != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only administrators can define a different owner (%).',input_owner;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Insert new system
|
|
INSERT INTO "systems"."systems"
|
|
("system_name","owner","type","os_name","comment","last_modifier","group","platform_name","asset","datacenter","location") VALUES
|
|
(input_system_name,input_owner,input_type,input_os_name,input_comment,api.get_current_user(),input_group,input_platform,input_asset,input_datacenter,input_location);
|
|
|
|
-- Done
|
|
PERFORM api.syslog('create_system:"'||input_system_name||'"');
|
|
RETURN QUERY (SELECT * FROM "systems"."systems" WHERE "system_name" = input_system_name);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_system(input_system_name text, input_owner text, input_type text, input_os_name text, input_comment text, input_group text, input_platform text, input_asset text, input_datacenter text, input_location text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_system(input_system_name text, input_owner text, input_type text, input_os_name text, input_comment text, input_group text, input_platform text, input_asset text, input_datacenter text, input_location text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_system(input_system_name text, input_owner text, input_type text, input_os_name text, input_comment text, input_group text, input_platform text, input_asset text, input_datacenter text, input_location text) IS 'Create a new system';
|
|
|
|
|
|
--
|
|
-- Name: create_system_quick(text, text, text, macaddr, inet, text, text, boolean); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_system_quick(input_system_name text, input_owner text, input_group text, input_mac macaddr, input_address inet, input_zone text, input_config text, input_dns boolean) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
PERFORM api.create_system(
|
|
input_system_name,
|
|
input_owner,
|
|
api.get_site_configuration('DEFAULT_SYSTEM_TYPE'),
|
|
'Other',
|
|
null,
|
|
input_group,
|
|
api.get_site_configuration('DEFAULT_SYSTEM_PLATFORM'),
|
|
null,
|
|
api.get_site_configuration('DEFAULT_DATACENTER'),
|
|
null
|
|
);
|
|
PERFORM api.create_interface(
|
|
input_system_name,
|
|
input_mac,
|
|
api.get_site_configuration('DEFAULT_INTERFACE_NAME'),
|
|
null
|
|
);
|
|
PERFORM api.create_interface_address(
|
|
input_mac,
|
|
input_address,
|
|
input_config,
|
|
api.get_site_configuration('DHCPD_DEFAULT_CLASS'),
|
|
TRUE,
|
|
null,
|
|
null
|
|
);
|
|
IF input_dns IS TRUE THEN
|
|
PERFORM api.create_dns_address(
|
|
input_address,
|
|
lower(regexp_replace(input_system_name,' ','-')),
|
|
input_zone,
|
|
null,
|
|
null,
|
|
TRUE,
|
|
input_owner
|
|
);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_system_quick(input_system_name text, input_owner text, input_group text, input_mac macaddr, input_address inet, input_zone text, input_config text, input_dns boolean) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_system_quick(input_system_name text, input_owner text, input_group text, input_mac macaddr, input_address inet, input_zone text, input_config text, input_dns boolean); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_system_quick(input_system_name text, input_owner text, input_group text, input_mac macaddr, input_address inet, input_zone text, input_config text, input_dns boolean) IS 'Create a full system in one call';
|
|
|
|
|
|
--
|
|
-- Name: vlans; Type: TABLE; Schema: network; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE network.vlans (
|
|
datacenter text NOT NULL,
|
|
vlan integer NOT NULL,
|
|
name text NOT NULL,
|
|
comment text,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE network.vlans OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE vlans; Type: COMMENT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE network.vlans IS 'VLANs in the organization';
|
|
|
|
|
|
--
|
|
-- Name: create_vlan(text, integer, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.create_vlan(input_datacenter text, input_vlan integer, input_name text, input_comment text) RETURNS SETOF network.vlans
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Only admins can create VLANs';
|
|
END IF;
|
|
|
|
INSERT INTO "network"."vlans" ("datacenter","vlan","name","comment")
|
|
VALUES (input_datacenter, input_vlan, input_name, input_comment);
|
|
|
|
PERFORM api.syslog('create_vlan:"'||input_datacenter||'","'||input_vlan||'"');
|
|
RETURN QUERY (SELECT * FROM "network"."vlans" WHERE "datacenter" = input_datacenter AND "vlan" = input_vlan);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.create_vlan(input_datacenter text, input_vlan integer, input_name text, input_comment text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION create_vlan(input_datacenter text, input_vlan integer, input_name text, input_comment text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.create_vlan(input_datacenter text, input_vlan integer, input_name text, input_comment text) IS 'Create a VLAN';
|
|
|
|
|
|
--
|
|
-- Name: deinitialize(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.deinitialize() RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
DROP TABLE IF EXISTS "user_privileges";
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.deinitialize() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION deinitialize(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.deinitialize() IS 'Reset user permissions to activate a new user';
|
|
|
|
|
|
--
|
|
-- Name: dns_clean_zone_a(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.dns_clean_zone_a(input_zone text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
DECLARE
|
|
AuditData RECORD;
|
|
DnsKeyName TEXT;
|
|
DnsKey TEXT;
|
|
DnsServer INET;
|
|
DnsRecord TEXT;
|
|
ReturnCode TEXT;
|
|
|
|
BEGIN
|
|
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Non-admin users are not allowed to clean zones';
|
|
END IF;
|
|
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key","address"
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."ns"
|
|
JOIN "dns"."zones" ON "dns"."ns"."zone" = "dns"."zones"."zone"
|
|
JOIN "dns"."keys" ON "dns"."zones"."keyname" = "dns"."keys"."keyname"
|
|
WHERE "dns"."ns"."zone" = input_zone AND "dns"."ns"."nameserver" IN (SELECT "nameserver" FROM "dns"."soa" WHERE "dns"."soa"."zone" = input_zone);
|
|
|
|
FOR AuditData IN (
|
|
SELECT
|
|
"audit_data"."address",
|
|
"audit_data"."type",
|
|
"host" AS "bind-forward",
|
|
"dns"."a"."hostname"||'.'||"dns"."a"."zone" AS "impulse-forward"
|
|
FROM api.dns_zone_audit(input_zone) AS "audit_data"
|
|
LEFT JOIN "dns"."a" ON "dns"."a"."address" = "audit_data"."address"
|
|
WHERE "audit_data"."type" ~* '^A|AAAA$'
|
|
ORDER BY "audit_data"."address"
|
|
) LOOP
|
|
-- Delete the forward
|
|
DnsRecord := AuditData."bind-forward";
|
|
ReturnCode := api.nsupdate(input_zone,DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when deleting forward %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
-- If it's static, create the correct one
|
|
IF (SELECT "config" FROM "systems"."interface_addresses" WHERE "address" = AuditData."address") ~* 'static' AND AuditData."impulse-forward" IS NOT NULL THEN
|
|
-- Forward
|
|
DnsRecord := AuditData."impulse-forward"||' '||AuditData."ttl"||' '||AuditData."type"||' '||host(AuditData."address");
|
|
ReturnCode := api.nsupdate(input_zone,DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when creating forward %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
END IF;
|
|
END LOOP;
|
|
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.dns_clean_zone_a(input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION dns_clean_zone_a(input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.dns_clean_zone_a(input_zone text) IS 'Erase all non-IMPULSE controlled A records from a zone.';
|
|
|
|
|
|
--
|
|
-- Name: dns_clean_zone_ptr(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.dns_clean_zone_ptr(input_zone text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
AuditData RECORD;
|
|
DnsKeyName TEXT;
|
|
DnsKey TEXT;
|
|
DnsServer INET;
|
|
DnsRecord TEXT;
|
|
ReturnCode TEXT;
|
|
|
|
BEGIN
|
|
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Non-admin users are not allowed to clean zones';
|
|
END IF;
|
|
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key","dns"."ns"."address"
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."ns"
|
|
JOIN "dns"."zones" ON "dns"."ns"."zone" = "dns"."zones"."zone"
|
|
JOIN "dns"."keys" ON "dns"."zones"."keyname" = "dns"."keys"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."ns"."zone"
|
|
WHERE "dns"."ns"."nameserver" = "dns"."soa"."nameserver"
|
|
AND "dns"."ns"."zone" = (SELECT "ip"."subnets"."zone" FROM "ip"."subnets" WHERE api.get_reverse_domain("subnet") = input_zone);
|
|
|
|
FOR AuditData IN (
|
|
SELECT
|
|
"audit_data"."host",
|
|
"audit_data"."target" AS "bind-reverse",
|
|
"dns"."a"."hostname"||'.'||"dns"."a"."zone" AS "impulse-reverse",
|
|
"dns"."a"."ttl" AS "ttl",
|
|
"audit_data"."type" AS "type"
|
|
FROM api.dns_zone_audit(input_zone) AS "audit_data"
|
|
LEFT JOIN "dns"."a" ON api.get_reverse_domain("dns"."a"."address") = "audit_data"."host"
|
|
WHERE "audit_data"."type"='PTR'
|
|
) LOOP
|
|
DnsRecord := AuditData."host";
|
|
ReturnCode := api.nsupdate(input_zone,DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when deleting reverse %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
IF (SELECT "config" FROM "systems"."interface_addresses" WHERE api.get_reverse_domain("address") = AuditData."host") ~* 'static' AND AuditData."impulse-reverse" IS NOT NULL THEN
|
|
DnsRecord := AuditData."host"||' '||AuditData."ttl"||' '||AuditData."type"||' '||AuditData."impulse-reverse";
|
|
ReturnCode := api.nsupdate(input_zone,DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when creating reverse %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
END IF;
|
|
|
|
END LOOP;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.dns_clean_zone_ptr(input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION dns_clean_zone_ptr(input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.dns_clean_zone_ptr(input_zone text) IS 'Clean all incorrect pointer records in a reverse zone';
|
|
|
|
|
|
--
|
|
-- Name: dns_forward_lookup(text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.dns_forward_lookup(text) RETURNS inet
|
|
LANGUAGE plperlu
|
|
AS $_X$
|
|
use Socket;
|
|
|
|
my $hostname = $_[0];
|
|
#my $ipaddr = `host $hostname | cut -d ' ' -f 4`;
|
|
$packed_ip = gethostbyname("$hostname");
|
|
if (defined $packed_ip) {
|
|
$ip_address = inet_ntoa($packed_ip);
|
|
}
|
|
return $ip_address;
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.dns_forward_lookup(text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: dns_resolve(text, text, integer); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.dns_resolve(input_hostname text, input_zone text, input_family integer) RETURNS inet
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_family IS NULL THEN
|
|
RETURN (SELECT "address" FROM "dns"."a" WHERE "hostname" = input_hostname AND "zone" = input_zone LIMIT 1);
|
|
ELSE
|
|
RETURN (SELECT "address" FROM "dns"."a" WHERE "hostname" = input_hostname AND "zone" = input_zone AND family("address") = input_family);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.dns_resolve(input_hostname text, input_zone text, input_family integer) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION dns_resolve(input_hostname text, input_zone text, input_family integer); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.dns_resolve(input_hostname text, input_zone text, input_family integer) IS 'Resolve a hostname/zone to its IP address';
|
|
|
|
|
|
--
|
|
-- Name: dns_zone_audit(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.dns_zone_audit(input_zone text) RETURNS SETOF dns.zone_audit_data
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Create a temporary table to store record data in
|
|
DROP TABLE IF EXISTS "audit";
|
|
CREATE TEMPORARY TABLE "audit" (
|
|
host TEXT, ttl INTEGER, type TEXT, address INET, port INTEGER, weight INTEGER, priority INTEGER, preference INTEGER, target TEXT, text TEXT, contact TEXT, serial TEXT, refresh INTEGER, retry INTEGER, expire INTEGER, minimum INTEGER);
|
|
|
|
-- Put AXFR data into the table
|
|
IF (SELECT "forward" FROM "dns"."zones" WHERE "zone" = input_zone) IS TRUE THEN
|
|
INSERT INTO "audit"
|
|
(SELECT * FROM "api"."query_axfr"(input_zone, (SELECT "nameserver" FROM "dns"."soa" WHERE "zone" = input_zone)));
|
|
ELSE
|
|
INSERT INTO "audit" (SELECT * FROM "api"."query_axfr"(input_zone, (SELECT "nameserver" FROM "dns"."soa" WHERE "zone" = (SELECT "zone" FROM "ip"."subnets" WHERE api.get_reverse_domain("subnet") = input_zone))));
|
|
END IF;
|
|
|
|
-- Update the SOA table with the latest serial
|
|
PERFORM api.modify_dns_soa(input_zone,'serial',(SELECT "api"."query_zone_serial"(input_zone)));
|
|
|
|
IF (SELECT "forward" FROM "dns"."zones" WHERE "zone" = input_zone) IS TRUE THEN
|
|
-- Remove all records that IMPULSE contains
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","address") IN (SELECT "hostname"||'.'||"zone" AS "host","ttl","type","address" FROM "dns"."a");
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","target","port","weight","priority") IN (SELECT "alias"||'.'||"zone" AS "host","ttl","type","hostname"||'.'||"zone" as "target","port","weight","priority" FROM "dns"."srv");
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","target") IN (SELECT "alias"||'.'||"zone" AS "host","ttl","type","hostname"||'.'||"zone" as "target" FROM "dns"."cname");
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","preference") IN (SELECT "hostname"||'.'||"zone" AS "host","ttl","type","preference" FROM "dns"."mx");
|
|
DELETE FROM "audit" WHERE ("host","ttl","type") IN (SELECT "nameserver" AS "host","ttl","type" FROM "dns"."ns");
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","text") IN (SELECT "hostname"||'.'||"zone" AS "host","ttl","type","text" FROM "dns"."txt");
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","target","contact","serial","refresh","retry","expire","minimum") IN
|
|
(SELECT "zone" as "host","ttl",'SOA'::text as "type","nameserver" as "target","contact","serial","refresh","retry","expire","minimum" FROM "dns"."soa");
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","text") IN (SELECT "hostname"||'.'||"zone" AS "host","ttl","type","text" FROM "dns"."zone_txt");
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","text") IN (SELECT "zone" AS "host","ttl","type","text" FROM "dns"."zone_txt");
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","address") IN (SELECT "zone" AS "host","ttl","type","address" FROM "dns"."zone_a");
|
|
|
|
-- DynamicDNS records have TXT data placed by the DHCP server. Don't count those.
|
|
DELETE FROM "audit" WHERE ("host") IN (SELECT "hostname"||'.'||"zone" AS "host" FROM "api"."get_dhcpd_dynamic_hosts"() WHERE "hostname" IS NOT NULL) AND "type" = 'TXT';
|
|
-- So do DHCP'd records;
|
|
DELETE FROM "audit" WHERE ("host") IN (SELECT "hostname"||'.'||"zone" AS "host" FROM "dns"."a" JOIN "systems"."interface_addresses" ON "systems"."interface_addresses"."address" = "dns"."a"."address" WHERE "config"='dhcp') AND "type"='TXT';
|
|
ELSE
|
|
-- Remove constant address records
|
|
DELETE FROM "audit" WHERE ("host","target","type") IN (SELECT api.get_reverse_domain("address") as "host","hostname"||'.'||"zone" as "target",'PTR'::text AS "type" FROM "dns"."a");
|
|
-- Remove Dynamics
|
|
DELETE FROM "audit" WHERE ("target","type") IN (SELECT "hostname"||'.'||"zone" as "target",'PTR'::text AS "type" FROM "dns"."a" JOIN "systems"."interface_addresses" ON "systems"."interface_addresses"."address" = "dns"."a"."address" WHERE "config"='dhcp');
|
|
-- Remove NS records;
|
|
DELETE FROM "audit" WHERE ("host","ttl","type") IN (SELECT "nameserver" AS "host","ttl","type" FROM "dns"."ns");
|
|
-- Remove SOA;
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","target","contact","serial","refresh","retry","expire","minimum") IN
|
|
(SELECT "zone" as "host","ttl",'SOA'::text as "type","nameserver" as "target","contact","serial","refresh","retry","expire","minimum" FROM "dns"."soa" WHERE "zone" = input_zone);
|
|
-- Remove TXT
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","text") IN (SELECT "hostname"||'.'||"zone" AS "host","ttl","type","text" FROM "dns"."zone_txt");
|
|
DELETE FROM "audit" WHERE ("host","ttl","type","text") IN (SELECT "zone" AS "host","ttl","type","text" FROM "dns"."zone_txt");
|
|
END IF;
|
|
|
|
-- What's left is data that IMPULSE has no idea of
|
|
RETURN QUERY (SELECT * FROM "audit");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.dns_zone_audit(input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION dns_zone_audit(input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.dns_zone_audit(input_zone text) IS 'Perform an audit of IMPULSE zone data against server zone data';
|
|
|
|
|
|
--
|
|
-- Name: exec(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.exec(text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
EXECUTE $1;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.exec(text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION exec(text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.exec(text) IS 'Execute a query in a plpgsql context';
|
|
|
|
|
|
--
|
|
-- Name: generate_dhcpd6_config(); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.generate_dhcpd6_config() RETURNS void
|
|
LANGUAGE plperlu
|
|
AS $_X$ # Script written by Anthony Gargiulo
|
|
# Altered for IPv6 by Jordan Rodgers
|
|
use warnings;
|
|
no warnings 'redefine';
|
|
|
|
# First things first. defining the subroutines that make up this script.
|
|
|
|
# Global Options
|
|
sub global_opts
|
|
{
|
|
my ($row, $option, $value, $output);
|
|
my $global_options = spi_query("SELECT * FROM api.get_dhcpd_global_options()");
|
|
while (defined($row = spi_fetchrow($global_options)))
|
|
{
|
|
$option = $row->{option};
|
|
$value = $row->{value};
|
|
$output .= "$option $value;\n"
|
|
}
|
|
return $output;
|
|
} # end global options
|
|
|
|
# DNS keys added here
|
|
sub dns_keys
|
|
{
|
|
my $keys = spi_query("SELECT * FROM api.get_dhcpd_dns_keys()");
|
|
my ($keyname, $key, $enctype, $row, $output);
|
|
while (defined ($row = spi_fetchrow($keys)))
|
|
{
|
|
$keyname = $row->{keyname};
|
|
$key = $row->{key};
|
|
$enctype = $row->{enctype};
|
|
$output .= "key $keyname {\n algorithm ${enctype};\n secret \"$key\";\n}\n";
|
|
}
|
|
return $output;
|
|
}# end DNS keys
|
|
|
|
# Zones are added here.
|
|
sub forward_zones
|
|
{
|
|
my $zones = spi_query("SELECT * FROM api.get_dhcpd_forward_zones()");
|
|
my ($zone, $keyname, $primary_ns, $row, $output);
|
|
$output = "";
|
|
while (defined ($row = spi_fetchrow($zones)))
|
|
{
|
|
$zone = $row->{zone};
|
|
$keyname = $row->{keyname};
|
|
$primary_ns = $row->{primary_ns};
|
|
$output .= "zone $zone {\n primary ${primary_ns};\n key ${keyname};\n}\n";
|
|
}
|
|
return $output;
|
|
}# end forward zones
|
|
|
|
# Zones are added here.
|
|
sub reverse_zones
|
|
{
|
|
my $zones = spi_query("SELECT * FROM api.get_dhcpd6_reverse_zones()");
|
|
my ($zone, $keyname, $primary_ns, $row, $output);
|
|
$output = "";
|
|
while (defined ($row = spi_fetchrow($zones)))
|
|
{
|
|
$zone = $row->{zone};
|
|
$keyname = $row->{keyname};
|
|
$primary_ns = $row->{primary_ns};
|
|
$output .= "zone $zone {\n primary ${primary_ns};\n key ${keyname};\n}\n";
|
|
}
|
|
return $output;
|
|
}# end reverse zones
|
|
|
|
# DHCP Classes
|
|
sub dhcp_classes
|
|
{
|
|
my $classes = spi_query("SELECT class,comment FROM api.get_dhcpd_classes()");
|
|
my ($class, $comment, $row, $output);
|
|
while (defined($row = spi_fetchrow($classes)))
|
|
{
|
|
$class = $row->{class};
|
|
$comment = $row->{comment};
|
|
$output .= "class \"$class\" {\n";
|
|
$output .= " # ${comment}\n" if(defined($comment));
|
|
$output .= &dhcp_class_options($class);
|
|
$output .= "}\n\n";
|
|
}
|
|
return $output;
|
|
}# end &dhcp_classes
|
|
|
|
# DHCP Class options
|
|
sub dhcp_class_options
|
|
{
|
|
my $class = $_[0];
|
|
my $options = spi_query("SELECT * FROM api.get_dhcpd_class_options('$class')");
|
|
my ($option, $value, $row, $output);
|
|
while (defined($row = spi_fetchrow($options)))
|
|
{
|
|
$option = $row->{option};
|
|
$value = $row->{value};
|
|
$output .= " " . $option . ' ' . $value . ";\n";
|
|
}
|
|
return $output;
|
|
}# end &dhcp_class_options
|
|
|
|
# Shared networks
|
|
sub shared_networks
|
|
{
|
|
my $networks = spi_query("SELECT get_dhcpd_shared_networks FROM api.get_dhcpd_shared_networks()");
|
|
my ($network, $row, $output, $subnets);
|
|
|
|
while (defined($row = spi_fetchrow($networks)))
|
|
{
|
|
$network = $row->{get_dhcpd_shared_networks};
|
|
$subnets = &subnets($network);
|
|
if ($subnets)
|
|
{
|
|
$output .= "shared-network " . $network . " {\n\n";
|
|
$output .= $subnets;
|
|
$output .= "}\n\n";
|
|
}
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
# Subnets (for shared networks)
|
|
sub subnets
|
|
{
|
|
my $shared_net = $_[0];
|
|
# COHOE: THIS QUERY STRING IS QUITE VERBOSE, I HOPE YOU ARE HAPPY
|
|
my $query = "select get_dhcpd_shared_network_subnets as subnets, netmask(get_dhcpd_shared_network_subnets) ";
|
|
$query .= "from api.get_dhcpd_shared_network_subnets('$shared_net')";
|
|
my $subnets = spi_query($query);
|
|
|
|
# $subnet = ip + netmask in slash notation; i.e. 10.21.49.0/24
|
|
# $net = only the network address; i.e. 10.21.49.0
|
|
# $mask = netmask in dotted decimal notation; i.e. 255.255.255.0
|
|
my ($subnet, $net, $mask, $row, $output);
|
|
|
|
while (defined($row = spi_fetchrow($subnets)))
|
|
{
|
|
$subnet = $row->{subnets};
|
|
# Dirty way to only do IPv6 subnets
|
|
if (index($subnet, ':') != -1)
|
|
{
|
|
$net = substr($subnet, 0, index($subnet, "/"));
|
|
$mask = $row->{netmask};
|
|
$output .= " subnet6 $subnet {\n ";
|
|
$output .= " authoritative;";
|
|
my $subnet_option = &subnet_options($subnet);
|
|
if(defined($subnet_option))
|
|
{
|
|
$output .= $subnet_option;
|
|
}
|
|
my $subnet_range = &subnet_ranges($subnet);
|
|
if(defined($subnet_range))
|
|
{
|
|
$output .= $subnet_range;
|
|
}
|
|
$output .= "\n }\n\n";
|
|
}
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
# Subnet options
|
|
sub subnet_options
|
|
{
|
|
my $subnet = $_[0];
|
|
my $options = spi_query("SELECT option,value from api.get_dhcpd_subnet_options('$subnet')");
|
|
my ($option, $value, $row, $output);
|
|
while (defined($row = spi_fetchrow($options)))
|
|
{
|
|
$option = $row->{option};
|
|
$value = $row->{value};
|
|
$output .= "\n $option $value;";
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
# Subnet ranges
|
|
sub subnet_ranges
|
|
{
|
|
my $subnet = $_[0];
|
|
my $pool = spi_query("SELECT name,first_ip,last_ip,class from api.get_dhcpd_subnet_ranges('$subnet')");
|
|
my ($range_name, $first_ip, $last_ip, $class, $row, $output);
|
|
$output="";
|
|
|
|
while (defined($row = spi_fetchrow($pool)))
|
|
{
|
|
$range_name = $row->{name};
|
|
$first_ip = $row->{first_ip};
|
|
$last_ip = $row->{last_ip};
|
|
$class = $row->{class};
|
|
$output .= "\n pool {\n range $first_ip $last_ip;\n failover peer \"dhcpfailover\";";
|
|
{
|
|
my $range_options = spi_query("SELECT * from api.get_dhcpd_range_options('$range_name')");
|
|
my ($option, $value, $row);
|
|
while (defined($row = spi_fetchrow($range_options)))
|
|
{
|
|
$option = $row->{option};
|
|
$value = $row->{value};
|
|
$output .= "\n $option $value;";
|
|
}
|
|
}
|
|
if (defined($class))
|
|
{
|
|
$output .= "\n allow members of \"$class\";";
|
|
}
|
|
else
|
|
{
|
|
$output .= "\n allow unknown clients;";
|
|
}
|
|
$output .= "\n }";
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
# hosts
|
|
sub hosts
|
|
{
|
|
my $static_hosts = spi_query("SELECT * FROM api.get_dhcpd6_static_hosts() order by owner,hostname");
|
|
# Disable dynamic hosts
|
|
#my $dynamic_hosts = spi_query("SELECT * FROM api.get_dhcpd_dynamic_hosts() order by owner,hostname");
|
|
my ($hostname, $zone, $mac, $address, $owner, $class, $row, $output);
|
|
$output .= "# Static hosts\n";
|
|
while (defined($row = spi_fetchrow($static_hosts)))
|
|
{
|
|
$hostname = $row->{hostname};
|
|
$zone = $row->{zone};
|
|
$mac = $row->{mac};
|
|
$address = $row->{address};
|
|
$owner = $row->{owner};
|
|
$class = $row->{class};
|
|
|
|
# Dirty way to only do IPv6 hosts
|
|
if (index($address, ':') != -1)
|
|
{
|
|
$output .= &host_config($hostname, $zone, $mac, $address, $owner, $class);
|
|
}
|
|
}
|
|
# Disable dynamic hosts
|
|
#$output .= "# Dynamic hosts\n";
|
|
#while (defined($row = spi_fetchrow($dynamic_hosts)))
|
|
#{
|
|
# $hostname = $row->{hostname};
|
|
# $zone = $row->{zone};
|
|
# $mac = $row->{mac};
|
|
# $owner = $row->{owner};
|
|
# $class = $row->{class};
|
|
#
|
|
# # Dirty way to only do IPv6 hosts
|
|
# if (index($address, ':') != -1)
|
|
# {
|
|
# $output .= &host_config($hostname, $zone, $mac, undef, $owner, $class);
|
|
# }
|
|
#}
|
|
return $output;
|
|
}
|
|
|
|
# hosts config generation
|
|
sub host_config
|
|
{
|
|
my ($hostname, $zone, $mac, $address, $owner, $class) = @_;
|
|
|
|
my $hostmac = $mac;
|
|
$hostmac =~ s/://g;
|
|
|
|
my $output .= "# $owner\n";
|
|
if (defined($hostname) && defined($zone))
|
|
{
|
|
$output .= "host $hostname.$zone {\n";
|
|
}else
|
|
{
|
|
$output .= "host $hostmac {\n";
|
|
}
|
|
$output .= " option dhcp-client-identifier 1:$mac;\n";
|
|
$output .= " hardware ethernet $mac;\n";
|
|
$output .= " fixed-address6 $address;\n" if (defined($address));
|
|
$output .= " option host-name \"$hostname\";\n" if (defined($hostname));
|
|
$output .= " ddns-hostname \"$hostname\";\n" if (defined($hostname));
|
|
$output .= " ddns-domainname \"$zone\";\n" if (defined($zone));
|
|
$output .= " option domain-name \"$zone\";\n" if (defined($zone));
|
|
$output .= "}\n";
|
|
$output .= "subclass \"$class\" 1:$mac;\n";
|
|
$output .= "subclass \"$class\" $mac;\n\n";
|
|
return $output;
|
|
}
|
|
|
|
|
|
# lets start with the DHCPd.conf header from the DB
|
|
my $header = spi_exec_query("SELECT api.get_site_configuration('DHCPD6_HEADER')");
|
|
my $output = $header->{rows}[0]->{get_site_configuration}. "\n\n";
|
|
|
|
# add the date to the file
|
|
my $date = spi_exec_query("SELECT localtimestamp(0)")->{rows}[0]->{timestamp};
|
|
$output .= "\# Generated at $date\n\n";
|
|
|
|
# now for the rest of the config file
|
|
$output .= &global_opts() . "\n";
|
|
$output .= &dns_keys() . "\n";
|
|
$output .= &forward_zones() . "\n";
|
|
$output .= &reverse_zones() . "\n";
|
|
$output .= &dhcp_classes() . "\n";
|
|
$output .= &shared_networks() . "\n";
|
|
$output .= &hosts() . "\n";
|
|
|
|
$output .= "\# End dhcpd6 configuration file";
|
|
|
|
# finally, store the config in the db, so we can get it back later.
|
|
spi_exec_query("INSERT INTO management.output (value,file,timestamp) VALUES (\$\$".$output."\$\$,'dhcpd6.conf',now())");
|
|
|
|
#log our success with the api logging tool.
|
|
spi_exec_query("SELECT api.syslog('successfully generated dhcpd6.conf')");
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.generate_dhcpd6_config() OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION generate_dhcpd6_config(); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.generate_dhcpd6_config() IS 'Generate the config file for the dhcpd6 server, and store it in the db';
|
|
|
|
|
|
--
|
|
-- Name: generate_dhcpd_config(); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.generate_dhcpd_config() RETURNS void
|
|
LANGUAGE plperlu
|
|
AS $_X$ # Script written by Anthony Gargiulo
|
|
use strict;
|
|
use warnings;
|
|
no warnings 'redefine';
|
|
|
|
# First things first. defining the subroutines that make up this script.
|
|
|
|
# Global Options
|
|
sub global_opts
|
|
{
|
|
my ($row, $option, $value, $output);
|
|
my $global_options = spi_query("SELECT * FROM api.get_dhcpd_global_options()");
|
|
while (defined($row = spi_fetchrow($global_options)))
|
|
{
|
|
$option = $row->{option};
|
|
$value = $row->{value};
|
|
$output .= "$option $value;\n"
|
|
}
|
|
return $output;
|
|
} # end global options
|
|
|
|
# DNS keys added here
|
|
sub dns_keys
|
|
{
|
|
my $keys = spi_query("SELECT * FROM api.get_dhcpd_dns_keys()");
|
|
my ($keyname, $key, $enctype, $row, $output);
|
|
while (defined ($row = spi_fetchrow($keys)))
|
|
{
|
|
$keyname = $row->{keyname};
|
|
$key = $row->{key};
|
|
$enctype = $row->{enctype};
|
|
$output .= "key $keyname {\n algorithm ${enctype};\n secret \"$key\";\n}\n";
|
|
}
|
|
return $output;
|
|
}# end DNS keys
|
|
|
|
# Zones are added here.
|
|
sub forward_zones
|
|
{
|
|
my $zones = spi_query("SELECT * FROM api.get_dhcpd_forward_zones()");
|
|
my ($zone, $keyname, $primary_ns, $row, $output);
|
|
$output = "";
|
|
while (defined ($row = spi_fetchrow($zones)))
|
|
{
|
|
$zone = $row->{zone};
|
|
$keyname = $row->{keyname};
|
|
$primary_ns = $row->{primary_ns};
|
|
$output .= "zone $zone {\n primary ${primary_ns};\n key ${keyname};\n}\n";
|
|
}
|
|
return $output;
|
|
}# end forward zones
|
|
|
|
# Zones are added here.
|
|
sub reverse_zones
|
|
{
|
|
my $zones = spi_query("SELECT * FROM api.get_dhcpd_reverse_zones()");
|
|
my ($zone, $keyname, $primary_ns, $row, $output);
|
|
$output = "";
|
|
while (defined ($row = spi_fetchrow($zones)))
|
|
{
|
|
$zone = $row->{zone};
|
|
$keyname = $row->{keyname};
|
|
$primary_ns = $row->{primary_ns};
|
|
$output .= "zone $zone {\n primary ${primary_ns};\n key ${keyname};\n}\n";
|
|
}
|
|
return $output;
|
|
}# end reverse zones
|
|
|
|
# DHCP Classes
|
|
sub dhcp_classes
|
|
{
|
|
my $classes = spi_query("SELECT class,comment FROM api.get_dhcpd_classes()");
|
|
my ($class, $comment, $row, $output);
|
|
while (defined($row = spi_fetchrow($classes)))
|
|
{
|
|
$class = $row->{class};
|
|
$comment = $row->{comment};
|
|
$output .= "class \"$class\" {\n";
|
|
$output .= " # ${comment}\n" if(defined($comment));
|
|
$output .= &dhcp_class_options($class);
|
|
$output .= "}\n\n";
|
|
}
|
|
return $output;
|
|
}# end &dhcp_classes
|
|
|
|
# DHCP Class options
|
|
sub dhcp_class_options
|
|
{
|
|
my $class = $_[0];
|
|
my $options = spi_query("SELECT * FROM api.get_dhcpd_class_options('$class')");
|
|
my ($option, $value, $row, $output);
|
|
while (defined($row = spi_fetchrow($options)))
|
|
{
|
|
$option = $row->{option};
|
|
$value = $row->{value};
|
|
$output .= " " . $option . ' ' . $value . ";\n";
|
|
}
|
|
return $output;
|
|
}# end &dhcp_class_options
|
|
|
|
# Shared networks
|
|
sub shared_networks
|
|
{
|
|
my $networks = spi_query("SELECT get_dhcpd_shared_networks FROM api.get_dhcpd_shared_networks()");
|
|
my ($network, $row, $output, $subnets);
|
|
|
|
while (defined($row = spi_fetchrow($networks)))
|
|
{
|
|
$network = $row->{get_dhcpd_shared_networks};
|
|
$subnets = &subnets($network);
|
|
if ($subnets)
|
|
{
|
|
$output .= "shared-network " . $network . " {\n\n";
|
|
$output .= $subnets;
|
|
$output .= "}\n\n";
|
|
}
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
# Subnets (for shared networks)
|
|
sub subnets
|
|
{
|
|
my $shared_net = $_[0];
|
|
# COHOE: THIS QUERY STRING IS QUITE VERBOSE, I HOPE YOU ARE HAPPY
|
|
my $query = "select get_dhcpd_shared_network_subnets as subnets, netmask(get_dhcpd_shared_network_subnets) ";
|
|
$query .= "from api.get_dhcpd_shared_network_subnets('$shared_net')";
|
|
my $subnets = spi_query($query);
|
|
|
|
# $subnet = ip + netmask in slash notation; i.e. 10.21.49.0/24
|
|
# $net = only the network address; i.e. 10.21.49.0
|
|
# $mask = netmask in dotted decimal notation; i.e. 255.255.255.0
|
|
my ($subnet, $net, $mask, $row, $output);
|
|
|
|
while (defined($row = spi_fetchrow($subnets)))
|
|
{
|
|
$subnet = $row->{subnets};
|
|
# Dirty way to only do IPv4 subnets ~Jordan
|
|
if (index($subnet, ':') == -1)
|
|
{
|
|
$net = substr($subnet, 0, index($subnet, "/"));
|
|
$mask = $row->{netmask};
|
|
$output .= " subnet $net netmask $mask {\n ";
|
|
$output .= " authoritative;";
|
|
my $subnet_option = &subnet_options($subnet);
|
|
if(defined($subnet_option))
|
|
{
|
|
$output .= $subnet_option;
|
|
}
|
|
my $subnet_range = &subnet_ranges($subnet);
|
|
if(defined($subnet_range))
|
|
{
|
|
$output .= $subnet_range;
|
|
}
|
|
$output .= "\n }\n\n";
|
|
}
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
# Subnet options
|
|
sub subnet_options
|
|
{
|
|
my $subnet = $_[0];
|
|
my $options = spi_query("SELECT option,value from api.get_dhcpd_subnet_options('$subnet')");
|
|
my ($option, $value, $row, $output);
|
|
while (defined($row = spi_fetchrow($options)))
|
|
{
|
|
$option = $row->{option};
|
|
$value = $row->{value};
|
|
$output .= "\n $option $value;";
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
# Subnet ranges
|
|
sub subnet_ranges
|
|
{
|
|
my $subnet = $_[0];
|
|
my $pool = spi_query("SELECT name,first_ip,last_ip,class from api.get_dhcpd_subnet_ranges('$subnet')");
|
|
my ($range_name, $first_ip, $last_ip, $class, $row, $output);
|
|
$output="";
|
|
|
|
while (defined($row = spi_fetchrow($pool)))
|
|
{
|
|
$range_name = $row->{name};
|
|
$first_ip = $row->{first_ip};
|
|
$last_ip = $row->{last_ip};
|
|
$class = $row->{class};
|
|
$output .= "\n pool {\n range $first_ip $last_ip;\n failover peer \"dhcpfailover\";";
|
|
{
|
|
my $range_options = spi_query("SELECT * from api.get_dhcpd_range_options('$range_name')");
|
|
my ($option, $value, $row);
|
|
while (defined($row = spi_fetchrow($range_options)))
|
|
{
|
|
$option = $row->{option};
|
|
$value = $row->{value};
|
|
$output .= "\n $option $value;";
|
|
}
|
|
}
|
|
if (defined($class))
|
|
{
|
|
$output .= "\n allow members of \"$class\";";
|
|
}
|
|
else
|
|
{
|
|
$output .= "\n allow unknown clients;";
|
|
}
|
|
$output .= "\n }";
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
# hosts
|
|
sub hosts
|
|
{
|
|
my $static_hosts = spi_query("SELECT * FROM api.get_dhcpd_static_hosts() order by owner,hostname");
|
|
my $dynamic_hosts = spi_query("SELECT * FROM api.get_dhcpd_dynamic_hosts() order by owner,hostname");
|
|
my ($hostname, $zone, $mac, $address, $owner, $class, $row, $output);
|
|
$output .= "# Static hosts\n";
|
|
while (defined($row = spi_fetchrow($static_hosts)))
|
|
{
|
|
$hostname = $row->{hostname};
|
|
$zone = $row->{zone};
|
|
$mac = $row->{mac};
|
|
$address = $row->{address};
|
|
$owner = $row->{owner};
|
|
$class = $row->{class};
|
|
|
|
$output .= &host_config($hostname, $zone, $mac, $address, $owner, $class);
|
|
}
|
|
$output .= "# Dynamic hosts\n";
|
|
while (defined($row = spi_fetchrow($dynamic_hosts)))
|
|
{
|
|
$hostname = $row->{hostname};
|
|
$zone = $row->{zone};
|
|
$mac = $row->{mac};
|
|
$owner = $row->{owner};
|
|
$class = $row->{class};
|
|
|
|
$output .= &host_config($hostname, $zone, $mac, undef, $owner, $class);
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
# hosts config generation
|
|
sub host_config
|
|
{
|
|
my ($hostname, $zone, $mac, $address, $owner, $class) = @_;
|
|
|
|
my $hostmac = $mac;
|
|
$hostmac =~ s/://g;
|
|
|
|
my $output .= "# $owner\n";
|
|
if (defined($hostname) && defined($zone))
|
|
{
|
|
$output .= "host $hostname.$zone {\n";
|
|
}else
|
|
{
|
|
$output .= "host $hostmac {\n";
|
|
}
|
|
$output .= " option dhcp-client-identifier 1:$mac;\n";
|
|
$output .= " hardware ethernet $mac;\n";
|
|
$output .= " fixed-address $address;\n" if (defined($address));
|
|
$output .= " option host-name \"$hostname\";\n" if (defined($hostname));
|
|
$output .= " ddns-hostname \"$hostname\";\n" if (defined($hostname));
|
|
$output .= " ddns-domainname \"$zone\";\n" if (defined($zone));
|
|
$output .= " option domain-name \"$zone\";\n" if (defined($zone));
|
|
$output .= "}\n";
|
|
$output .= "subclass \"$class\" 1:$mac;\n";
|
|
$output .= "subclass \"$class\" $mac;\n\n";
|
|
return $output;
|
|
}
|
|
|
|
|
|
# lets start with the DHCPd.conf header from the DB
|
|
my $header = spi_exec_query("SELECT api.get_site_configuration('DHCPD_HEADER')");
|
|
my $output = $header->{rows}[0]->{get_site_configuration}. "\n\n";
|
|
|
|
# add the date to the file
|
|
my $date = spi_exec_query("SELECT localtimestamp(0)")->{rows}[0]->{timestamp};
|
|
$output .= "\# Generated at $date\n\n";
|
|
|
|
# now for the rest of the config file
|
|
$output .= &global_opts() . "\n";
|
|
$output .= &dns_keys() . "\n";
|
|
$output .= &forward_zones() . "\n";
|
|
$output .= &reverse_zones() . "\n";
|
|
$output .= &dhcp_classes() . "\n";
|
|
$output .= &shared_networks() . "\n";
|
|
$output .= &hosts() . "\n";
|
|
|
|
$output .= "\# End dhcpd configuration file";
|
|
|
|
# finally, store the config in the db, so we can get it back later.
|
|
spi_exec_query("INSERT INTO management.output (value,file,timestamp) VALUES (\$\$".$output."\$\$,'dhcpd.conf',now())");
|
|
|
|
#log our success with the api logging tool.
|
|
spi_exec_query("SELECT api.syslog('successfully generated dhcpd.conf')");
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.generate_dhcpd_config() OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION generate_dhcpd_config(); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.generate_dhcpd_config() IS 'Generate the config file for the dhcpd server, and store it in the db';
|
|
|
|
|
|
--
|
|
-- Name: get_ad_user_email(text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_ad_user_email(text) RETURNS text
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
#!/usr/bin/perl
|
|
|
|
use strict;
|
|
use warnings;
|
|
use Net::LDAPS;
|
|
use Data::Dumper;
|
|
|
|
my $uri = spi_exec_query("SELECT api.get_site_configuration('AD_URI')")->{rows}[0]->{"get_site_configuration"};
|
|
my $binddn = spi_exec_query("SELECT api.get_site_configuration('AD_BINDDN')")->{rows}[0]->{"get_site_configuration"};
|
|
my $password = spi_exec_query("SELECT api.get_site_configuration('AD_PASSWORD')")->{rows}[0]->{"get_site_configuration"};
|
|
my $identifier= spi_exec_query("SELECT api.get_site_configuration('AD_IDENTIFIER')")->{rows}[0]->{"get_site_configuration"};
|
|
my $username = shift(@_) or die "Unable to get username\n";
|
|
|
|
# Set up the server connection
|
|
my $srv = Net::LDAPS->new ($uri) or die "Could not connect to LDAP server ($uri)\n";
|
|
my $mesg = $srv->bind($binddn,password=>$password) or die "Could not bind to LDAP server at $uri\n";
|
|
|
|
# Get the users DN
|
|
my $user_dn_query = $srv->search(filter=>"($identifier=$username)");
|
|
my $user_result = $user_dn_query->pop_entry();
|
|
if(!$user_result) {
|
|
die "Unable to find user \"$username\"\n";
|
|
}
|
|
|
|
# Unbind from the server
|
|
$srv->unbind;
|
|
|
|
return $user_result->get_value('mail');
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_ad_user_email(text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_ad_user_email(text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_ad_user_email(text) IS 'Get a users email address from Active Directory';
|
|
|
|
|
|
--
|
|
-- Name: get_ad_user_level(text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_ad_user_level(text) RETURNS text
|
|
LANGUAGE plperlu
|
|
AS $_X$
|
|
#!/usr/bin/perl
|
|
|
|
use strict;
|
|
use warnings;
|
|
use Net::LDAPS;
|
|
use Data::Dumper;
|
|
|
|
my $uri = spi_exec_query("SELECT api.get_site_configuration('AD_URI')")->{rows}[0]->{"get_site_configuration"};
|
|
my $binddn = spi_exec_query("SELECT api.get_site_configuration('AD_BINDDN')")->{rows}[0]->{"get_site_configuration"};
|
|
my $password = spi_exec_query("SELECT api.get_site_configuration('AD_PASSWORD')")->{rows}[0]->{"get_site_configuration"};
|
|
my $identifier= spi_exec_query("SELECT api.get_site_configuration('AD_IDENTIFIER')")->{rows}[0]->{"get_site_configuration"};
|
|
my $admin_filter = spi_exec_query("SELECT api.get_site_configuration('AD_ADMIN_FILTER')")->{rows}[0]->{"get_site_configuration"};
|
|
my $admin_basedn = spi_exec_query("SELECT api.get_site_configuration('AD_ADMIN_BASEDN')")->{rows}[0]->{"get_site_configuration"};
|
|
my $program_filter = spi_exec_query("SELECT api.get_site_configuration('AD_PROGRAM_FILTER')")->{rows}[0]->{"get_site_configuration"};
|
|
my $program_basedn = spi_exec_query("SELECT api.get_site_configuration('AD_PROGRAM_BASEDN')")->{rows}[0]->{"get_site_configuration"};
|
|
my $user_filter = spi_exec_query("SELECT api.get_site_configuration('AD_USER_FILTER')")->{rows}[0]->{"get_site_configuration"};
|
|
my $user_basedn = spi_exec_query("SELECT api.get_site_configuration('AD_USER_BASEDN')")->{rows}[0]->{"get_site_configuration"};
|
|
my $username = shift(@_) or die "Unable to get username\n";
|
|
|
|
my $status = "NONE";
|
|
my $user_dn;
|
|
|
|
if ($username eq "root") {
|
|
return "ADMIN";
|
|
}
|
|
|
|
|
|
# Set up the server connection
|
|
my $srv = Net::LDAPS->new ($uri) or die "Could not connect to LDAP server ($uri)\n";
|
|
my $mesg = $srv->bind($binddn,password=>$password) or die "Could not bind to LDAP server at $uri\n";
|
|
|
|
# Get the users DN
|
|
my $user_dn_query = $srv->search(filter=>"($identifier=$username)");
|
|
my $user_result = $user_dn_query->pop_entry();
|
|
if($user_result) {
|
|
$user_dn = $user_result->dn;
|
|
} else {
|
|
die "Unable to identify user \"$username\"\n";
|
|
}
|
|
|
|
# Get the User group members
|
|
my $user_query = $srv->search(filter=>"($user_filter)",base=>"$user_basedn");
|
|
foreach my $user_user_entries ($user_query->entries) {
|
|
if(grep $user_dn eq $_, $user_user_entries->get_value("member")) {
|
|
$status = "USER";
|
|
}
|
|
}
|
|
|
|
# Get the Admin group members
|
|
my $admin_query = $srv->search(filter=>"($admin_filter)",base=>"$admin_basedn");
|
|
foreach my $admin_user_entries ($admin_query->entries) {
|
|
if(grep $user_dn eq $_, $admin_user_entries->get_value("member")) {
|
|
$status = "ADMIN";
|
|
}
|
|
}
|
|
|
|
# Unbind from the server
|
|
$srv->unbind;
|
|
|
|
return $status;
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.get_ad_user_level(text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_ad_user_level(text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_ad_user_level(text) IS 'Get a users level from Active Directory';
|
|
|
|
|
|
--
|
|
-- Name: get_address_from_range(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_address_from_range(input_range_name text) RETURNS inet
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
LowerBound INET;
|
|
UpperBound INET;
|
|
AddressToUse INET;
|
|
BEGIN
|
|
-- Dynamic Addressing for ipv4
|
|
IF (SELECT "use" FROM "ip"."ranges" WHERE "name" = input_range_name) = 'ROAM'
|
|
AND (SELECT family("subnet") FROM "ip"."ranges" WHERE "name" = input_range_name) = 4 THEN
|
|
SELECT "address" INTO AddressToUse FROM "ip"."addresses"
|
|
WHERE "address" << cidr(api.get_site_configuration('DYNAMIC_SUBNET'))
|
|
AND "address" NOT IN (SELECT "address" FROM "systems"."interface_addresses") ORDER BY "address" ASC LIMIT 1;
|
|
RETURN AddressToUse;
|
|
END IF;
|
|
|
|
-- Get range bounds
|
|
SELECT "first_ip","last_ip" INTO LowerBound,UpperBound
|
|
FROM "ip"."ranges"
|
|
WHERE "ip"."ranges"."name" = input_range_name;
|
|
|
|
-- Get address from range
|
|
SELECT "address" FROM "ip"."addresses" INTO AddressToUse
|
|
WHERE "address" <= UpperBound AND "address" >= LowerBound
|
|
AND "address" NOT IN (SELECT "address" FROM "systems"."interface_addresses") ORDER BY "address" ASC LIMIT 1;
|
|
|
|
-- Check if range was full (AddressToUse will be NULL)
|
|
IF AddressToUse IS NULL THEN
|
|
RAISE EXCEPTION 'All addresses in range % are in use',input_range_name;
|
|
END IF;
|
|
|
|
-- Done
|
|
RETURN AddressToUse;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_address_from_range(input_range_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_address_from_range(input_range_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_address_from_range(input_range_name text) IS 'get the first available address in a range';
|
|
|
|
|
|
--
|
|
-- Name: get_address_range(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_address_range(input_address inet) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT "name" FROM "ip"."ranges" WHERE "first_ip" <= input_address AND "last_ip" >= input_address);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_address_range(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_address_range(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_address_range(input_address inet) IS 'Get the name of the range an address is in';
|
|
|
|
|
|
--
|
|
-- Name: get_availability_zones(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_availability_zones() RETURNS SETOF systems.availability_zones
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "systems"."availability_zones" ORDER BY "zone");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_availability_zones() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_availability_zones(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_availability_zones() IS 'Get all of the configured availability zones';
|
|
|
|
|
|
--
|
|
-- Name: get_current_user_groups(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_current_user_groups() RETURNS SETOF text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY(SELECT "group" FROM "management"."group_members" WHERE "user" = api.get_current_user());
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_current_user_groups() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_current_user_groups(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_current_user_groups() IS 'Get the groups of the current user';
|
|
|
|
|
|
--
|
|
-- Name: get_current_user_level(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_current_user_level() RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
RETURN (SELECT "privilege"
|
|
FROM "user_privileges"
|
|
WHERE "allow" = TRUE
|
|
AND "privilege" ~* '^admin|program|user$');
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_current_user_level() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_current_user_level(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_current_user_level() IS 'Get the level of the current session user';
|
|
|
|
|
|
--
|
|
-- Name: get_datacenters(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_datacenters() RETURNS SETOF systems.datacenters
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "systems"."datacenters" ORDER BY CASE WHEN "datacenter" = (SELECT api.get_site_configuration('DEFAULT_DATACENTER')) THEN 1 ELSE 2 END);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_datacenters() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_datacenters(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_datacenters() IS 'Get all of the available datacenters';
|
|
|
|
|
|
--
|
|
-- Name: get_default_renew_date(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_default_renew_date(input_system text) RETURNS date
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_system IS NULL THEN
|
|
RETURN date((('now'::text)::date + (api.get_site_configuration('DEFAULT_RENEW_INTERVAL'::text))::interval));
|
|
ELSE
|
|
RETURN date(('now'::text)::date + (SELECT "renew_interval" FROM "management"."groups"
|
|
JOIN "systems"."systems" ON "systems"."systems"."group" = "management"."groups"."group"
|
|
WHERE "system_name" = input_system));
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_default_renew_date(input_system text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_default_renew_date(input_system text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_default_renew_date(input_system text) IS 'Get the default renew date based on the configuration';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcp_class(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcp_class(input_class text) RETURNS SETOF dhcp.classes
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_class IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."classes" ORDER BY "class");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dhcp"."classes" WHERE "class" = input_class ORDER BY "class");
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcp_class(input_class text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcp_class(input_class text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcp_class(input_class text) IS 'Get all DHCP class information for a specific class';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcp_class_options(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcp_class_options(input_class text) RETURNS SETOF dhcp.class_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."class_options" WHERE "class" = input_class ORDER BY "option");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcp_class_options(input_class text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcp_class_options(input_class text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcp_class_options(input_class text) IS 'Get all DHCP class option data';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcp_classes(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcp_classes() RETURNS SETOF dhcp.classes
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."classes" ORDER BY "class");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcp_classes() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcp_classes(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcp_classes() IS 'Get all DHCP class information';
|
|
|
|
|
|
--
|
|
-- Name: config_types; Type: TABLE; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dhcp.config_types (
|
|
config text NOT NULL,
|
|
comment text,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
family integer NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dhcp.config_types OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE config_types; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dhcp.config_types IS 'List of ways to configure your address';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcp_config_types(integer); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcp_config_types(input_family integer) RETURNS SETOF dhcp.config_types
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_family IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."config_types" ORDER BY CASE WHEN "config" = api.get_site_configuration('DEFAULT_CONFIG_TYPE') THEN 1 ELSE 2 END);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dhcp"."config_types" WHERE "family" = input_family ORDER BY CASE WHEN "config" = api.get_site_configuration('DEFAULT_CONFIG_TYPE') THEN 1 ELSE 2 END);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcp_config_types(input_family integer) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcp_config_types(input_family integer); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcp_config_types(input_family integer) IS 'Get all DHCP config information';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcp_global_options(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcp_global_options() RETURNS SETOF dhcp.global_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."global_options" ORDER BY "option");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcp_global_options() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcp_global_options(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcp_global_options() IS 'Get all DHCP global option data';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcp_range_options(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcp_range_options(input_range text) RETURNS SETOF dhcp.range_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."range_options" WHERE "name" = input_range ORDER BY "option");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcp_range_options(input_range text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcp_range_options(input_range text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcp_range_options(input_range text) IS 'Get all DHCP range option data';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcp_subnet_options(cidr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcp_subnet_options(input_subnet cidr) RETURNS SETOF dhcp.subnet_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."subnet_options" WHERE "subnet" = input_subnet ORDER BY "option");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcp_subnet_options(input_subnet cidr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcp_subnet_options(input_subnet cidr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcp_subnet_options(input_subnet cidr) IS 'Get all DHCP subnet option data';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd6_config(); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd6_config() RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$ BEGIN
|
|
RETURN (SELECT "value" FROM "management"."output" WHERE "file"='dhcpd6.conf' ORDER BY "timestamp" DESC LIMIT 1);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd6_config() OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd6_config(); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd6_config() IS 'Get the latest DHCPD6 configuration file';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd6_reverse_zones(); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd6_reverse_zones() RETURNS SETOF dhcp.dhcpd_zones
|
|
LANGUAGE plpgsql
|
|
AS $$ BEGIN
|
|
RETURN QUERY (SELECT DISTINCT api.get_reverse_domain("subnet") AS "zone","dns"."zones"."keyname","address"
|
|
FROM "ip"."subnets"
|
|
JOIN "dns"."zones" ON "dns"."zones"."zone" = "ip"."subnets"."zone"
|
|
JOIN "dns"."ns" ON "dns"."zones"."zone" = "dns"."ns"."zone"
|
|
WHERE "dns"."ns"."nameserver" IN (SELECT "nameserver" FROM "dns"."soa" WHERE "dns"."soa"."zone" = "ip"."subnets"."zone")
|
|
AND "dhcp_enable" = TRUE AND family("subnet") = 6
|
|
ORDER BY api.get_reverse_domain("subnet"),"dns"."zones"."keyname","address");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd6_reverse_zones() OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd6_reverse_zones(); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd6_reverse_zones() IS 'Get all reverse zone info for dhcpd6';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd6_static_hosts(); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd6_static_hosts() RETURNS SETOF dhcp.dhcpd_static_hosts
|
|
LANGUAGE plpgsql
|
|
AS $$ BEGIN
|
|
RETURN QUERY (SELECT "dns"."a"."hostname","dns"."a"."zone",
|
|
"systems"."interface_addresses"."mac","systems"."interface_addresses"."address","systems"."systems"."owner",
|
|
"systems"."interface_addresses"."class"
|
|
FROM "systems"."interface_addresses"
|
|
LEFT JOIN "dns"."a" ON "dns"."a"."address" = "systems"."interface_addresses"."address"
|
|
JOIN "systems"."interfaces" ON "systems"."interfaces"."mac" = "systems"."interface_addresses"."mac"
|
|
JOIN "systems"."systems" ON "systems"."systems"."system_name" = "systems"."interfaces"."system_name"
|
|
WHERE "systems"."interface_addresses"."config"='dhcpv6'
|
|
AND NOT "systems"."interface_addresses"."address" << (SELECT cidr(api.get_site_configuration('DYNAMIC_SUBNET')))
|
|
AND ("dns"."a"."zone" IN (SELECT DISTINCT "zone" FROM "ip"."subnets" WHERE "dhcp_enable" IS TRUE ORDER BY "zone")
|
|
OR "dns"."a"."zone" IS NULL) ORDER BY "systems"."systems"."owner");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd6_static_hosts() OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd6_static_hosts(); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd6_static_hosts() IS 'Get all information for a host block of the dhcpd6.conf file';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_class_options(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_class_options(input_class text) RETURNS SETOF dhcp.dhcpd_class_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "option","value" FROM "dhcp"."class_options" WHERE "class" = input_class ORDER BY "option");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_class_options(input_class text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_class_options(input_class text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_class_options(input_class text) IS 'Get class options for the dhcpd.conf file';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_classes(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_classes() RETURNS SETOF dhcp.dhcpd_classes
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "class","comment" FROM "dhcp"."classes" ORDER BY "class");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_classes() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_classes(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_classes() IS 'Get class information for the dhcpd.conf file';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_config(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_config() RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT "value" FROM "management"."output" WHERE "file"='dhcpd.conf' ORDER BY "timestamp" DESC LIMIT 1);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_config() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_config(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_config() IS 'Get the latest DHCPD configuration file';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_dns_keys(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_dns_keys() RETURNS SETOF dhcp.dhcpd_dns_keys
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied on get_dhcpd_dns_keys: You are not admin.';
|
|
END IF;
|
|
|
|
-- Return data
|
|
RETURN QUERY (SELECT DISTINCT "dns"."zones"."keyname","dns"."keys"."key","dns"."keys"."enctype"
|
|
FROM "ip"."subnets"
|
|
JOIN "dns"."zones" ON "dns"."zones"."zone" = "ip"."subnets"."zone"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
WHERE "dhcp_enable" = TRUE
|
|
ORDER BY "dns"."zones"."keyname","dns"."keys"."key","dns"."keys"."enctype");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_dns_keys() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_dns_keys(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_dns_keys() IS 'Get all of the dns keys for dhcpd';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_dynamic_hosts(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_dynamic_hosts() RETURNS SETOF dhcp.dhcpd_dynamic_hosts
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "dns"."a"."hostname","dns"."a"."zone",
|
|
"systems"."interface_addresses"."mac","systems"."systems"."owner","systems"."interface_addresses"."class"
|
|
FROM "systems"."interface_addresses"
|
|
LEFT JOIN "dns"."a" ON "dns"."a"."address" = "systems"."interface_addresses"."address"
|
|
JOIN "systems"."interfaces" ON "systems"."interfaces"."mac" = "systems"."interface_addresses"."mac"
|
|
JOIN "systems"."systems" ON "systems"."systems"."system_name" = "systems"."interfaces"."system_name"
|
|
WHERE "systems"."interface_addresses"."config"='dhcp'
|
|
AND "systems"."interface_addresses"."address" << (SELECT cidr(api.get_site_configuration('DYNAMIC_SUBNET')))
|
|
AND ("dns"."a"."zone" IN (SELECT DISTINCT "zone" FROM "ip"."subnets" WHERE "dhcp_enable" IS TRUE ORDER BY "zone")
|
|
OR "dns"."a"."zone" IS NULL) ORDER BY "systems"."systems"."owner");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_dynamic_hosts() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_dynamic_hosts(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_dynamic_hosts() IS 'Get all information for a host block of the dhcpd.conf file';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_forward_zones(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_forward_zones() RETURNS SETOF dhcp.dhcpd_zones
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT DISTINCT "ip"."subnets"."zone","dns"."zones"."keyname","address"
|
|
FROM "ip"."subnets"
|
|
JOIN "dns"."zones" ON "dns"."zones"."zone" = "ip"."subnets"."zone"
|
|
JOIN "dns"."ns" ON "dns"."zones"."zone" = "dns"."ns"."zone"
|
|
WHERE "dns"."ns"."nameserver" IN (SELECT "nameserver" FROM "dns"."soa" WHERE "dns"."soa"."zone" = "ip"."subnets"."zone")
|
|
ORDER BY "ip"."subnets"."zone");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_forward_zones() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_forward_zones(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_forward_zones() IS 'Get all forward zone info for dhcpd';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_global_options(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_global_options() RETURNS SETOF dhcp.dhcpd_global_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "option","value" FROM "dhcp"."global_options" ORDER BY CASE WHEN "option" = 'option space' THEN 1 ELSE 2 END);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_global_options() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_global_options(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_global_options() IS 'Get all of the global DHCPD config directives';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_range_options(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_range_options(input_range text) RETURNS SETOF dhcp.dhcpd_range_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "option","value" FROM "dhcp"."range_options" WHERE "name" = input_range ORDER BY "option");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_range_options(input_range text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_range_options(input_range text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_range_options(input_range text) IS 'Get all range options for dhcpd.conf';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_reverse_zones(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_reverse_zones() RETURNS SETOF dhcp.dhcpd_zones
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT DISTINCT api.get_reverse_domain("subnet") AS "zone","dns"."zones"."keyname","address"
|
|
FROM "ip"."subnets"
|
|
JOIN "dns"."zones" ON "dns"."zones"."zone" = "ip"."subnets"."zone"
|
|
JOIN "dns"."ns" ON "dns"."zones"."zone" = "dns"."ns"."zone"
|
|
WHERE "dns"."ns"."nameserver" IN (SELECT "nameserver" FROM "dns"."soa" WHERE "dns"."soa"."zone" = "ip"."subnets"."zone")
|
|
AND "dhcp_enable" = TRUE AND family("subnet") = 4
|
|
ORDER BY api.get_reverse_domain("subnet"),"dns"."zones"."keyname","address");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_reverse_zones() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_reverse_zones(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_reverse_zones() IS 'Get all reverse zone info for dhcpd';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_shared_network_subnets(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_shared_network_subnets(input_name text) RETURNS SETOF cidr
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "subnet" FROM "network"."vlans" JOIN "ip"."subnets" ON "network"."vlans"."vlan" = "ip"."subnets"."vlan" WHERE "network"."vlans"."name" = input_name AND "dhcp_enable" IS TRUE);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_shared_network_subnets(input_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_shared_network_subnets(input_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_shared_network_subnets(input_name text) IS 'Get the subnets for DHCPD';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_shared_networks(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_shared_networks() RETURNS SETOF text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "name" FROM "network"."vlans" WHERE "datacenter" = api.get_site_configuration('DEFAULT_DATACENTER') ORDER BY "name");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_shared_networks() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_shared_networks(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_shared_networks() IS 'Get DHCPD shared networks';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_static_hosts(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_static_hosts() RETURNS SETOF dhcp.dhcpd_static_hosts
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "dns"."a"."hostname","dns"."a"."zone",
|
|
"systems"."interface_addresses"."mac","systems"."interface_addresses"."address","systems"."systems"."owner",
|
|
"systems"."interface_addresses"."class"
|
|
FROM "systems"."interface_addresses"
|
|
LEFT JOIN "dns"."a" ON "dns"."a"."address" = "systems"."interface_addresses"."address"
|
|
JOIN "systems"."interfaces" ON "systems"."interfaces"."mac" = "systems"."interface_addresses"."mac"
|
|
JOIN "systems"."systems" ON "systems"."systems"."system_name" = "systems"."interfaces"."system_name"
|
|
WHERE "systems"."interface_addresses"."config"='dhcp'
|
|
AND NOT "systems"."interface_addresses"."address" << (SELECT cidr(api.get_site_configuration('DYNAMIC_SUBNET')))
|
|
AND ("dns"."a"."zone" IN (SELECT DISTINCT "zone" FROM "ip"."subnets" WHERE "dhcp_enable" IS TRUE ORDER BY "zone")
|
|
OR "dns"."a"."zone" IS NULL) ORDER BY "systems"."systems"."owner");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_static_hosts() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_static_hosts(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_static_hosts() IS 'Get all information for a host block of the dhcpd.conf file';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_subnet_options(cidr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_subnet_options(input_subnet cidr) RETURNS SETOF dhcp.dhcpd_subnet_options
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "option","value" FROM "dhcp"."subnet_options" WHERE "subnet" = input_subnet ORDER BY "option");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_subnet_options(input_subnet cidr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_subnet_options(input_subnet cidr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_subnet_options(input_subnet cidr) IS 'Get all subnet options for dhcpd.conf';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_subnet_ranges(cidr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_subnet_ranges(input_subnet cidr) RETURNS SETOF dhcp.dhcpd_subnet_ranges
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "name","first_ip","last_ip","class" FROM "ip"."ranges" WHERE "subnet" = input_subnet AND "use" = 'ROAM' AND family("subnet") = 4 ORDER BY "subnet");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_subnet_ranges(input_subnet cidr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_subnet_ranges(input_subnet cidr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_subnet_ranges(input_subnet cidr) IS 'Get a list of all dynamic ranges in a subnet';
|
|
|
|
|
|
--
|
|
-- Name: get_dhcpd_subnets(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dhcpd_subnets() RETURNS SETOF cidr
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "subnet" FROM "ip"."subnets" WHERE "dhcp_enable" = TRUE AND family("subnet") = 4 ORDER BY "subnet");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dhcpd_subnets() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dhcpd_subnets(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dhcpd_subnets() IS 'Get a list of all DHCP enabled subnets for DHCPD';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_a(inet, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_a(input_address inet, input_zone text) RETURNS SETOF dns.a
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_zone IS NULL THEN
|
|
IF input_address IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."a" ORDER BY "address");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."a" WHERE "address" = input_address ORDER BY "zone" ASC);
|
|
END IF;
|
|
ELSE
|
|
IF input_address IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."a" ORDER BY "address");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."a" WHERE "address" = input_address AND "zone" = input_zone ORDER BY "zone");
|
|
END IF;
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_a(input_address inet, input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_a(input_address inet, input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_a(input_address inet, input_zone text) IS 'Get all DNS address records for an address';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_cname(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_cname(input_address inet) RETURNS SETOF dns.cname
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_address IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."cname" ORDER BY "alias");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."cname" WHERE "address" = input_address ORDER BY "alias" ASC);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_cname(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_cname(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_cname(input_address inet) IS 'Get all DNS CNAME records for an address';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_key(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_key(input_keyname text) RETURNS SETOF dns.keys
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "dns"."keys" WHERE "keyname" = input_keyname) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to get DNS key denied: You are not admin or owner';
|
|
END IF;
|
|
END IF;
|
|
RETURN QUERY (SELECT * FROM "dns"."keys" WHERE "keyname" = input_keyname);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_key(input_keyname text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_key(input_keyname text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_key(input_keyname text) IS 'Get DNS key data';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_keys(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_keys(input_username text) RETURNS SETOF dns.keys
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_username IS NULL THEN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission to get DNS keys denied: You are not admin';
|
|
END IF;
|
|
RETURN QUERY (SELECT * FROM "dns"."keys" ORDER BY "keyname");
|
|
ELSE
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF input_username != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to get DNS keys denied: You are not admin or owner';
|
|
END IF;
|
|
END IF;
|
|
RETURN QUERY (SELECT * FROM "dns"."keys" WHERE "owner" = input_username ORDER BY "keyname" ASC);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_keys(input_username text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_keys(input_username text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_keys(input_username text) IS 'Get DNS key data';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_mx(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_mx(input_address inet) RETURNS SETOF dns.mx
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_address IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."mx" ORDER BY "preference");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."mx" WHERE "address" = input_address ORDER BY "preference");
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_mx(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_mx(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_mx(input_address inet) IS 'Get all data pertanent to DNS MX records for an address';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_ns(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_ns(input_zone text) RETURNS SETOF dns.ns
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_zone IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."ns" ORDER BY "nameserver");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."ns" WHERE "zone" = input_zone ORDER BY "nameserver");
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_ns(input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_ns(input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_ns(input_zone text) IS 'Get all DNS NS records for a zone';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_soa(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_soa(input_zone text) RETURNS SETOF dns.soa
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_zone IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."soa" ORDER BY "zone");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."soa" WHERE "dns"."soa"."zone" = input_zone);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_soa(input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_soa(input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_soa(input_zone text) IS 'Get the SOA record of a DNS zone';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_srv(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_srv(input_address inet) RETURNS SETOF dns.srv
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_address IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."srv" ORDER BY "alias");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."srv" WHERE "address" = input_address ORDER BY "alias" ASC);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_srv(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_srv(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_srv(input_address inet) IS 'Get all DNS SRV records for an address';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_txt(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_txt(input_address inet) RETURNS SETOF dns.txt
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_address IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."txt" ORDER BY "text");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."txt" WHERE "address" = input_address ORDER BY "text");
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_txt(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_txt(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_txt(input_address inet) IS 'Get all DNS TXT records for an address';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_zone(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_zone(input_zone text) RETURNS SETOF dns.zones
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_zone IS NULL THEN
|
|
RETURN QUERY(SELECT * FROM "dns"."zones" ORDER BY "zone");
|
|
ELSE
|
|
RETURN QUERY(SELECT * FROM "dns"."zones" WHERE "zone" = input_zone ORDER BY "zone");
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_zone(input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_zone(input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_zone(input_zone text) IS 'Get detailed dns zone information';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_zone_a(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_zone_a(input_zone text) RETURNS SETOF dns.zone_a
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_zone IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_a" ORDER BY "address");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_a" WHERE "zone" = input_zone ORDER BY "address");
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_zone_a(input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_zone_a(input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_zone_a(input_zone text) IS 'Get all DNS address records for a zone';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_zone_txt(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_zone_txt(input_zone text) RETURNS SETOF dns.zone_txt
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_zone IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" ORDER BY "hostname");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" WHERE "zone" = input_zone ORDER BY "hostname" ASC);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_zone_txt(input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_zone_txt(input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_zone_txt(input_zone text) IS 'Get all DNS TXT records specifically for a zone';
|
|
|
|
|
|
--
|
|
-- Name: get_dns_zones(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_dns_zones(input_username text) RETURNS SETOF dns.zones
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_username IS NULL THEN
|
|
RETURN QUERY(SELECT * FROM "dns"."zones" ORDER BY CASE WHEN "zone" = (SELECT api.get_site_configuration('DNS_DEFAULT_ZONE')) THEN 1 ELSE 2 END, "forward" DESC, "zone" ASC);
|
|
ELSE
|
|
RETURN QUERY(SELECT * FROM "dns"."zones" WHERE "shared" = TRUE OR "owner" = input_username ORDER BY CASE WHEN "zone" = (SELECT api.get_site_configuration('DNS_DEFAULT_ZONE')) THEN 1 ELSE 2 END, "forward" DESC, "zone" ASC);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_dns_zones(input_username text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_dns_zones(input_username text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_dns_zones(input_username text) IS 'Get the available zones to a user';
|
|
|
|
|
|
--
|
|
-- Name: get_domain_state(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_domain_state(input_system text) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
HostData RECORD;
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."system" WHERE "system_name" = input_system) THEN
|
|
RAISE EXCEPTION 'Permission denied: Not VM owner';
|
|
END IF;
|
|
END IF;
|
|
|
|
SELECT * INTO HostData FROM "libvirt"."hosts" WHERE "system_name" = (SELECT "host_name" FROM "libvirt"."domains" WHERE "domain_name" = input_system);
|
|
|
|
RETURN api.get_libvirt_domain_state(HostData.uri, HostData.password, input_system);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_domain_state(input_system text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: get_function_counts(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_function_counts(input_schema text) RETURNS TABLE(function text, calls integer)
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY(
|
|
SELECT "information_schema"."routines"."routine_name"::text,"pg_stat_user_functions"."calls"::integer
|
|
FROM "information_schema"."routines"
|
|
LEFT JOIN "pg_stat_user_functions" ON "pg_stat_user_functions"."funcname" = "information_schema"."routines"."routine_name"
|
|
WHERE "information_schema"."routines"."routine_schema" = input_schema
|
|
);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_function_counts(input_schema text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_function_counts(input_schema text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_function_counts(input_schema text) IS 'Get statistics on number of calls to each function in a schema';
|
|
|
|
|
|
--
|
|
-- Name: get_group_admins(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_group_admins(input_group text) RETURNS SETOF text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY(SELECT "user" FROM "management"."group_members" WHERE "group" = input_group AND "privilege" = 'ADMIN');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_group_admins(input_group text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_group_admins(input_group text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_group_admins(input_group text) IS 'Get a list of all admins for a group';
|
|
|
|
|
|
--
|
|
-- Name: get_group_members(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_group_members(input_group text) RETURNS SETOF management.group_members
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "management"."group_members" WHERE "group" = input_group ORDER BY "user");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_group_members(input_group text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_group_members(input_group text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_group_members(input_group text) IS 'Get all members of a group';
|
|
|
|
|
|
--
|
|
-- Name: get_group_ranges(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_group_ranges(input_group text) RETURNS SETOF ip.ranges
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "ip"."ranges" WHERE "name" IN (SELECT "range_name" FROM "ip"."range_groups" WHERE "group_name" = input_group) ORDER BY "name");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_group_ranges(input_group text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_group_ranges(input_group text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_group_ranges(input_group text) IS 'Get group range information';
|
|
|
|
|
|
--
|
|
-- Name: get_group_settings(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_group_settings(input_group text) RETURNS SETOF management.group_settings
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can view group provider settings';
|
|
END IF;
|
|
|
|
-- return
|
|
RETURN QUERY (SELECT * FROM "management"."group_settings" WHERE "group" = input_group);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_group_settings(input_group text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_group_settings(input_group text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_group_settings(input_group text) IS 'Get group settings';
|
|
|
|
|
|
--
|
|
-- Name: get_groups(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_groups() RETURNS SETOF management.groups
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "management"."groups" ORDER BY "group");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_groups() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_groups(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_groups() IS 'Get all of the configured groups';
|
|
|
|
|
|
--
|
|
-- Name: get_host_domain(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_host_domain(input_system text, input_domain text) RETURNS SETOF libvirt.domains
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
HostData RECORD;
|
|
BEGIN
|
|
SELECT * INTO HostData FROM "libvirt"."hosts" WHERE "system_name" = input_system;
|
|
RETURN QUERY (SELECT input_system AS "host_name","domain","state","definition",localtimestamp(0) AS "date_created", localtimestamp(0) AS "date_modified", api.get_current_user() AS "last_modifier" FROM api.get_libvirt_domain(HostData.uri, HostData.password, input_domain));
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_host_domain(input_system text, input_domain text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: get_host_domains(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_host_domains(input_system text) RETURNS SETOF libvirt.domains
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
HostData RECORD;
|
|
BEGIN
|
|
SELECT * INTO HostData FROM "libvirt"."hosts" WHERE "system_name" = input_system;
|
|
RETURN QUERY (SELECT input_system AS "host_name","domain","state","definition",localtimestamp(0) AS "date_created", localtimestamp(0) AS "date_modified", api.get_current_user() AS "last_modifier" FROM api.get_libvirt_domains(HostData.uri, HostData.password));
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_host_domains(input_system text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: get_hosts(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_hosts(input_user text) RETURNS SETOF libvirt.hosts
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_user IS NULL THEN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Only admins can view all VM hosts';
|
|
END IF;
|
|
RETURN QUERY (SELECT * FROM "libvirt"."hosts" ORDER BY "system_name");
|
|
ELSE
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RETURN QUERY (SELECT * FROM "libvirt"."hosts" WHERE api.get_system_owner("system_name") = input_user ORDER BY "system_name");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "libvirt"."hosts" ORDER BY "system_name");
|
|
END IF;
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_hosts(input_user text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_hosts(input_user text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_hosts(input_user text) IS 'Get all VM hosts';
|
|
|
|
|
|
--
|
|
-- Name: get_interface_address_owner(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_interface_address_owner(input_address inet) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT "owner" FROM systems.interface_addresses
|
|
JOIN systems.interfaces on systems.interface_addresses.mac = systems.interfaces.mac
|
|
JOIN systems.systems on systems.interfaces.system_name = systems.systems.system_name
|
|
WHERE "address" = input_address);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_interface_address_owner(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_interface_address_owner(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_interface_address_owner(input_address inet) IS 'Get the owner of an interface address';
|
|
|
|
|
|
--
|
|
-- Name: get_interface_address_system(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_interface_address_system(input_address inet) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT "system_name" FROM "systems"."interface_addresses"
|
|
JOIN "systems"."interfaces" ON "systems"."interface_addresses"."mac" = "systems"."interfaces"."mac"
|
|
WHERE "address" = input_address);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_interface_address_system(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_interface_address_system(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_interface_address_system(input_address inet) IS 'Get the name of the system to which the given address is assigned';
|
|
|
|
|
|
--
|
|
-- Name: get_interface_owner(macaddr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_interface_owner(input_mac macaddr) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT "owner" FROM "systems"."interfaces"
|
|
JOIN "systems"."systems" ON "systems"."interfaces"."system_name" = "systems"."systems"."system_name"
|
|
WHERE "mac" = input_mac);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_interface_owner(input_mac macaddr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_interface_owner(input_mac macaddr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_interface_owner(input_mac macaddr) IS 'Get the owner of the system that contains the mac address';
|
|
|
|
|
|
--
|
|
-- Name: cam_cache; Type: TABLE; Schema: network; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE network.cam_cache (
|
|
system_name text NOT NULL,
|
|
mac macaddr NOT NULL,
|
|
ifindex integer NOT NULL,
|
|
vlan integer NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE network.cam_cache OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE cam_cache; Type: COMMENT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE network.cam_cache IS 'Cache switch data for port mappings';
|
|
|
|
|
|
--
|
|
-- Name: get_interface_switchports(macaddr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_interface_switchports(input_mac macaddr) RETURNS SETOF network.cam_cache
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "network"."cam_cache" WHERE "mac" = input_mac);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_interface_switchports(input_mac macaddr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_interface_switchports(input_mac macaddr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_interface_switchports(input_mac macaddr) IS 'Get all the cam cache entries for MAC';
|
|
|
|
|
|
--
|
|
-- Name: get_interface_system(macaddr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_interface_system(input_mac macaddr) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT "system_name" FROM "systems"."interfaces" WHERE "mac" = input_mac);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_interface_system(input_mac macaddr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_interface_system(input_mac macaddr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_interface_system(input_mac macaddr) IS 'Get the system name that a mac address is on';
|
|
|
|
|
|
--
|
|
-- Name: get_ip_mask_bits(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_ip_mask_bits(input_subnet inet) RETURNS integer
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
t1 TEXT;
|
|
t2 TEXT;
|
|
t3 TEXT;
|
|
t4 TEXT;
|
|
i BIGINT;
|
|
n INTEGER;
|
|
BEGIN
|
|
IF family(input_subnet) != 4 THEN
|
|
RAISE EXCEPTION 'Can only get mask bits of an IPv4 address';
|
|
END IF;
|
|
|
|
t1 := SPLIT_PART(HOST(input_subnet), '.',1);
|
|
t2 := SPLIT_PART(HOST(input_subnet), '.',2);
|
|
t3 := SPLIT_PART(HOST(input_subnet), '.',3);
|
|
t4 := SPLIT_PART(HOST(input_subnet), '.',4);
|
|
i := (t1::BIGINT << 24) + (t2::BIGINT << 16) +
|
|
(t3::BIGINT << 8) + t4::BIGINT;
|
|
n := (32-log(2, 4294967296 - i ))::integer;
|
|
|
|
RETURN n;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_ip_mask_bits(input_subnet inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_ip_mask_bits(input_subnet inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_ip_mask_bits(input_subnet inet) IS 'Get the number of bits in a subnet mask';
|
|
|
|
|
|
--
|
|
-- Name: get_ip_range_total(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_ip_range_total(input_range text) RETURNS integer
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT COUNT(api.get_address_range("address"))
|
|
FROM "ip"."addresses"
|
|
WHERE api.get_address_range("address") ~* input_range);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_ip_range_total(input_range text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_ip_range_total(input_range text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_ip_range_total(input_range text) IS 'Get the number of possible addresses in a particiular range';
|
|
|
|
|
|
--
|
|
-- Name: get_ip_range_uses(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_ip_range_uses() RETURNS SETOF text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT text("use") FROM "ip"."range_uses");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_ip_range_uses() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_ip_range_uses(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_ip_range_uses() IS 'Get a list of all use codes';
|
|
|
|
|
|
--
|
|
-- Name: get_ip_ranges(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_ip_ranges() RETURNS SETOF ip.ranges
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "ip"."ranges" ORDER BY "first_ip");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_ip_ranges() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_ip_ranges(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_ip_ranges() IS 'Get all configured IP ranges';
|
|
|
|
|
|
--
|
|
-- Name: get_ip_subnets(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_ip_subnets(input_username text) RETURNS SETOF ip.subnets
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_username IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "ip"."subnets" ORDER BY "subnet");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "ip"."subnets" WHERE "owner" = input_username ORDER BY "subnet");
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_ip_subnets(input_username text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_ip_subnets(input_username text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_ip_subnets(input_username text) IS 'Get all IP subnet data';
|
|
|
|
|
|
--
|
|
-- Name: get_ldap_group_members(text, text, text, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_ldap_group_members(text, text, text, text) RETURNS SETOF text
|
|
LANGUAGE plperlu
|
|
AS $_X$
|
|
use strict;
|
|
use warnings;
|
|
use Net::LDAP;
|
|
|
|
# Get the credentials
|
|
my $hostname = $_[0] or die "Need to give a hostname";
|
|
my $id= $_[1] or die "Need to give an ID";
|
|
my $binddn = $_[2] or die "Need to give a username";
|
|
my $password = $_[3] or die "Need to give a password";
|
|
|
|
my $srv = Net::LDAP->new ($hostname) or die "Could not connect to LDAP server ($hostname)\n";
|
|
my $mesg = $srv->bind($binddn,password=>$password) or die "Could not bind to LDAP server";
|
|
|
|
my @members;
|
|
|
|
my @dnparts = split(/,/, $id);
|
|
my $filter = shift(@dnparts);
|
|
my $base = join(",",@dnparts);
|
|
|
|
|
|
$mesg = $srv->search(filter=>"($filter)",base=>$base);
|
|
foreach my $entry ($mesg->entries) {
|
|
my @vals = $entry->get_value('member');
|
|
foreach my $val (@vals) {
|
|
$val =~ s/^uid=(.*?),(.*?)$/$1/;
|
|
push(@members, $val);
|
|
}
|
|
}
|
|
|
|
return \@members;
|
|
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.get_ldap_group_members(text, text, text, text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: get_ldap_user_level(text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_ldap_user_level(text) RETURNS text
|
|
LANGUAGE plperlu
|
|
AS $_X$
|
|
use strict;
|
|
use warnings;
|
|
use Net::LDAP;
|
|
|
|
# Get the current authenticated username
|
|
my $username = $_[0] or die "Need to give a username";
|
|
|
|
# If this is the installer, we dont need to query the server
|
|
if ($username eq "root")
|
|
{
|
|
return "ADMIN";
|
|
}
|
|
|
|
# Get LDAP connection information
|
|
my $host = spi_exec_query("SELECT api.get_site_configuration('LDAP_HOST')")->{rows}[0]->{"get_site_configuration"};
|
|
my $binddn = spi_exec_query("SELECT api.get_site_configuration('LDAP_BINDDN')")->{rows}[0]->{"get_site_configuration"};
|
|
my $password = spi_exec_query("SELECT api.get_site_configuration('LDAP_PASSWORD')")->{rows}[0]->{"get_site_configuration"};
|
|
my $admin_filter = spi_exec_query("SELECT api.get_site_configuration('LDAP_ADMIN_FILTER')")->{rows}[0]->{"get_site_configuration"};
|
|
my $admin_basedn = spi_exec_query("SELECT api.get_site_configuration('LDAP_ADMIN_BASEDN')")->{rows}[0]->{"get_site_configuration"};
|
|
my $program_filter = spi_exec_query("SELECT api.get_site_configuration('LDAP_PROGRAM_FILTER')")->{rows}[0]->{"get_site_configuration"};
|
|
my $program_basedn = spi_exec_query("SELECT api.get_site_configuration('LDAP_PROGRAM_BASEDN')")->{rows}[0]->{"get_site_configuration"};
|
|
my $user_filter = spi_exec_query("SELECT api.get_site_configuration('LDAP_USER_FILTER')")->{rows}[0]->{"get_site_configuration"};
|
|
my $user_basedn = spi_exec_query("SELECT api.get_site_configuration('LDAP_USER_BASEDN')")->{rows}[0]->{"get_site_configuration"};
|
|
|
|
# The lowest status. Build from here.
|
|
my $status = "NONE";
|
|
|
|
# Bind to the LDAP server
|
|
my $srv = Net::LDAP->new ($host) or die "Could not connect to LDAP server ($host)\n";
|
|
my $mesg = $srv->bind($binddn,password=>$password) or die "Could not bind to LDAP server at $host\n";
|
|
|
|
# Go through the directory and see if this user is a user account
|
|
$mesg = $srv->search(filter=>"($user_filter=$username)",base=>$user_basedn,attrs=>[$user_filter]);
|
|
foreach my $entry ($mesg->entries)
|
|
{
|
|
my @users = $entry->get_value($user_filter);
|
|
foreach my $user (@users)
|
|
{
|
|
$user =~ s/^uid=(.*?)\,(.*?)$/$1/;
|
|
if ($user eq $username)
|
|
{
|
|
$status = "USER";
|
|
}
|
|
}
|
|
}
|
|
|
|
# Go through the directory and see if this user is a program account
|
|
$mesg = $srv->search(filter=>"($program_filter=$username)",base=>$program_basedn,attrs=>[$program_filter]);
|
|
foreach my $entry ($mesg->entries)
|
|
{
|
|
my @programs = $entry->get_value($program_filter);
|
|
foreach my $program (@programs)
|
|
{
|
|
if ($program eq $username)
|
|
{
|
|
$status = "PROGRAM";
|
|
}
|
|
}
|
|
}
|
|
|
|
# Go through the directory and see if this user is an admin
|
|
# Fancy hacks to allow for less hardcoding of attributes
|
|
my $admin_filter_atr = $admin_filter;
|
|
$admin_filter_atr =~ s/^(.*?)[^a-zA-Z0-9]+$/$1/;
|
|
$mesg = $srv->search(filter=>"($admin_filter)",base=>$admin_basedn,attrs=>[$admin_filter_atr]);
|
|
foreach my $entry ($mesg->entries)
|
|
{
|
|
my @admins = $entry->get_value($admin_filter_atr);
|
|
foreach my $admin (@admins)
|
|
{
|
|
$admin =~ s/^uid=(.*?)\,(.*?)$/$1/;
|
|
if ($admin eq $username)
|
|
{
|
|
$status = "ADMIN";
|
|
}
|
|
}
|
|
}
|
|
|
|
# Unbind from the LDAP server
|
|
$srv->unbind;
|
|
|
|
# Done
|
|
return $status;
|
|
|
|
# if($_[0] eq 'root')
|
|
# {
|
|
# return "ADMIN"
|
|
# }
|
|
# else
|
|
# {
|
|
# return "USER";
|
|
# }
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.get_ldap_user_level(text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_ldap_user_level(text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_ldap_user_level(text) IS 'Get the level of access for the authenticated user';
|
|
|
|
|
|
--
|
|
-- Name: get_libvirt_domain(text, text, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_libvirt_domain(sysuri text, syspassword text, domainname text) RETURNS libvirt.domain_data
|
|
LANGUAGE plpython3u
|
|
AS $$
|
|
#!/usr/bin/python
|
|
|
|
import libvirt
|
|
import sys
|
|
|
|
def request_credentials(credentials, data):
|
|
for credential in credentials:
|
|
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
|
|
#credential[4] = sysuser
|
|
return 0
|
|
elif credential[0] == libvirt.VIR_CRED_NOECHOPROMPT:
|
|
credential[4] = syspassword
|
|
else:
|
|
return -1
|
|
|
|
return 0
|
|
|
|
auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT], request_credentials, None]
|
|
if syspassword == None:
|
|
conn = libvirt.open(sysuri)
|
|
else:
|
|
conn = libvirt.openAuth(sysuri, auth, 0)
|
|
|
|
if conn == None:
|
|
sys.exit("Unable to connect")
|
|
|
|
state_names = { libvirt.VIR_DOMAIN_RUNNING : "running",
|
|
libvirt.VIR_DOMAIN_BLOCKED : "idle",
|
|
libvirt.VIR_DOMAIN_PAUSED : "paused",
|
|
libvirt.VIR_DOMAIN_SHUTDOWN : "in shutdown",
|
|
libvirt.VIR_DOMAIN_SHUTOFF : "shut off",
|
|
libvirt.VIR_DOMAIN_CRASHED : "crashed",
|
|
libvirt.VIR_DOMAIN_NOSTATE : "no state" }
|
|
|
|
domain = conn.lookupByName(domainname)
|
|
return ([domain.name(), state_names[domain.info()[0]], domain.XMLDesc(0)])
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_libvirt_domain(sysuri text, syspassword text, domainname text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: get_libvirt_domain_state(text, text, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_libvirt_domain_state(sysuri text, syspassword text, domain text) RETURNS text
|
|
LANGUAGE plpython3u
|
|
AS $$
|
|
#!/usr/bin/python
|
|
|
|
import libvirt
|
|
import sys
|
|
|
|
def request_credentials(credentials, data):
|
|
for credential in credentials:
|
|
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
|
|
return 0
|
|
elif credential[0] == libvirt.VIR_CRED_NOECHOPROMPT:
|
|
credential[4] = syspassword
|
|
else:
|
|
return -1
|
|
|
|
return 0
|
|
|
|
auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT], request_credentials, None]
|
|
conn = libvirt.openAuth(sysuri, auth, 0)
|
|
|
|
dom = conn.lookupByName(domain)
|
|
|
|
conn.close()
|
|
state_names = { libvirt.VIR_DOMAIN_RUNNING : "running",
|
|
libvirt.VIR_DOMAIN_BLOCKED : "idle",
|
|
libvirt.VIR_DOMAIN_PAUSED : "paused",
|
|
libvirt.VIR_DOMAIN_SHUTDOWN : "in shutdown",
|
|
libvirt.VIR_DOMAIN_SHUTOFF : "shut off",
|
|
libvirt.VIR_DOMAIN_CRASHED : "crashed",
|
|
libvirt.VIR_DOMAIN_NOSTATE : "no state" }
|
|
return state_names[dom.info()[0]]
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_libvirt_domain_state(sysuri text, syspassword text, domain text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: get_libvirt_domains(text, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_libvirt_domains(sysuri text, syspassword text) RETURNS SETOF libvirt.domain_data
|
|
LANGUAGE plpython3u
|
|
AS $$
|
|
#!/usr/bin/python
|
|
|
|
import libvirt
|
|
import sys
|
|
|
|
def request_credentials(credentials, data):
|
|
for credential in credentials:
|
|
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
|
|
#credential[4] = sysuser
|
|
return 0
|
|
elif credential[0] == libvirt.VIR_CRED_NOECHOPROMPT:
|
|
credential[4] = syspassword
|
|
else:
|
|
return -1
|
|
|
|
return 0
|
|
|
|
auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT], request_credentials, None]
|
|
if syspassword == None:
|
|
conn = libvirt.open(sysuri)
|
|
else:
|
|
conn = libvirt.openAuth(sysuri, auth, 0)
|
|
|
|
if conn == None:
|
|
sys.exit("Unable to connect")
|
|
|
|
state_names = { libvirt.VIR_DOMAIN_RUNNING : "running",
|
|
libvirt.VIR_DOMAIN_BLOCKED : "idle",
|
|
libvirt.VIR_DOMAIN_PAUSED : "paused",
|
|
libvirt.VIR_DOMAIN_SHUTDOWN : "in shutdown",
|
|
libvirt.VIR_DOMAIN_SHUTOFF : "shut off",
|
|
libvirt.VIR_DOMAIN_CRASHED : "crashed",
|
|
libvirt.VIR_DOMAIN_NOSTATE : "no state" }
|
|
|
|
domNames = ()
|
|
for domID in conn.listDomainsID():
|
|
domain = conn.lookupByID(domID)
|
|
domNames += ([domain.name(), state_names[domain.info()[0]], domain.XMLDesc(0)],)
|
|
|
|
for dom in conn.listDefinedDomains():
|
|
domain = conn.lookupByName(dom)
|
|
domNames += ([domain.name(), state_names[domain.info()[0]], domain.XMLDesc(0)],)
|
|
|
|
conn.close()
|
|
return domNames
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_libvirt_domains(sysuri text, syspassword text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: get_libvirt_platform(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_libvirt_platform(input_name text) RETURNS SETOF libvirt.platforms
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "libvirt"."platforms" WHERE "platform_name" = input_name);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_libvirt_platform(input_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_libvirt_platform(input_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_libvirt_platform(input_name text) IS 'Get a libvirt platform';
|
|
|
|
|
|
--
|
|
-- Name: get_local_user_level(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_local_user_level(input_user text) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_user = 'root' THEN
|
|
RETURN 'admin';
|
|
END IF;
|
|
|
|
IF input_user IN (SELECT "user" FROM api.get_group_members(api.get_site_configuration('DEFAULT_LOCAL_ADMIN_GROUP'))) THEN
|
|
RETURN 'ADMIN';
|
|
END IF;
|
|
|
|
IF input_user IN (SELECT "user" FROM "management"."group_members" JOIN "management"."groups" ON "management"."groups"."group" = "management"."group_members"."group" WHERE "management"."groups"."privilege" = 'USER') THEN
|
|
RETURN 'USER';
|
|
END IF;
|
|
|
|
IF input_user IN (SELECT "user" FROM "management"."group_members" JOIN "management"."groups" ON "management"."groups"."group" = "management"."group_members"."group" WHERE "management"."groups"."privilege" = 'PROGRAM') THEN
|
|
RETURN 'PROGRAM';
|
|
END IF;
|
|
|
|
IF input_user IN (SELECT "user" FROM api.get_group_members(api.get_site_configuration('DEFAULT_LOCAL_USER_GROUP'))) THEN
|
|
RETURN 'USER';
|
|
END IF;
|
|
|
|
RETURN 'NONE';
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_local_user_level(input_user text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_local_user_level(input_user text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_local_user_level(input_user text) IS 'Get the users privilege level based on local tables';
|
|
|
|
|
|
--
|
|
-- Name: get_network_snmp(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_network_snmp(input_system_name text) RETURNS SETOF network.snmp
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."systems" WHERE "system_name" = input_system_name) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to get SNMP credentials denied: You are not owner or admin';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Return
|
|
RETURN QUERY (SELECT * FROM "network"."snmp" WHERE "system_name" = input_system_name);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_network_snmp(input_system_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_network_snmp(input_system_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_network_snmp(input_system_name text) IS 'Get SNMP connection information for a system';
|
|
|
|
|
|
--
|
|
-- Name: get_network_switchport(text, integer); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_network_switchport(text, integer) RETURNS SETOF network.switchports
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
|
|
# Input parameters
|
|
my $systemName = shift(@_);
|
|
my $ifIndex = shift(@_);
|
|
|
|
# Connection Details
|
|
my $snmpInfo = spi_exec_query("SELECT ro_community,address FROM network.snmp WHERE system_name = '$systemName'");
|
|
my $host = $snmpInfo->{rows}[0]->{address};
|
|
my $community = $snmpInfo->{rows}[0]->{ro_community};
|
|
|
|
# Date
|
|
my $date = spi_exec_query("SELECT localtimestamp(0)");
|
|
$date = $date->{rows}[0]->{timestamp};
|
|
my $user = spi_exec_query("SELECT api.get_current_user()");
|
|
$user = $user->{rows}[0]->{get_current_user};
|
|
|
|
# OIDs
|
|
my $OID_ifName = ".1.3.6.1.2.1.31.1.1.1.1.$ifIndex";
|
|
my $OID_ifDesc = ".1.3.6.1.2.1.2.2.1.2.$ifIndex";
|
|
my $OID_ifAlias = ".1.3.6.1.2.1.31.1.1.1.18.$ifIndex";
|
|
my $OID_ifOperStatus = ".1.3.6.1.2.1.2.2.1.8.$ifIndex";
|
|
my $OID_ifAdminStatus = ".1.3.6.1.2.1.2.2.1.7.$ifIndex";
|
|
my $OID_vmVlan = ".1.3.6.1.4.1.9.9.68.1.2.2.1.2.$ifIndex";
|
|
|
|
# Establish session
|
|
my ($session,$error) = Net::SNMP->session (
|
|
-hostname => "$host",
|
|
-community => "$community",
|
|
);
|
|
|
|
# Check that it did not error
|
|
if (!defined($session)) {
|
|
die $error;
|
|
}
|
|
|
|
# Data
|
|
my $result = $session->get_request(
|
|
-varbindlist => [ $OID_ifName, $OID_ifDesc, $OID_ifAlias, $OID_ifOperStatus, $OID_ifAdminStatus ]
|
|
);
|
|
|
|
# Check for errors
|
|
if(!defined($result)) {
|
|
die $session->error();
|
|
}
|
|
|
|
my $vlanResult = $session->get_request(
|
|
-varbindlist => [ $OID_vmVlan ]
|
|
);
|
|
|
|
# Gracefully disconnect
|
|
$session->close();
|
|
|
|
# Deal with results
|
|
if(!$vlanResult->{$OID_vmVlan}) { $result->{$OID_vmVlan} = undef; } else { $result->{$OID_vmVlan} = $vlanResult->{$OID_vmVlan}; }
|
|
if($result->{$OID_ifAlias} eq 'noSuchInstance') { $result->{$OID_ifAlias} = undef; }
|
|
if($result->{$OID_ifOperStatus}-1 == 0) { $result->{$OID_ifOperStatus} = 1; } else { $result->{$OID_ifOperStatus} = 0; }
|
|
if($result->{$OID_ifAdminStatus}-1 == 0) { $result->{$OID_ifAdminStatus} = 1; } else { $result->{$OID_ifAdminStatus} = 0; }
|
|
|
|
# Return
|
|
return_next({system_name=>$systemName, name=>$result->{$OID_ifName}, desc=>$result->{$OID_ifDesc}, ifindex=>$ifIndex, alias=>$result->{$OID_ifAlias}, admin_state=>$result->{$OID_ifAdminStatus}, oper_state=>$result->{$OID_ifOperStatus}, vlan=>$result->{$OID_vmVlan},date_created=>$date, date_modified=>$date, last_modifier=>$user});
|
|
return undef;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_network_switchport(text, integer) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_network_switchport(text, integer); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_network_switchport(text, integer) IS 'Get information on a specific switchport';
|
|
|
|
|
|
--
|
|
-- Name: get_network_switchports(text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_network_switchports(text) RETURNS SETOF integer
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
|
|
# Input parameters
|
|
my $systemName = shift(@_);
|
|
|
|
# Connection Details
|
|
my $snmpInfo = spi_exec_query("SELECT ro_community,address FROM network.snmp WHERE system_name = '$systemName'");
|
|
my $host = $snmpInfo->{rows}[0]->{address};
|
|
my $community = $snmpInfo->{rows}[0]->{ro_community};
|
|
|
|
# OIDs
|
|
my $OID_ifName = ".1.3.6.1.2.1.31.1.1.1.1";
|
|
|
|
# Establish session
|
|
my ($session,$error) = Net::SNMP->session (
|
|
-hostname => "$host",
|
|
-community => "$community",
|
|
);
|
|
|
|
# Check that it did not error
|
|
if (!defined($session)) {
|
|
die $error;
|
|
}
|
|
|
|
# Data
|
|
my $ifList = $session->get_table(-baseoid => $OID_ifName);
|
|
|
|
# Check for errors
|
|
if(!defined($ifList)) {
|
|
die $session->error();
|
|
}
|
|
|
|
# Deal with results
|
|
while ( my ($ifIndex, $ifName) = each(%$ifList)) {
|
|
$ifIndex =~ s/$OID_ifName\.//;
|
|
return_next($ifIndex);
|
|
}
|
|
|
|
# Gracefully disconnect
|
|
$session->close();
|
|
|
|
# Return
|
|
return undef;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_network_switchports(text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_network_switchports(text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_network_switchports(text) IS 'Get a list of all switchport indexes on a system';
|
|
|
|
|
|
--
|
|
-- Name: get_operating_systems(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_operating_systems() RETURNS SETOF text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "name" FROM "systems"."os" ORDER BY "name" ASC);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_operating_systems() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_operating_systems(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_operating_systems() IS 'Get a list of all available system types';
|
|
|
|
|
|
--
|
|
-- Name: get_os_distribution(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_os_distribution() RETURNS SETOF systems.os_distribution
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY(SELECT "os_name",count("os_name")::integer,round(count("os_name")::numeric/(SELECT count(*)::numeric FROM "systems"."systems")*100,0)::integer AS "percentage"
|
|
FROM "systems"."systems"
|
|
JOIN "systems"."os" ON "systems"."systems"."os_name" = "systems"."os"."name"
|
|
GROUP BY "os_name"
|
|
ORDER BY count("os_name") DESC);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_os_distribution() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_os_distribution(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_os_distribution() IS 'Get fun statistics on registered operating systems';
|
|
|
|
|
|
--
|
|
-- Name: get_os_family_distribution(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_os_family_distribution() RETURNS SETOF systems.os_family_distribution
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY(SELECT "family",count("family")::integer,round(count("family")::numeric/(SELECT count(*)::numeric FROM "systems"."systems")*100,0)::integer AS "percentage"
|
|
FROM "systems"."systems"
|
|
JOIN "systems"."os" ON "systems"."systems"."os_name" = "systems"."os"."name"
|
|
GROUP BY "family"
|
|
ORDER BY count("family") DESC);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_os_family_distribution() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_os_family_distribution(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_os_family_distribution() IS 'Get fun statistics on registered operating system families';
|
|
|
|
|
|
--
|
|
-- Name: get_owned_interface_addresses(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_owned_interface_addresses(input_owner text) RETURNS SETOF systems.interface_addresses
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_owner IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "systems"."interface_addresses");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "systems"."interface_addresses" WHERE api.get_interface_address_owner("address") = input_owner);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_owned_interface_addresses(input_owner text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_owned_interface_addresses(input_owner text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_owned_interface_addresses(input_owner text) IS 'Get all interface address data for all addresses owned by a given user';
|
|
|
|
|
|
--
|
|
-- Name: get_platforms(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_platforms() RETURNS SETOF systems.platforms
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "systems"."platforms" ORDER BY CASE WHEN "platform_name" = 'Custom' THEN 1 ELSE 2 END);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_platforms() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_platforms(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_platforms() IS 'Get information on all system platforms';
|
|
|
|
|
|
--
|
|
-- Name: get_range_addresses(inet, inet); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_range_addresses(inet, inet) RETURNS SETOF inet
|
|
LANGUAGE plperlu
|
|
AS $_X$
|
|
use strict;
|
|
use warnings;
|
|
use Net::IP;
|
|
use Net::IP qw(:PROC);
|
|
use feature 'switch';
|
|
|
|
# Define range
|
|
my $range = new Net::IP ("$_[0] - $_[1]");
|
|
my @addresses;
|
|
|
|
# Loop through range
|
|
while ($range)
|
|
{
|
|
push(@addresses, ip_compress_address($range->ip(), 6));
|
|
$range++;
|
|
}
|
|
|
|
# Done
|
|
return \@addresses;
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.get_range_addresses(inet, inet) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_range_addresses(inet, inet); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_range_addresses(inet, inet) IS 'return a list of all addresses within a given range';
|
|
|
|
|
|
--
|
|
-- Name: get_range_groups(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_range_groups(input_name text) RETURNS SETOF management.groups
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "management"."groups" WHERE "group" IN (SELECT "group_name" FROM "ip"."range_groups" WHERE "range_name" = input_name) ORDER BY "group");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_range_groups(input_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: get_range_top_users(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_range_top_users(input_name text) RETURNS TABLE("user" text, count integer)
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY(
|
|
SELECT
|
|
api.get_interface_address_owner(address),
|
|
count(api.get_interface_address_owner(address))::integer
|
|
FROM
|
|
systems.interface_addresses
|
|
WHERE api.get_address_range(address) = input_name
|
|
GROUP BY api.get_interface_address_owner(address)
|
|
ORDER BY count(api.get_interface_address_owner(address))
|
|
DESC limit 10
|
|
);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_range_top_users(input_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_range_top_users(input_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_range_top_users(input_name text) IS 'Get the top 10 users of range addresses';
|
|
|
|
|
|
--
|
|
-- Name: get_range_utilization(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_range_utilization(input_range text) RETURNS TABLE(inuse integer, free integer, total integer)
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (
|
|
SELECT COUNT("systems"."interface_addresses"."address")::integer AS "inuse",
|
|
(api.get_ip_range_total(input_range) - COUNT("systems"."interface_addresses"."address"))::integer AS "free",
|
|
api.get_ip_range_total(input_range)::integer AS "total"
|
|
FROM "systems"."interface_addresses"
|
|
WHERE api.get_address_range("address") = input_range);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_range_utilization(input_range text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_range_utilization(input_range text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_range_utilization(input_range text) IS 'Get statistics on range utilization';
|
|
|
|
|
|
--
|
|
-- Name: get_record_types(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_record_types() RETURNS SETOF text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "type" FROM "dns"."types" ORDER BY "type" ASC);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_record_types() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_record_types(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_record_types() IS 'Get all of the valid DNS types for this application';
|
|
|
|
|
|
--
|
|
-- Name: get_reverse_domain(inet); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_reverse_domain(inet) RETURNS text
|
|
LANGUAGE plperlu
|
|
AS $_X$
|
|
use strict;
|
|
use warnings;
|
|
use Net::IP;
|
|
use Net::IP qw(:PROC);
|
|
|
|
# Return the rdns string for nsupdate from the given address. Automagically figures out IPv4 and IPv6.
|
|
my $reverse_domain = new Net::IP ($_[0])->reverse_ip() or die (Net::IP::Error());
|
|
$reverse_domain =~ s/\.$//;
|
|
return $reverse_domain;
|
|
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.get_reverse_domain(inet) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_reverse_domain(inet); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_reverse_domain(inet) IS 'Use a convenient Perl module to generate and return the RDNS record for a given address';
|
|
|
|
|
|
--
|
|
-- Name: get_search_data(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_search_data() RETURNS SETOF management.search_data
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT
|
|
"systems"."systems"."datacenter",
|
|
(SELECT "zone" FROM "ip"."ranges" WHERE "name" = "api"."get_address_range"("systems"."interface_addresses"."address")) AS "availability_zone",
|
|
"systems"."systems"."system_name",
|
|
"systems"."systems"."location",
|
|
"systems"."systems"."asset",
|
|
"systems"."systems"."group",
|
|
"systems"."systems"."platform_name",
|
|
"systems"."interfaces"."mac",
|
|
"systems"."interface_addresses"."address",
|
|
"systems"."interface_addresses"."config",
|
|
"systems"."systems"."owner" AS "system_owner",
|
|
"systems"."systems"."last_modifier" AS "system_last_modifier",
|
|
"api"."get_address_range"("systems"."interface_addresses"."address") AS "range",
|
|
"dns"."a"."hostname",
|
|
"dns"."cname"."alias",
|
|
"dns"."srv"."alias",
|
|
"dns"."a"."zone",
|
|
"dns"."a"."owner" AS "dns_owner",
|
|
"dns"."a"."last_modifier" AS "dns_last_modifier"
|
|
FROM "systems"."systems"
|
|
LEFT JOIN "systems"."interfaces" ON "systems"."interfaces"."system_name" = "systems"."systems"."system_name"
|
|
LEFT JOIN "systems"."interface_addresses" ON "systems"."interface_addresses"."mac" = "systems"."interfaces"."mac"
|
|
LEFT JOIN "dns"."a" ON "dns"."a"."address" = "systems"."interface_addresses"."address"
|
|
LEFT JOIN "dns"."cname" ON "dns"."cname"."address" = "systems"."interface_addresses"."address"
|
|
LEFT JOIN "dns"."srv" ON "dns"."srv"."address" = "systems"."interface_addresses"."address"
|
|
ORDER BY "systems"."interface_addresses"."address","systems"."interfaces"."mac");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_search_data() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_search_data(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_search_data() IS 'Get search data to parse';
|
|
|
|
|
|
--
|
|
-- Name: get_site_configuration_all(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_site_configuration_all() RETURNS SETOF management.configuration
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "management"."configuration" ORDER BY "option" ASC);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_site_configuration_all() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_site_configuration_all(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_site_configuration_all() IS 'Get all site configuration directives';
|
|
|
|
|
|
--
|
|
-- Name: get_subnet_addresses(cidr); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_subnet_addresses(cidr) RETURNS SETOF inet
|
|
LANGUAGE plperlu
|
|
AS $_X$
|
|
use strict;
|
|
use warnings;
|
|
use Net::IP;
|
|
use Net::IP qw(:PROC);
|
|
use feature 'switch';
|
|
|
|
# Define some basic information about the network.
|
|
my $subnet = new Net::IP ($_[0]) or die (Net::IP::Error());
|
|
my $broadcast_address = $subnet->last_ip();
|
|
my $network_address = $subnet->ip();
|
|
my $version = ip_get_version($network_address);
|
|
|
|
# Create an object of the range between the network address and the broadcast address.
|
|
my $range = new Net::IP ("$network_address - $broadcast_address");
|
|
my @addresses;
|
|
|
|
# Given/When is the new Switch. Perform different operations for IPv4 and IPv6.
|
|
given ($version) {
|
|
when (/4/) {
|
|
while (++$range) {
|
|
# While they technically work, .255 and .0 addresses in multi-range wide networks
|
|
# can cause confusion and possibly device problems. Well just avoid them alltogether.
|
|
if($range->ip() !~ m/\.0$|\.255$/) {
|
|
push(@addresses, $range->ip());
|
|
}
|
|
}
|
|
}
|
|
when (/6/) {
|
|
while (++$range) {
|
|
push(@addresses, ip_compress_address($range->ip(), 6));
|
|
}
|
|
}
|
|
default { die "Unable to generate\n"; }
|
|
}
|
|
|
|
# Done
|
|
return \@addresses;
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.get_subnet_addresses(cidr) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_subnet_addresses(cidr); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_subnet_addresses(cidr) IS 'Given a subnet, return an array of all acceptable addresses within that subnet.';
|
|
|
|
|
|
--
|
|
-- Name: get_subnet_utilization(cidr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_subnet_utilization(input_subnet cidr) RETURNS TABLE(inuse integer, free integer, total integer)
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
addrcount INTEGER;
|
|
BEGIN
|
|
-- Total
|
|
SELECT COUNT("address")::integer INTO addrcount
|
|
FROM "ip"."addresses" WHERE "address" << input_subnet;
|
|
|
|
RETURN QUERY (
|
|
SELECT COUNT("systems"."interface_addresses"."address"):: integer AS "inuse",
|
|
addrcount - COUNT("systems"."interface_addresses"."address"):: integer as "free",
|
|
addrcount AS "total"
|
|
FROM "systems"."interface_addresses"
|
|
WHERE "address" << input_subnet
|
|
);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_subnet_utilization(input_subnet cidr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_subnet_utilization(input_subnet cidr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_subnet_utilization(input_subnet cidr) IS 'Get statistics on subnet utilization';
|
|
|
|
|
|
--
|
|
-- Name: get_switchview_bridgeportid(inet, text, integer); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_switchview_bridgeportid(inet, text, integer) RETURNS TABLE(camportinstanceid text, bridgeportid integer)
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
use Socket;
|
|
|
|
# Define OIDs
|
|
my $dot1dTpFdbPort = ".1.3.6.1.2.1.17.4.3.1.2";
|
|
|
|
# Needed Variables
|
|
my $hostname = shift(@_) or die "Unable to get host";
|
|
my $community = shift(@_) or die "Unable to get READ community";
|
|
my $vlan = shift(@_) or die "Unable to get VLANID";
|
|
|
|
# Establish session
|
|
my ($session,$error) = Net::SNMP->session (
|
|
-hostname => "$hostname",
|
|
-community => "$community\@$vlan",
|
|
);
|
|
|
|
# Check that it did not error
|
|
if (!defined($session)) {
|
|
die $error;
|
|
}
|
|
|
|
# Get a list of all data
|
|
my $bridgePortList = $session->get_table(-baseoid => $dot1dTpFdbPort);
|
|
|
|
# Do something for each item of the list
|
|
while ( my ($camPortInstanceID, $bridgePortID) = each(%$bridgePortList)) {
|
|
$camPortInstanceID =~ s/$dot1dTpFdbPort//;
|
|
return_next({camportinstanceid=>$camPortInstanceID, bridgeportid=>$bridgePortID});
|
|
}
|
|
|
|
# Gracefully disconnect
|
|
$session->close();
|
|
|
|
# Return
|
|
return undef;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_switchview_bridgeportid(inet, text, integer) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_switchview_bridgeportid(inet, text, integer); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_switchview_bridgeportid(inet, text, integer) IS 'Get a mapping of CAM instanceIDs and bridgeIDs';
|
|
|
|
|
|
--
|
|
-- Name: get_switchview_cam(inet, text, integer); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_switchview_cam(inet, text, integer) RETURNS TABLE(camportinstanceid text, mac macaddr)
|
|
LANGUAGE plperlu
|
|
AS $_X$
|
|
#!/usr/bin/perl -w
|
|
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
use Socket;
|
|
|
|
# Define OIDs
|
|
my $dot1dTpFdbAddress = ".1.3.6.1.2.1.17.4.3.1.1";
|
|
|
|
# Needed Variables
|
|
my $hostname = shift(@_) or die "Unable to get host";
|
|
my $community = shift(@_) or die "Unable to get READ community";
|
|
my $vlan = shift(@_) or die "Unable to get VLANID";
|
|
|
|
# Subroutine to format a MAC address to something nice
|
|
sub format_raw_mac {
|
|
my $mac = $_[0];
|
|
# Get rid of the hex identifier
|
|
$mac =~ s/^0x//;
|
|
|
|
# Make groups of two characters
|
|
$mac =~ s/(.{2})/$1:/gg;
|
|
|
|
# Remove the trailing : left by the previous function
|
|
$mac =~ s/\:$//;
|
|
|
|
# Spit it back out
|
|
return $mac;
|
|
}
|
|
|
|
# Establish session
|
|
my ($session,$error) = Net::SNMP->session (
|
|
-hostname => "$hostname",
|
|
-community => "$community\@$vlan",
|
|
);
|
|
|
|
# Check that it did not error
|
|
if (!defined($session)) {
|
|
die $error;
|
|
}
|
|
|
|
# Get a list of all data
|
|
my $camList = $session->get_table(-baseoid => $dot1dTpFdbAddress);
|
|
|
|
# Do something for each item of the list
|
|
while ( my ($camPortInstanceID, $macaddr) = each(%$camList)) {
|
|
$camPortInstanceID =~ s/$dot1dTpFdbAddress//;
|
|
|
|
# Sometimes there are non-valid MAC addresses in the CAM.
|
|
if($macaddr =~ m/[0-9a-fA-F]{12}/) {
|
|
$macaddr = format_raw_mac($macaddr);
|
|
#print "InstanceID: $camPortInstanceID - MAC: $macaddr\n";
|
|
return_next({camportinstanceid=>$camPortInstanceID,mac=>$macaddr});
|
|
}
|
|
}
|
|
|
|
# Gracefully disconnect
|
|
$session->close();
|
|
|
|
# Return
|
|
return undef;
|
|
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.get_switchview_cam(inet, text, integer) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_switchview_cam(inet, text, integer); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_switchview_cam(inet, text, integer) IS 'Get the CAM/MAC table from a device on a certain VLAN';
|
|
|
|
|
|
--
|
|
-- Name: get_switchview_device_cam(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_switchview_device_cam(input_system text) RETURNS SETOF network.cam
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
Vlans RECORD;
|
|
CamData RECORD;
|
|
input_host INET;
|
|
input_community TEXT;
|
|
BEGIN
|
|
SELECT get_system_primary_address::inet INTO input_host FROM api.get_system_primary_address(input_system);
|
|
IF input_host IS NULL THEN
|
|
RAISE EXCEPTION 'Unable to find address for system %',input_system;
|
|
END IF;
|
|
SELECT ro_community INTO input_community FROM api.get_network_snmp(input_system);
|
|
IF input_community IS NULL THEN
|
|
RAISE EXCEPTION 'Unable to find SNMP settings for system %',input_system;
|
|
END IF;
|
|
|
|
FOR Vlans IN (SELECT "vlan" FROM "network"."vlans" WHERE "datacenter" = (SELECT "datacenter" FROM "systems"."systems" WHERE "system_name" = input_system) AND "vlan" IS NOT NULL GROUP BY "vlan" ORDER BY "vlan") LOOP
|
|
FOR CamData IN (
|
|
SELECT mac,portindex.ifindex,Vlans.vlan FROM api.get_switchview_cam(input_host,input_community,vlans.vlan) AS "cam"
|
|
JOIN api.get_switchview_bridgeportid(input_host,input_community,vlans.vlan) AS "bridgeportid"
|
|
ON bridgeportid.camportinstanceid = cam.camportinstanceid
|
|
JOIN api.get_switchview_portindex(input_host,input_community,vlans.vlan) AS "portindex"
|
|
ON bridgeportid.bridgeportid = portindex.bridgeportid
|
|
) LOOP
|
|
RETURN NEXT CamData;
|
|
END LOOP;
|
|
END LOOP;
|
|
RETURN;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_switchview_device_cam(input_system text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_switchview_device_cam(input_system text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_switchview_device_cam(input_system text) IS 'Get all CAM data from a particular device';
|
|
|
|
|
|
--
|
|
-- Name: get_switchview_device_switchports(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_switchview_device_switchports(input_system text) RETURNS SETOF network.switchports
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
system_address INET;
|
|
system_community TEXT;
|
|
BEGIN
|
|
SELECT get_system_primary_address::inet INTO system_address FROM api.get_system_primary_address(input_system);
|
|
IF system_address IS NULL THEN
|
|
RAISE EXCEPTION 'Unable to find address for system %',input_system;
|
|
END IF;
|
|
SELECT ro_community INTO system_community FROM api.get_network_snmp(input_system);
|
|
IF system_community IS NULL THEN
|
|
RAISE EXCEPTION 'Unable to find SNMP settings for system %',input_system;
|
|
END IF;
|
|
|
|
RETURN QUERY (
|
|
SELECT "ifadminstatus","ifoperstatus","ifname","ifdesc","ifalias"
|
|
FROM api.get_switchview_port_names(system_address, system_community) AS "namedata"
|
|
JOIN api.get_switchview_port_adminstatus(system_address, system_community) AS "admindata"
|
|
ON "admindata"."ifindex" = "namedata"."ifindex"
|
|
JOIN api.get_switchview_port_operstatus(system_address, system_community) AS "operdata"
|
|
ON "operdata"."ifindex" = "namedata"."ifindex"
|
|
JOIN api.get_switchview_port_descriptions(system_address, system_community) AS "descdata"
|
|
ON "descdata"."ifindex" = "namedata"."ifindex"
|
|
);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_switchview_device_switchports(input_system text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_switchview_device_switchports(input_system text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_switchview_device_switchports(input_system text) IS 'Get data on all switchports on a system';
|
|
|
|
|
|
--
|
|
-- Name: get_switchview_neighbors(inet, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_switchview_neighbors(inet, text) RETURNS TABLE("localifIndex" integer, remoteifdesc text, remotehostname text)
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
use Socket;
|
|
use 5.10.0;
|
|
|
|
# Define OIDs
|
|
my $cdpCacheEntry = "1.3.6.1.4.1.9.9.23.1.2.1.1";
|
|
my $cdpCacheIfIndex = "1";
|
|
my $cdpCacheDeviceId = "6";
|
|
my $cdpCacheDevicePort = "7";
|
|
my $cdpCachePlatform = "8";
|
|
|
|
# Needed Variables
|
|
my $hostname = shift(@_) or die "Unable to get host";
|
|
my $community = shift(@_) or die "Unable to get READ community";
|
|
|
|
# Data containers
|
|
my %remoteHosts;
|
|
my %remotePorts;
|
|
my %remotePlatforms;
|
|
my %localPorts;
|
|
|
|
# Establish session
|
|
my ($session,$error) = Net::SNMP->session (
|
|
-hostname => "$hostname",
|
|
-community => "$community",
|
|
);
|
|
|
|
# Check that it did not error
|
|
if (!defined($session)) {
|
|
print $error;
|
|
exit 1;
|
|
}
|
|
|
|
# Get a list of all data
|
|
my $neighborList = $session->get_table(-baseoid => $cdpCacheEntry);
|
|
|
|
# Do something for each item of the list
|
|
while ( my ($id, $value) = each(%$neighborList)) {
|
|
$id=~ s/$cdpCacheEntry\.//;
|
|
|
|
if($id =~ m/^($cdpCacheDeviceId|$cdpCacheDevicePort|$cdpCachePlatform|$cdpCacheIfIndex)\./) {
|
|
my @cdpEntry = split(/\./,$id);
|
|
|
|
given ($cdpEntry[0]) {
|
|
when(/$cdpCacheDeviceId/) {
|
|
$remoteHosts{$cdpEntry[1]} = $value;
|
|
}
|
|
when(/$cdpCacheDevicePort/) {
|
|
$remotePorts{$cdpEntry[1]} = $value;
|
|
}
|
|
when(/$cdpCachePlatform/) {
|
|
$remotePlatforms{$cdpEntry[1]} = $value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach my $ifIndex (keys(%remoteHosts)) {
|
|
return_next({localifIndex=>$ifIndex,remoteifdesc=>$remotePorts{$ifIndex}, remotehostname=>$remoteHosts{$ifIndex}});
|
|
}
|
|
|
|
# Gracefully disconnect
|
|
$session->close();
|
|
|
|
# Return
|
|
return undef;
|
|
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_switchview_neighbors(inet, text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_switchview_neighbors(inet, text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_switchview_neighbors(inet, text) IS 'Get the CDP table from a device to see who it is attached to';
|
|
|
|
|
|
--
|
|
-- Name: get_switchview_port_adminstatus(inet, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_switchview_port_adminstatus(inet, text) RETURNS TABLE(ifindex integer, ifadminstatus boolean)
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
use Socket;
|
|
|
|
# Define OIDs
|
|
my $ifAdminStatus = ".1.3.6.1.2.1.2.2.1.7";
|
|
|
|
# Needed Variables
|
|
my $hostname = shift(@_) or die "Unable to get host";
|
|
my $community = shift(@_) or die "Unable to get READ community";
|
|
|
|
# Establish session
|
|
my ($session,$error) = Net::SNMP->session (
|
|
-hostname => "$hostname",
|
|
-community => "$community",
|
|
);
|
|
|
|
# Check that it did not error
|
|
if (!defined($session)) {
|
|
die $error;
|
|
}
|
|
|
|
# Get a list of all data
|
|
my $portStates = $session->get_table(-baseoid => $ifAdminStatus);
|
|
|
|
# Do something for each item of the list
|
|
while ( my ($portIndex, $portState) = each(%$portStates)) {
|
|
$portIndex =~ s/$ifAdminStatus\.//;
|
|
if($portState-1 == 0) {
|
|
# Then its up
|
|
$portState = 1;
|
|
}
|
|
else {
|
|
# Then its down
|
|
$portState = 0;
|
|
}
|
|
return_next({ifindex=>$portIndex, ifadminstatus=>$portState});
|
|
}
|
|
|
|
# Gracefully disconnect
|
|
$session->close();
|
|
|
|
# Return
|
|
return undef;
|
|
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_switchview_port_adminstatus(inet, text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_switchview_port_adminstatus(inet, text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_switchview_port_adminstatus(inet, text) IS 'Map ifindexes to port administrative status';
|
|
|
|
|
|
--
|
|
-- Name: get_switchview_port_descriptions(inet, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_switchview_port_descriptions(inet, text) RETURNS TABLE(ifindex integer, ifalias text)
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
use Socket;
|
|
|
|
# Define OIDs
|
|
my $ifAlias = "1.3.6.1.2.1.31.1.1.1.18";
|
|
|
|
# Needed Variables
|
|
my $hostname = shift(@_) or die "Unable to get host";
|
|
my $community = shift(@_) or die "Unable to get READ community";
|
|
|
|
# Establish session
|
|
my ($session,$error) = Net::SNMP->session (
|
|
-hostname => "$hostname",
|
|
-community => "$community",
|
|
);
|
|
|
|
# Check that it did not error
|
|
if (!defined($session)) {
|
|
die $error;
|
|
}
|
|
|
|
# Get a list of all data
|
|
my $portAliases = $session->get_table(-baseoid => $ifAlias);
|
|
|
|
# Do something for each item of the list
|
|
while ( my ($portIndex, $portAlias) = each(%$portAliases)) {
|
|
$portIndex =~ s/$ifAlias\.//;
|
|
return_next({ifindex=>$portIndex, ifalias=>$portAlias});
|
|
}
|
|
|
|
# Gracefully disconnect
|
|
$session->close();
|
|
|
|
# Return
|
|
return undef;
|
|
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_switchview_port_descriptions(inet, text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_switchview_port_descriptions(inet, text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_switchview_port_descriptions(inet, text) IS 'Map ifindexes to port descriptions (or aliases in Cisco-land)';
|
|
|
|
|
|
--
|
|
-- Name: get_switchview_port_names(inet, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_switchview_port_names(inet, text) RETURNS TABLE(ifindex integer, ifname text, ifdesc text)
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
use Socket;
|
|
|
|
# Define OIDs
|
|
my $ifName = ".1.3.6.1.2.1.31.1.1.1.1";
|
|
my $ifDesc = ".1.3.6.1.2.1.2.2.1.2";
|
|
|
|
# Needed Variables
|
|
my $hostname = shift(@_) or die "Unable to get host";
|
|
my $community = shift(@_) or die "Unable to get READ community";
|
|
my %ports;
|
|
|
|
# Establish session
|
|
my ($session,$error) = Net::SNMP->session (
|
|
-hostname => "$hostname",
|
|
-community => "$community",
|
|
);
|
|
|
|
# Check that it did not error
|
|
if (!defined($session)) {
|
|
die $error;
|
|
}
|
|
|
|
# Get a list of all data
|
|
my $portNameList = $session->get_table(-baseoid => $ifName);
|
|
my $portDescList = $session->get_table(-baseoid => $ifDesc);
|
|
|
|
# Do something for each item of the list
|
|
while ( my ($portIndex, $portName) = each(%$portNameList)) {
|
|
$portIndex =~ s/$ifName\.//;
|
|
$ports{$portIndex}{'ifName'} = $portName;
|
|
}
|
|
while ( my ($portIndex, $portDesc) = each(%$portDescList)) {
|
|
$portIndex =~ s/$ifDesc\.//;
|
|
$ports{$portIndex}{'ifDesc'} = $portDesc;
|
|
}
|
|
foreach my $key (keys(%ports)) {
|
|
return_next({ifindex=>$key, ifname=>$ports{$key}{'ifName'}, ifdesc=>$ports{$key}{'ifDesc'}});
|
|
}
|
|
|
|
# Gracefully disconnect
|
|
$session->close();
|
|
|
|
# Return
|
|
return undef;
|
|
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_switchview_port_names(inet, text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_switchview_port_names(inet, text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_switchview_port_names(inet, text) IS 'Map ifindexes to port names';
|
|
|
|
|
|
--
|
|
-- Name: get_switchview_port_operstatus(inet, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_switchview_port_operstatus(inet, text) RETURNS TABLE(ifindex integer, ifoperstatus boolean)
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
use Socket;
|
|
|
|
# Define OIDs
|
|
my $ifOperStatus = ".1.3.6.1.2.1.2.2.1.8";
|
|
|
|
# Needed Variables
|
|
my $hostname = shift(@_) or die "Unable to get host";
|
|
my $community = shift(@_) or die "Unable to get READ community";
|
|
|
|
# Establish session
|
|
my ($session,$error) = Net::SNMP->session (
|
|
-hostname => "$hostname",
|
|
-community => "$community",
|
|
);
|
|
|
|
# Check that it did not error
|
|
if (!defined($session)) {
|
|
die $error;
|
|
}
|
|
|
|
# Get a list of all data
|
|
my $portStates = $session->get_table(-baseoid => $ifOperStatus);
|
|
|
|
# Do something for each item of the list
|
|
while ( my ($portIndex, $portState) = each(%$portStates)) {
|
|
$portIndex =~ s/$ifOperStatus\.//;
|
|
if($portState-1 == 0) {
|
|
# Then its up
|
|
$portState = 1;
|
|
}
|
|
else {
|
|
# Then its down
|
|
$portState = 0;
|
|
}
|
|
return_next({ifindex=>$portIndex, ifoperstatus=>$portState});
|
|
}
|
|
|
|
# Gracefully disconnect
|
|
$session->close();
|
|
|
|
# Return
|
|
return undef;
|
|
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_switchview_port_operstatus(inet, text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_switchview_port_operstatus(inet, text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_switchview_port_operstatus(inet, text) IS 'Map ifindexes to port operational status';
|
|
|
|
|
|
--
|
|
-- Name: get_switchview_portindex(inet, text, integer); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.get_switchview_portindex(inet, text, integer) RETURNS TABLE(bridgeportid integer, ifindex integer)
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
use Socket;
|
|
|
|
# Define OIDs
|
|
my $dot1dBasePortIfIndex = ".1.3.6.1.2.1.17.1.4.1.2";
|
|
|
|
# Needed Variables
|
|
my $hostname = shift(@_) or die "Unable to get host";
|
|
my $community = shift(@_) or die "Unable to get READ community";
|
|
my $vlan = shift(@_) or die "Unable to get VLAN";
|
|
|
|
# Establish session
|
|
my ($session,$error) = Net::SNMP->session (
|
|
-hostname => "$hostname",
|
|
-community => "$community\@$vlan"
|
|
);
|
|
|
|
# Check that it did not error
|
|
if (!defined($session)) {
|
|
die $error;
|
|
}
|
|
|
|
# Get a list of all data
|
|
my $portIndexList = $session->get_table(-baseoid => $dot1dBasePortIfIndex);
|
|
|
|
# Do something for each item of the list
|
|
while ( my ($bridgePortID, $portIndex) = each(%$portIndexList)) {
|
|
$bridgePortID =~ s/$dot1dBasePortIfIndex\.//;
|
|
return_next({bridgeportid=>$bridgePortID, ifindex=>$portIndex});
|
|
}
|
|
|
|
# Gracefully disconnect
|
|
$session->close();
|
|
|
|
# Return
|
|
return undef;
|
|
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_switchview_portindex(inet, text, integer) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION get_switchview_portindex(inet, text, integer); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_switchview_portindex(inet, text, integer) IS 'Get a mapping of port indexes to bridge indexes';
|
|
|
|
|
|
--
|
|
-- Name: get_system(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system(input_system_name text) RETURNS SETOF systems.systems
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "systems"."systems" WHERE "system_name" = input_system_name);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system(input_system_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system(input_system_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system(input_system_name text) IS 'Get a single system';
|
|
|
|
|
|
--
|
|
-- Name: architectures; Type: TABLE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE systems.architectures (
|
|
architecture text NOT NULL,
|
|
comment text,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE systems.architectures OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE architectures; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE systems.architectures IS 'The CPU architecture of a platform';
|
|
|
|
|
|
--
|
|
-- Name: get_system_architectures(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system_architectures() RETURNS SETOF systems.architectures
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "systems"."architectures" ORDER BY CASE WHEN "architecture" = 'i386' THEN 1 ELSE 2 END);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system_architectures() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system_architectures(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system_architectures() IS 'Get all the available system architectures';
|
|
|
|
|
|
--
|
|
-- Name: get_system_cam(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system_cam(input_system_name text) RETURNS SETOF network.cam_cache
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."systems" WHERE "system_name" = input_system_name) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to get CAM denied: You are not owner or admin';
|
|
END IF;
|
|
END IF;
|
|
|
|
RETURN QUERY (SELECT * FROM "network"."cam_cache" WHERE "system_name" = input_system_name ORDER BY "vlan","ifindex","mac");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system_cam(input_system_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system_cam(input_system_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system_cam(input_system_name text) IS 'Get the latest CAM data from the cache';
|
|
|
|
|
|
--
|
|
-- Name: get_system_interface_address(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system_interface_address(input_address inet) RETURNS SETOF systems.interface_addresses
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "systems"."interface_addresses" WHERE "address" = input_address);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system_interface_address(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system_interface_address(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system_interface_address(input_address inet) IS 'Get all interface address data for an address';
|
|
|
|
|
|
--
|
|
-- Name: get_system_interface_addresses(macaddr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system_interface_addresses(input_mac macaddr) RETURNS SETOF systems.interface_addresses
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_mac IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "systems"."interface_addresses" ORDER BY family(address),address);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "systems"."interface_addresses" WHERE "mac" = input_mac ORDER BY family(address),address ASC);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system_interface_addresses(input_mac macaddr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system_interface_addresses(input_mac macaddr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system_interface_addresses(input_mac macaddr) IS 'Get all interface addresses on a specified MAC';
|
|
|
|
|
|
--
|
|
-- Name: get_system_interface_data(macaddr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system_interface_data(input_mac macaddr) RETURNS SETOF systems.interfaces
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "systems"."interfaces" WHERE "mac" = input_mac);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system_interface_data(input_mac macaddr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system_interface_data(input_mac macaddr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system_interface_data(input_mac macaddr) IS 'Get all interface information on a system for a specific interface';
|
|
|
|
|
|
--
|
|
-- Name: get_system_interfaces(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system_interfaces(input_system_name text) RETURNS SETOF systems.interfaces
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_system_name IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "systems"."interfaces" ORDER BY mac);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "systems"."interfaces" WHERE "system_name" = input_system_name ORDER BY mac);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system_interfaces(input_system_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system_interfaces(input_system_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system_interfaces(input_system_name text) IS 'Get all interface information on a system';
|
|
|
|
|
|
--
|
|
-- Name: get_system_owner(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system_owner(input_system text) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT "owner" FROM "systems"."systems" WHERE "system_name" = input_system);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system_owner(input_system text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system_owner(input_system text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system_owner(input_system text) IS 'Easily get the owner of a system';
|
|
|
|
|
|
--
|
|
-- Name: get_system_permissions(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system_permissions(input_system_name text) RETURNS TABLE(read boolean, write boolean)
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
read BOOLEAN;
|
|
write BOOLEAN;
|
|
sysowner TEXT;
|
|
sysgroup TEXT;
|
|
BEGIN
|
|
SELECT "owner","group" INTO sysowner, sysgroup
|
|
FROM "systems"."systems"
|
|
WHERE "system_name" = input_system_name;
|
|
|
|
IF sysowner IS NULL THEN
|
|
RAISE EXCEPTION 'System % not found!',input_system_name;
|
|
END IF;
|
|
|
|
IF sysgroup IN (SELECT * FROM api.get_current_user_groups()) THEN
|
|
IF api.get_current_user() IN (SELECT * FROM api.get_group_admins(sysgroup)) THEN
|
|
read := TRUE;
|
|
write := TRUE;
|
|
ELSE
|
|
read := TRUE;
|
|
write := FALSE;
|
|
END IF;
|
|
ELSE
|
|
read := TRUE;
|
|
write := FALSE;
|
|
END IF;
|
|
|
|
IF sysowner = api.get_current_user() THEN
|
|
read := TRUE;
|
|
write := TRUE;
|
|
|
|
END IF;
|
|
|
|
IF api.get_current_user_level() ~* 'ADMIN' THEN
|
|
read := TRUE;
|
|
write := TRUE;
|
|
END IF;
|
|
RETURN QUERY (SELECT read, write);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system_permissions(input_system_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system_permissions(input_system_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system_permissions(input_system_name text) IS 'Get the current user permissions on a system';
|
|
|
|
|
|
--
|
|
-- Name: get_system_primary_address(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system_primary_address(input_system_name text) RETURNS inet
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT "address" FROM "systems"."systems"
|
|
JOIN "systems"."interfaces" ON "systems"."interfaces"."system_name" = "systems"."systems"."system_name"
|
|
JOIN "systems"."interface_addresses" ON "systems"."interfaces"."mac" = "systems"."interface_addresses"."mac"
|
|
WHERE "isprimary" = TRUE AND "systems"."systems"."system_name" = input_system_name
|
|
ORDER BY "systems"."interfaces"."mac" DESC LIMIT 1);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system_primary_address(input_system_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system_primary_address(input_system_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system_primary_address(input_system_name text) IS 'Get the primary address of a system';
|
|
|
|
|
|
--
|
|
-- Name: get_system_switchports(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system_switchports(input_system text) RETURNS SETOF network.switchports
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
IfIndexes RECORD;
|
|
Ints network.switchports%rowtype;
|
|
BEGIN
|
|
FOR IfIndexes IN (SELECT * FROM api.get_network_switchports(input_system) ORDER BY get_network_switchports) LOOP
|
|
--RETURN NEXT api.get_network_switchport(input_system, IfIndexes.get_network_switchports);
|
|
SELECT * FROM api.get_network_switchport(input_system, IfIndexes.get_network_switchports) INTO Ints;
|
|
RETURN NEXT Ints;
|
|
END LOOP;
|
|
RETURN;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system_switchports(input_system text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system_switchports(input_system text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system_switchports(input_system text) IS 'Get the most recent cached switchport data';
|
|
|
|
|
|
--
|
|
-- Name: device_types; Type: TABLE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE systems.device_types (
|
|
type text NOT NULL,
|
|
family text NOT NULL,
|
|
CONSTRAINT device_types_family_check CHECK ((family ~ '^PC|Network$'::text))
|
|
);
|
|
|
|
|
|
ALTER TABLE systems.device_types OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE device_types; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE systems.device_types IS 'Computers are different than switches and routers, as they appear in the network overview.';
|
|
|
|
|
|
--
|
|
-- Name: get_system_types(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_system_types() RETURNS SETOF systems.device_types
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "systems"."device_types" ORDER BY "type");
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_system_types() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_system_types(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_system_types() IS 'Get a list of all available system types';
|
|
|
|
|
|
--
|
|
-- Name: get_systems(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_systems(input_username text) RETURNS SETOF systems.systems
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_username IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "systems"."systems" ORDER BY lower("system_name") ASC);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "systems"."systems" WHERE "owner" = input_username ORDER BY lower("system_name") ASC);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_systems(input_username text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_systems(input_username text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_systems(input_username text) IS 'Get all system names owned by a given user';
|
|
|
|
|
|
--
|
|
-- Name: get_user_email(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_user_email(input_user text) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
IF api.get_site_configuration('USER_PRIVILEGE_SOURCE') ~* '^ad$' THEN
|
|
RETURN api.get_ad_user_email(input_user);
|
|
ELSE
|
|
RETURN input_user||'@'||api.get_site_configuration('EMAIL_DOMAIN');
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.get_user_email(input_user text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_user_email(input_user text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_user_email(input_user text) IS 'Get the email address of a user';
|
|
|
|
|
|
--
|
|
-- Name: get_user_groups(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_user_groups(input_user text) RETURNS SETOF management.groups
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT * FROM "management"."groups" WHERE "group" IN (
|
|
SELECT "group" FROM "management"."group_members" WHERE "user" = input_user)
|
|
ORDER BY "group"
|
|
);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_user_groups(input_user text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_user_groups(input_user text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_user_groups(input_user text) IS 'Get all of the groups that a user belongs to';
|
|
|
|
|
|
--
|
|
-- Name: get_user_ranges(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_user_ranges(input_user text) RETURNS SETOF ip.ranges
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
UserGroups RECORD;
|
|
GroupRanges RECORD;
|
|
RangeData RECORD;
|
|
BEGIN
|
|
--IF api.get_current_user_level() ~* 'ADMIN' THEN
|
|
-- RETURN QUERY (SELECT * FROM "ip"."ranges" ORDER BY "name");
|
|
--END IF;
|
|
|
|
FOR UserGroups IN (SELECT "group" FROM "management"."group_members" WHERE "user" = input_user) LOOP
|
|
FOR RangeData IN (SELECT * FROM api.get_group_ranges(UserGroups."group")) LOOP
|
|
RETURN NEXT RangeData;
|
|
END LOOP;
|
|
END LOOP;
|
|
|
|
RETURN;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_user_ranges(input_user text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: get_vlans(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.get_vlans(input_datacenter text) RETURNS SETOF network.vlans
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_datacenter IS NULL THEN
|
|
RETURN QUERY (SELECT * FROM "network"."vlans" ORDER BY "datacenter","vlan");
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "network"."vlans" WHERE "datacenter" = input_datacenter ORDER BY "vlan");
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.get_vlans(input_datacenter text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION get_vlans(input_datacenter text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.get_vlans(input_datacenter text) IS 'Get all or a systems vlans';
|
|
|
|
|
|
--
|
|
-- Name: initialize(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.initialize(input_username text) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
Level TEXT;
|
|
BEGIN
|
|
-- Get level
|
|
IF api.get_site_configuration('USER_PRIVILEGE_SOURCE') ~* 'ldap' THEN
|
|
SELECT api.get_ldap_user_level(input_username) INTO Level;
|
|
ELSEIF api.get_site_configuration('USER_PRIVILEGE_SOURCE') ~* 'ad' THEN
|
|
SELECT api.get_ad_user_level(input_username) INTO Level;
|
|
ELSE
|
|
SELECT api.get_local_user_level(input_username) INTO Level;
|
|
END IF;
|
|
|
|
IF Level='NONE' THEN
|
|
RAISE EXCEPTION 'Could not identify "%".',input_username;
|
|
END IF;
|
|
|
|
-- Create privilege table
|
|
DROP TABLE IF EXISTS "user_privileges";
|
|
|
|
CREATE TEMPORARY TABLE "user_privileges"
|
|
(username text NOT NULL,privilege text NOT NULL,
|
|
allow boolean NOT NULL DEFAULT false);
|
|
|
|
-- Populate privileges
|
|
INSERT INTO "user_privileges" VALUES (input_username,'USERNAME',TRUE);
|
|
INSERT INTO "user_privileges" VALUES (input_username,'ADMIN',FALSE);
|
|
INSERT INTO "user_privileges" VALUES (input_username,'PROGRAM',FALSE);
|
|
INSERT INTO "user_privileges" VALUES (input_username,'USER',FALSE);
|
|
ALTER TABLE "user_privileges" ALTER COLUMN "username" SET DEFAULT api.get_current_user();
|
|
|
|
-- Set level
|
|
UPDATE "user_privileges" SET "allow" = TRUE WHERE "privilege" ~* Level;
|
|
|
|
RETURN 'Greetings '||lower(Level)||'!';
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.initialize(input_username text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION initialize(input_username text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.initialize(input_username text) IS 'Setup user access to the database';
|
|
|
|
|
|
--
|
|
-- Name: ip_arp(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.ip_arp(input_address inet) RETURNS macaddr
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN (SELECT "mac" FROM "systems"."interface_addresses" WHERE "address" = input_address);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.ip_arp(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION ip_arp(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.ip_arp(input_address inet) IS 'Get the MAC address assiciated with an IP address';
|
|
|
|
|
|
--
|
|
-- Name: ip_in_subnet(inet, cidr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.ip_in_subnet(input_address inet, input_subnet cidr) RETURNS boolean
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_address << input_subnet THEN
|
|
RETURN TRUE;
|
|
ELSE
|
|
RETURN FALSE;
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.ip_in_subnet(input_address inet, input_subnet cidr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION ip_in_subnet(input_address inet, input_subnet cidr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.ip_in_subnet(input_address inet, input_subnet cidr) IS 'True or False if an address is contained within a given subnet';
|
|
|
|
|
|
--
|
|
-- Name: ip_is_dynamic(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.ip_is_dynamic(input_address inet) RETURNS boolean
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF input_address << cidr((SELECT api.get_site_configuration('DYNAMIC_SUBNET'))) THEN
|
|
RETURN TRUE;
|
|
ELSE
|
|
RETURN FALSE;
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.ip_is_dynamic(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: modify_availability_zone(text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_availability_zone(input_old_datacenter text, input_old_zone text, input_field text, input_new_value text) RETURNS SETOF systems.availability_zones
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to edit availability zone denied. You are not admin';
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'datacenter|zone|comment' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Update record
|
|
|
|
EXECUTE 'UPDATE "systems"."availability_zones" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "datacenter" = $1 AND "zone" = $2'
|
|
USING input_old_datacenter, input_old_zone, input_field, input_new_value;
|
|
|
|
-- Done
|
|
|
|
PERFORM api.syslog('modify_availability_zone:"'||input_old_datacenter||'","'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'zone' THEN
|
|
RETURN QUERY (SELECT * FROM "systems"."availability_zones" WHERE "datacenter" = input_old_datacenter AND "zone" = input_new_value);
|
|
ELSEIF input_field ~* 'datacenter' THEN
|
|
RETURN QUERY (SELECT * FROM "systems"."availability_zones" WHERE "datacenter" = input_new_value AND "zone" = input_old_zone);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "systems"."availability_zones" WHERE "datacenter" = input_old_datacenter AND "zone" = input_old_zone);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_availability_zone(input_old_datacenter text, input_old_zone text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_availability_zone(input_old_datacenter text, input_old_zone text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_availability_zone(input_old_datacenter text, input_old_zone text, input_field text, input_new_value text) IS 'modify a availability_zone';
|
|
|
|
|
|
--
|
|
-- Name: modify_datacenter(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_datacenter(input_old_name text, input_field text, input_new_value text) RETURNS SETOF systems.datacenters
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to edit address % denied. You are not admin';
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'datacenter|comment' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Update record
|
|
|
|
EXECUTE 'UPDATE "systems"."datacenters" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "datacenter" = $1'
|
|
USING input_old_name, input_field, input_new_value;
|
|
|
|
-- Done
|
|
|
|
PERFORM api.syslog('modify_datacenter:"'||input_old_name||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'datacenter' THEN
|
|
RETURN QUERY (SELECT * FROM "systems"."datacenters" WHERE "datacenter" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "systems"."datacenters" WHERE "datacenter" = input_old_name);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_datacenter(input_old_name text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_datacenter(input_old_name text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_datacenter(input_old_name text, input_field text, input_new_value text) IS 'modify a datacenter';
|
|
|
|
|
|
--
|
|
-- Name: modify_dhcp_class(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dhcp_class(input_old_class text, input_field text, input_new_value text) RETURNS SETOF dhcp.classes
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to modify dhcp class denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'class|comment' THEN
|
|
RAISE EXCEPTION 'Invalid field specified (%)',input_field;
|
|
END IF;
|
|
|
|
-- Validate class name
|
|
IF input_field !~* 'class' THEN
|
|
input_new_value := api.validate_nospecial(input_new_value);
|
|
END IF;
|
|
|
|
-- Update record
|
|
EXECUTE 'UPDATE "dhcp"."classes" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "class" = $1'
|
|
USING input_old_class, input_field, input_new_value;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dhcp_class:"'||input_old_class||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'class' THEN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."classes" WHERE "class" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dhcp"."classes" WHERE "class" = input_old_class);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dhcp_class(input_old_class text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dhcp_class(input_old_class text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dhcp_class(input_old_class text, input_field text, input_new_value text) IS 'Modify a field of a DHCP setting';
|
|
|
|
|
|
--
|
|
-- Name: modify_dhcp_class_option(text, text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dhcp_class_option(input_old_class text, input_old_option text, input_old_value text, input_field text, input_new_value text) RETURNS SETOF dhcp.class_options
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to modify dhcp class option denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'class|option|value' THEN
|
|
RAISE EXCEPTION 'Invalid field specified (%)',input_field;
|
|
END IF;
|
|
|
|
-- Update record
|
|
EXECUTE 'UPDATE "dhcp"."class_options" SET ' || quote_ident($4) || ' = $5,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "class" = $1 AND "option" = $2 AND "value" = $3'
|
|
USING input_old_class, input_old_option, input_old_value, input_field, input_new_value;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dhcp_class_option:"'||input_old_class||'","'||input_old_option||'","'||input_old_value||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'class' THEN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."class_options"
|
|
WHERE "class" = input_new_value AND "option" = input_old_option AND "value" = input_old_value);
|
|
ELSIF input_field ~* 'option' THEN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."class_options"
|
|
WHERE "class" = input_old_class AND "option" = input_new_value AND "value" = input_old_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dhcp"."class_options"
|
|
WHERE "class" = input_old_class AND "option" = input_old_option AND "value" = input_new_value);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dhcp_class_option(input_old_class text, input_old_option text, input_old_value text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dhcp_class_option(input_old_class text, input_old_option text, input_old_value text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dhcp_class_option(input_old_class text, input_old_option text, input_old_value text, input_field text, input_new_value text) IS 'Modify a field of a DHCP class option';
|
|
|
|
|
|
--
|
|
-- Name: modify_dhcp_global_option(text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dhcp_global_option(input_old_option text, input_old_value text, input_field text, input_new_value text) RETURNS SETOF dhcp.global_options
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to modify dhcp global option denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'option|value' THEN
|
|
RAISE EXCEPTION 'Invalid field specified (%)',input_field;
|
|
END IF;
|
|
|
|
-- Update record
|
|
EXECUTE 'UPDATE "dhcp"."global_options" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "option" = $1 AND "value" = $2'
|
|
USING input_old_option, input_old_value, input_field, input_new_value;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dhcp_global_option:"'||input_old_option||'","'||input_old_value||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'option' THEN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."global_options"
|
|
WHERE "option" = input_new_value AND "value" = input_old_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dhcp"."global_options"
|
|
WHERE "option" = input_old_option AND "value" = input_new_value);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dhcp_global_option(input_old_option text, input_old_value text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dhcp_global_option(input_old_option text, input_old_value text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dhcp_global_option(input_old_option text, input_old_value text, input_field text, input_new_value text) IS 'Modify a field of a DHCP global option';
|
|
|
|
|
|
--
|
|
-- Name: modify_dhcp_range_option(text, text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dhcp_range_option(input_old_range text, input_old_option text, input_old_value text, input_field text, input_new_value text) RETURNS SETOF dhcp.range_options
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to modify dhcp range option denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'name|option|value' THEN
|
|
RAISE EXCEPTION 'Invalid field specified (%)',input_field;
|
|
END IF;
|
|
|
|
-- Check if range is marked for DHCP
|
|
IF input_field ~* 'name' THEN
|
|
IF (SELECT "use" FROM "ip"."ranges" WHERE "name" = input_new_value) !~* 'ROAM' THEN
|
|
RAISE EXCEPTION 'Range % is not marked for DHCP configuration',input_new_value;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Update record
|
|
EXECUTE 'UPDATE "dhcp"."range_options" SET ' || quote_ident($4) || ' = $5,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "name" = $1 AND "option" = $2 AND "value" = $3'
|
|
USING input_old_range, input_old_option, input_old_value, input_field, input_new_value;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dhcp_range_option:"'||input_old_range||'","'||input_old_option||'","'||input_old_value||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'name' THEN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."range_options"
|
|
WHERE "name" = input_new_value AND "option" = input_old_option AND "value" = input_old_value);
|
|
ELSIF input_field ~* 'option' THEN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."range_options"
|
|
WHERE "name" = input_old_range AND "option" = input_new_value AND "value" = input_old_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dhcp"."range_options"
|
|
WHERE "name" = input_old_range AND "option" = input_old_option AND "value" = input_new_value);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dhcp_range_option(input_old_range text, input_old_option text, input_old_value text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dhcp_range_option(input_old_range text, input_old_option text, input_old_value text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dhcp_range_option(input_old_range text, input_old_option text, input_old_value text, input_field text, input_new_value text) IS 'Modify a field of a DHCP range option';
|
|
|
|
|
|
--
|
|
-- Name: modify_dhcp_subnet_option(cidr, text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dhcp_subnet_option(input_old_subnet cidr, input_old_option text, input_old_value text, input_field text, input_new_value text) RETURNS SETOF dhcp.subnet_options
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to modify dhcp subnet option denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'subnet|option|value' THEN
|
|
RAISE EXCEPTION 'Invalid field specified (%)',input_field;
|
|
END IF;
|
|
|
|
-- Update record
|
|
EXECUTE 'UPDATE "dhcp"."subnet_options" SET ' || quote_ident($4) || ' = $5,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "subnet" = $1 AND "option" = $2 AND "value" = $3'
|
|
USING input_old_subnet, input_old_option, input_old_value, input_field, input_new_value;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dhcp_subnet_option:"'||input_old_subnet||'","'||input_old_option||'","'||input_old_value||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'subnet' THEN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."subnet_options"
|
|
WHERE "subnet" = input_new_value AND "option" = input_old_option AND "value" = input_old_value);
|
|
ELSIF input_field ~* 'option' THEN
|
|
RETURN QUERY (SELECT * FROM "dhcp"."subnet_options"
|
|
WHERE "subnet" = input_old_subnet AND "option" = input_new_value AND "value" = input_old_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dhcp"."subnet_options"
|
|
WHERE "subnet" = input_old_subnet AND "option" = input_old_option AND "value" = input_new_value);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dhcp_subnet_option(input_old_subnet cidr, input_old_option text, input_old_value text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dhcp_subnet_option(input_old_subnet cidr, input_old_option text, input_old_value text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dhcp_subnet_option(input_old_subnet cidr, input_old_option text, input_old_value text, input_field text, input_new_value text) IS 'Modify a field of a DHCP subnet option';
|
|
|
|
|
|
--
|
|
-- Name: modify_dns_address(inet, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dns_address(input_old_address inet, input_old_zone text, input_field text, input_new_value text) RETURNS SETOF dns.a
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "write" FROM api.get_system_permissions(api.get_interface_address_system(input_old_address))) IS FALSE THEN
|
|
RAISE EXCEPTION 'Permission denied';
|
|
END IF;
|
|
-- Shared zone
|
|
IF (SELECT "shared" FROM "dns"."zones" WHERE "zone" = input_old_zone) IS FALSE THEN
|
|
RAISE EXCEPTION 'Zone is not shared and you are not admin';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'hostname|zone|address|owner|ttl' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
IF input_field ~* 'ttl' THEN
|
|
-- User can only specify TTL if address is static
|
|
IF (SELECT "config" FROM "systems"."interface_addresses" WHERE "address" = input_old_address) !~* 'static' AND input_new_value::integer != (SELECT "value"::integer/2 AS "ttl" FROM "dhcp"."subnet_options" WHERE "option"='default-lease-time' AND "subnet" >> input_old_address) THEN
|
|
RAISE EXCEPTION 'You can only specify a TTL other than the default if your address is configured statically';
|
|
END IF;
|
|
END IF;
|
|
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
-- Owner
|
|
IF input_field ~* 'owner' THEN
|
|
-- Different owner
|
|
IF (SELECT "owner" FROM "dns"."a" WHERE "address" = input_old_address AND "zone" = input_zone) != input_new_value THEN
|
|
RAISE EXCEPTION 'Only admins can define a different owner (%).',input_new_value;
|
|
END IF;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Lower
|
|
IF input_field ~* 'hostname' THEN
|
|
input_new_value := lower(input_new_value);
|
|
END IF;
|
|
|
|
-- Update record
|
|
|
|
IF input_field ~* 'address' THEN
|
|
EXECUTE 'UPDATE "dns"."a" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "address" = $1 AND "zone" = $2'
|
|
USING input_old_address, input_old_zone, input_field, inet(input_new_value);
|
|
ELSIF input_field ~* 'ttl' THEN
|
|
EXECUTE 'UPDATE "dns"."a" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "address" = $1 AND "zone" = $2'
|
|
USING input_old_address, input_old_zone, input_field, cast(input_new_value as int);
|
|
ELSE
|
|
EXECUTE 'UPDATE "dns"."a" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "address" = $1 AND "zone" = $2'
|
|
USING input_old_address, input_old_zone, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dns_address:"'||input_old_address||'","'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'address' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."a" WHERE "address" = inet(input_new_value) AND "zone" = input_old_zone);
|
|
ELSEIF input_field ~* 'zone' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."a" WHERE "address" = input_old_address AND "zone" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."a" WHERE "address" = input_old_address AND "zone" = input_old_zone);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dns_address(input_old_address inet, input_old_zone text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dns_address(input_old_address inet, input_old_zone text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dns_address(input_old_address inet, input_old_zone text, input_field text, input_new_value text) IS 'Modify an existing DNS address';
|
|
|
|
|
|
--
|
|
-- Name: modify_dns_cname(text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dns_cname(input_old_alias text, input_old_zone text, input_field text, input_new_value text) RETURNS SETOF dns.cname
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
-- Shared zone
|
|
IF (SELECT "shared" FROM "dns"."zones" WHERE "zone" = input_old_zone) IS FALSE THEN
|
|
RAISE EXCEPTION 'Zone is not shared and you are not admin';
|
|
END IF;
|
|
-- System owner
|
|
IF (SELECT "write" FROM api.get_system_permissions(api.get_interface_address_system((SELECT "address" FROM "dns"."cname" WHERE "alias" = input_old_alias AND "zone" = input_old_zone)))) IS FALSE THEN
|
|
RAISE EXCEPTION 'Permission denied';
|
|
END IF;
|
|
-- Another owner
|
|
IF input_field !~* 'owner' THEN
|
|
IF input_new_value != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'You specified another owner when you are not an admin';
|
|
END IF;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'hostname|zone|alias|owner|ttl' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Lower
|
|
IF input_field ~* 'hostname|alias' THEN
|
|
input_new_value := lower(input_new_value);
|
|
END IF;
|
|
|
|
-- Check for in use
|
|
IF input_field ~* 'alias' THEN
|
|
IF (SELECT api.check_dns_hostname(input_new_value, input_zone)) IS TRUE THEN
|
|
RAISE EXCEPTION 'Record with this hostname and zone already exists';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Update record
|
|
IF input_field ~* 'ttl' THEN
|
|
EXECUTE 'UPDATE "dns"."cname" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "alias" = $1 AND "zone" = $2'
|
|
USING input_old_alias, input_old_zone, input_field, cast(input_new_value as int);
|
|
ELSEIF input_field ~* 'hostname' THEN
|
|
EXECUTE 'UPDATE "dns"."cname" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user(), address = (SELECT "address" FROM "dns"."a" WHERE "hostname" = $4 AND "zone" = $2)
|
|
WHERE "alias" = $1 AND "zone" = $2'
|
|
USING input_old_alias, input_old_zone, input_field, input_new_value;
|
|
ELSE
|
|
EXECUTE 'UPDATE "dns"."cname" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "alias" = $1 AND "zone" = $2'
|
|
USING input_old_alias, input_old_zone, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dns_cname:"'||input_old_alias||'","'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'alias' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."cname" WHERE "alias" = input_new_value AND "zone" = input_old_zone);
|
|
ELSEIF input_field ~* 'zone' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."cname" WHERE "alias" = input_old_alias AND "zone" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."cname" WHERE "alias" = input_old_alias AND "zone" = input_old_zone);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dns_cname(input_old_alias text, input_old_zone text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dns_cname(input_old_alias text, input_old_zone text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dns_cname(input_old_alias text, input_old_zone text, input_field text, input_new_value text) IS 'Modify an existing DNS CNAME record';
|
|
|
|
|
|
--
|
|
-- Name: modify_dns_key(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dns_key(input_old_keyname text, input_field text, input_new_value text) RETURNS SETOF dns.keys
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."keys" WHERE "keyname" = input_old_keyname) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to edit key % denied. You are not owner',input_old_keyname;
|
|
END IF;
|
|
|
|
IF input_field ~* 'owner' AND input_new_value != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only administrators can define a different owner (%).',input_new_value;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'keyname|key|comment|owner|enctype' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Validate input
|
|
IF input_field ~* 'keyname' THEN
|
|
input_new_value := api.validate_nospecial(input_new_value);
|
|
END IF;
|
|
|
|
-- Update record
|
|
EXECUTE 'UPDATE "dns"."keys" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "keyname" = $1'
|
|
USING input_old_keyname, input_field, input_new_value;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dns_key:"'||input_old_keyname||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'keyname' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."keys" WHERE "keyname" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."keys" WHERE "keyname" = input_old_keyname);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dns_key(input_old_keyname text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dns_key(input_old_keyname text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dns_key(input_old_keyname text, input_field text, input_new_value text) IS 'Modify an existing DNS key';
|
|
|
|
|
|
--
|
|
-- Name: modify_dns_mailserver(text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dns_mailserver(input_old_hostname text, input_old_zone text, input_field text, input_new_value text) RETURNS SETOF dns.mx
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
-- Zone owner
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_old_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied';
|
|
END IF;
|
|
-- You own the system
|
|
IF (SELECT "write" FROM api.get_system_permissions(api.get_interface_address_system(input_old_address))) IS FALSE THEN
|
|
RAISE EXCEPTION 'Permission denied';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'hostname|zone|preference|owner|ttl' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Lower
|
|
IF input_field ~* 'hostname' THEN
|
|
input_new_value := lower(input_new_value);
|
|
END IF;
|
|
|
|
-- Update record
|
|
|
|
IF input_field ~* 'preference|ttl' THEN
|
|
EXECUTE 'UPDATE "dns"."mx" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "hostname" = $1 AND "zone" = $2'
|
|
USING input_old_hostname, input_old_zone, input_field, cast(input_new_value as int);
|
|
ELSEIF input_field ~* 'hostname' THEN
|
|
EXECUTE 'UPDATE "dns"."mx" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user(), address = (SELECT "address" FROM "dns"."a" WHERE "hostname" = $4 AND "zone" = $2)
|
|
WHERE "hostname" = $1 AND "zone" = $2'
|
|
USING input_old_hostname, input_old_zone, input_field, input_new_value;
|
|
ELSE
|
|
EXECUTE 'UPDATE "dns"."mx" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "hostname" = $1 AND "zone" = $2'
|
|
USING input_old_hostname, input_old_zone, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dns_mailserver:"'||input_old_hostname||'","'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'hostname' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."mx" WHERE "hostname" = input_new_value AND "zone" = input_old_zone);
|
|
ELSEIF input_field ~* 'zone' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."mx" WHERE "hostname" = input_old_hostname AND "zone" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."mx" WHERE "hostname" = input_old_hostname AND "zone" = input_old_zone);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dns_mailserver(input_old_hostname text, input_old_zone text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dns_mailserver(input_old_hostname text, input_old_zone text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dns_mailserver(input_old_hostname text, input_old_zone text, input_field text, input_new_value text) IS 'Modify an existing DNS MX record';
|
|
|
|
|
|
--
|
|
-- Name: modify_dns_ns(text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dns_ns(input_old_zone text, input_old_nameserver text, input_field text, input_new_value text) RETURNS SETOF dns.ns
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
-- You own the zone
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_old_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to edit nameserver (%.%) denied. You are not owner',input_old_nameserver,input_old_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'nameserver|zone|ttl|address' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Lower
|
|
IF input_field ~* 'nameserver' THEN
|
|
input_new_value := lower(input_new_value);
|
|
END IF;
|
|
|
|
-- Update record
|
|
IF input_field ~* 'ttl' THEN
|
|
EXECUTE 'UPDATE "dns"."ns" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "zone" = $1 AND "nameserver" = $2'
|
|
USING input_old_zone, input_old_nameserver, input_field, cast(input_new_value as int);
|
|
|
|
-- Update TTLs of other zone records since they all need to be the same
|
|
UPDATE "dns"."ns" SET "ttl" = cast(input_new_value as int) WHERE "zone" = input_old_zone;
|
|
|
|
ELSEIF input_field ~* 'address' THEN
|
|
EXECUTE 'UPDATE "dns"."ns" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "zone" = $1 AND "nameserver" = $2'
|
|
USING input_old_zone, input_old_nameserver, input_field, cast(input_new_value as inet);
|
|
ELSE
|
|
EXECUTE 'UPDATE "dns"."ns" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "zone" = $1 AND "nameserver" = $2'
|
|
USING input_old_zone, input_old_nameserver, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dns_ns:"'||input_old_zone||'","'||input_old_nameserver||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'input_old_zone' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."ns" WHERE "zone" = input_new_value AND "nameserver" = input_old_nameserver);
|
|
ELSEIF input_field ~* 'nameserver' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."ns" WHERE "zone" = input_old_zone AND "nameserver" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."ns" WHERE "zone" = input_old_zone AND "nameserver" = input_old_nameserver);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dns_ns(input_old_zone text, input_old_nameserver text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dns_ns(input_old_zone text, input_old_nameserver text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dns_ns(input_old_zone text, input_old_nameserver text, input_field text, input_new_value text) IS 'Modify an existing DNS NS record';
|
|
|
|
|
|
--
|
|
-- Name: modify_dns_soa(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dns_soa(input_old_zone text, input_field text, input_new_value text) RETURNS SETOF dns.soa
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_old_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to edit SOA % denied. You are not owner',input_old_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'zone|ttl|nameserver|contact|serial|refresh|retry|expire|minimum' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Validate
|
|
IF input_field ~* 'contact' THEN
|
|
IF api.validate_soa_contact(input_new_value) IS FALSE THEN
|
|
RAISE EXCEPTION 'Invalid SOA contact given (%)',input_contact;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Update record
|
|
IF input_field ~* 'ttl|refresh|retry|expire|minimum' THEN
|
|
EXECUTE 'UPDATE "dns"."soa" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "zone" = $1'
|
|
USING input_old_zone, input_field, cast(input_new_value as integer);
|
|
ELSE
|
|
EXECUTE 'UPDATE "dns"."soa" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "zone" = $1'
|
|
USING input_old_zone, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dns_soa:"'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'zone' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."soa" WHERE "zone" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."soa" WHERE "zone" = input_old_zone);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dns_soa(input_old_zone text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dns_soa(input_old_zone text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dns_soa(input_old_zone text, input_field text, input_new_value text) IS 'Modify an existing DNS SOA record';
|
|
|
|
|
|
--
|
|
-- Name: modify_dns_srv(text, text, integer, integer, integer, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dns_srv(input_old_alias text, input_old_zone text, input_old_priority integer, input_old_weight integer, input_old_port integer, input_field text, input_new_value text) RETURNS SETOF dns.srv
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
-- You own the system
|
|
IF (SELECT "write" FROM api.get_system_permissions(api.get_interface_address_system((SELECT "address" FROM "dns"."srv" WHERE "alias" = input_old_alias AND "zone" = input_old_zone AND "priority" = input_old_priority AND "weight" = input_old_weight AND "port" = input_old_port)))) IS FALSE THEN
|
|
RAISE EXCEPTION 'Permission denied';
|
|
END IF;
|
|
-- You own the zone
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_old_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to edit denied: You are not zone owner';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'hostname|zone|alias|owner|ttl|priority|weight|port' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Lower
|
|
IF input_field ~* 'hostname|alias' THEN
|
|
input_new_value := lower(input_new_value);
|
|
END IF;
|
|
|
|
-- Update record
|
|
IF input_field ~* 'ttl|priority|weight|port' THEN
|
|
EXECUTE 'UPDATE "dns"."srv" SET ' || quote_ident($6) || ' = $7,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "alias" = $1 AND "zone" = $2 AND "priority" = $3 AND "weight" = $4 AND "port" = $5'
|
|
USING input_old_alias, input_old_zone, input_old_priority, input_old_weight, input_old_port, input_field, cast(input_new_value as int);
|
|
ELSEIF input_field ~* 'hostname' THEN
|
|
RAISE EXCEPTION 'test';
|
|
EXECUTE 'UPDATE "dns"."srv" SET ' || quote_ident($6) || ' = $7,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user(), address = (SELECT "address" FROM "dns"."a" WHERE "hostname" = $7 AND "zone" = $2)
|
|
WHERE "alias" = $1 AND "zone" = $2 AND "priority" = $3 AND "weight" = $4 AND "port" = $5'
|
|
USING input_old_alias, input_old_zone, input_old_priority, input_old_weight, input_old_port, input_field, input_new_value;
|
|
ELSE
|
|
EXECUTE 'UPDATE "dns"."srv" SET ' || quote_ident($6) || ' = $7,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "alias" = $1 AND "zone" = $2 AND "priority" = $3 AND "weight" = $4 AND "port" = $5'
|
|
USING input_old_alias, input_old_zone, input_old_priority, input_old_weight, input_old_port, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dns_srv:"'||input_old_alias||'","'||input_old_zone||'","'||input_old_priority||'","'||input_old_weight||'","'||input_old_port||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'alias' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."srv"
|
|
WHERE "alias" = input_new_value AND "zone" = input_old_zone AND "priority" = input_old_priority AND "weight" = input_old_weight AND "port" = input_old_port);
|
|
ELSEIF input_field ~* 'zone' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."srv"
|
|
WHERE "alias" = input_old_alias AND "zone" = input_new_value AND "priority" = input_old_priority AND "weight" = input_old_weight AND "port" = input_old_port);
|
|
ELSEIF input_field ~* 'priority' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."srv"
|
|
WHERE "alias" = input_old_alias AND "zone" = input_old_zone AND "priority" = input_new_value::integer AND "weight" = input_old_weight AND "port" = input_old_port);
|
|
ELSEIF input_field ~* 'weight' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."srv"
|
|
WHERE "alias" = input_old_alias AND "zone" = input_old_zone AND "priority" = input_old_priority AND "weight" = input_new_value::integer AND "port" = input_old_port);
|
|
ELSEIF input_field ~* 'port' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."srv"
|
|
WHERE "alias" = input_old_alias AND "zone" = input_old_zone AND "priority" = input_old_priority AND "weight" = input_old_weight AND "port" = input_new_value::integer);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."srv"
|
|
WHERE "alias" = input_old_alias AND "zone" = input_old_zone AND "priority" = input_old_priority AND "weight" = input_old_weight AND "port" = input_old_port);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dns_srv(input_old_alias text, input_old_zone text, input_old_priority integer, input_old_weight integer, input_old_port integer, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dns_srv(input_old_alias text, input_old_zone text, input_old_priority integer, input_old_weight integer, input_old_port integer, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dns_srv(input_old_alias text, input_old_zone text, input_old_priority integer, input_old_weight integer, input_old_port integer, input_field text, input_new_value text) IS 'Modify an existing DNS SRV record';
|
|
|
|
|
|
--
|
|
-- Name: modify_dns_txt(text, text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dns_txt(input_old_hostname text, input_old_zone text, input_old_text text, input_field text, input_new_value text) RETURNS SETOF dns.txt
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
-- Record owner
|
|
IF (SELECT "owner" FROM "dns"."txt" WHERE "hostname" = input_old_hostname AND "zone" = input_old_zone AND "text" = input_old_text) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'You are not the record owner';
|
|
END IF;
|
|
-- Zone owner
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_old_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'You are not the owner of the zone or an admin';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'hostname|zone|text|owner|ttl' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Lower
|
|
IF input_new_value ~* 'hostname' THEN
|
|
input_new_value := lower(input_new_value);
|
|
END IF;
|
|
|
|
-- Update record
|
|
IF input_field ~* 'ttl' THEN
|
|
EXECUTE 'UPDATE "dns"."txt" SET ' || quote_ident($4) || ' = $5,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "hostname" = $1 AND "zone" = $2 AND "text" = $3'
|
|
USING input_old_hostname, input_old_zone, input_old_text, input_field, cast(input_new_value as int);
|
|
ELSE
|
|
EXECUTE 'UPDATE "dns"."txt" SET ' || quote_ident($4) || ' = $5,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "hostname" = $1 AND "zone" = $2 AND "text" = $3'
|
|
USING input_old_hostname, input_old_zone, input_old_text, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dns_txt:"'||input_old_hostname||'","'||input_old_zone||'","'||input_old_text||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'hostname' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."txt" WHERE "hostname" = input_new_value AND "zone" = input_old_zone AND "text" = input_old_text);
|
|
ELSEIF input_field ~* 'zone' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."txt" WHERE "hostname" = input_old_hostname AND "zone" = input_new_value AND "text" = input_old_text);
|
|
ELSEIF input_field ~* 'text' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."txt" WHERE "hostname" = input_old_hostname AND "zone" = input_old_zone AND "text" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."txt" WHERE "hostname" = input_old_hostname AND "zone" = input_old_zone AND "text" = input_old_text);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dns_txt(input_old_hostname text, input_old_zone text, input_old_text text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dns_txt(input_old_hostname text, input_old_zone text, input_old_text text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dns_txt(input_old_hostname text, input_old_zone text, input_old_text text, input_field text, input_new_value text) IS 'Modify an existing DNS TXT record';
|
|
|
|
|
|
--
|
|
-- Name: modify_dns_zone(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dns_zone(input_old_zone text, input_field text, input_new_value text) RETURNS SETOF dns.zones
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_old_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to edit zone % denied. You are not owner',input_old_zone;
|
|
END IF;
|
|
|
|
IF input_field ~* 'owner' AND input_new_value != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only administrators can define a different owner (%).',input_new_value;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'zone|forward|keyname|owner|comment|shared|ddns' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Update record
|
|
IF input_field ~* 'forward|shared|ddns' THEN
|
|
EXECUTE 'UPDATE "dns"."zones" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "zone" = $1'
|
|
USING input_old_zone, input_field, bool(input_new_value);
|
|
ELSE
|
|
EXECUTE 'UPDATE "dns"."zones" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "zone" = $1'
|
|
USING input_old_zone, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dns_zone:"'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'zone' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."zones" WHERE "zone" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."zones" WHERE "zone" = input_old_zone);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dns_zone(input_old_zone text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dns_zone(input_old_zone text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dns_zone(input_old_zone text, input_field text, input_new_value text) IS 'Modify an existing DNS zone';
|
|
|
|
|
|
--
|
|
-- Name: modify_dns_zone_a(text, inet, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dns_zone_a(input_old_zone text, input_old_address inet, input_field text, input_new_value text) RETURNS SETOF dns.zone_a
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_old_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to edit zone % denied. You are not owner',input_old_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'zone|address|ttl' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
IF input_field ~* 'address' THEN
|
|
IF input_new_value::inet << api.get_site_configuration('DYNAMIC_SUBNET')::cidr THEN
|
|
RAISE EXCEPTION 'Zone A cannot be dynamic';
|
|
END IF;
|
|
END IF;
|
|
|
|
|
|
-- Update record
|
|
IF input_field ~* 'address' THEN
|
|
EXECUTE 'UPDATE "dns"."zone_a" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "zone" = $1 AND "address" = $2'
|
|
USING input_old_zone, input_old_address, input_field, inet(input_new_value);
|
|
ELSIF input_field ~* 'ttl' THEN
|
|
EXECUTE 'UPDATE "dns"."zone_a" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "zone" = $1 AND "address" = $2'
|
|
USING input_old_zone, input_old_address, input_field, cast(input_new_value as int);
|
|
ELSE
|
|
EXECUTE 'UPDATE "dns"."zone_a" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "zone" = $1 AND "address" = $2'
|
|
USING input_old_zone, input_old_address, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_dns_zone_a:"'||input_old_zone||'","'||input_old_address||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'zone' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_a" WHERE "zone" = input_new_value AND "address" = input_old_address);
|
|
ELSEIF input_field ~* 'address' THEN
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_a" WHERE "zone" = input_old_zone AND "address" = inet(input_new_value));
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_a" WHERE "zone" = input_old_zone AND "address" = input_old_address);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dns_zone_a(input_old_zone text, input_old_address inet, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dns_zone_a(input_old_zone text, input_old_address inet, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dns_zone_a(input_old_zone text, input_old_address inet, input_field text, input_new_value text) IS 'Modify an existing DNS address';
|
|
|
|
|
|
--
|
|
-- Name: modify_dns_zone_txt(text, text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_dns_zone_txt(input_old_hostname text, input_old_zone text, input_old_text text, input_field text, input_new_value text) RETURNS SETOF dns.zone_txt
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_old_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to edit alias (%.%) denied. You are not owner',input_old_hostname,input_old_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'hostname|zone|text|ttl' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Lower
|
|
IF input_zone ~* 'hostname' THEN
|
|
input_new_value := lower(input_new_value);
|
|
END IF;
|
|
|
|
-- Update record
|
|
IF input_field ~* 'ttl' THEN
|
|
EXECUTE 'UPDATE "dns"."zone_txt" SET ' || quote_ident($4) || ' = $5,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "hostname" = $1 AND "zone" = $2 AND "text" = $3'
|
|
USING input_old_hostname, input_old_zone, input_old_text, input_field, cast(input_new_value as int);
|
|
|
|
-- Update other zone-only records if needed
|
|
IF input_old_hostname IS NULL THEN
|
|
UPDATE "dns"."zone_txt" SET "ttl" = cast(input_new_value as int) WHERE "hostname" IS NULL AND "zone" = input_old_zone;
|
|
END IF;
|
|
ELSE
|
|
EXECUTE 'UPDATE "dns"."zone_txt" SET ' || quote_ident($4) || ' = $5,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "hostname" = $1 AND "zone" = $2 AND "text" = $3'
|
|
USING input_old_hostname, input_old_zone, input_old_text, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
IF input_field ~* 'hostname' THEN
|
|
IF input_new_value IS NULL THEN
|
|
PERFORM api.syslog('modify_dns_zone_txt:"'||input_old_hostname||'","'||input_old_zone||'","'||input_field||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" WHERE "hostname" IS NULL AND "zone" = input_old_zone AND "text" = input_old_text);
|
|
ELSE
|
|
PERFORM api.syslog('modify_dns_zone_txt:"'||input_old_hostname||'","'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" WHERE "hostname" = input_new_value AND "zone" = input_old_zone AND "text" = input_old_text);
|
|
END IF;
|
|
ELSEIF input_field ~* 'zone' THEN
|
|
IF input_old_hostname IS NULL THEN
|
|
PERFORM api.syslog('modify_dns_zone_txt:"'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" WHERE "hostname" IS NULL AND "zone" = input_new_value AND "text" = input_old_text);
|
|
ELSE
|
|
PERFORM api.syslog('modify_dns_zone_txt:"'||input_old_hostname||'","'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" WHERE "hostname" = input_old_hostname AND "zone" = input_new_value AND "text" = input_old_text);
|
|
END IF;
|
|
ELSEIF input_field ~* 'text' THEN
|
|
IF input_old_hostname IS NULL THEN
|
|
PERFORM api.syslog('modify_dns_zone_txt:"'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" WHERE "hostname" IS NULL AND "zone" = input_old_zone AND "text" = input_new_value);
|
|
ELSE
|
|
PERFORM api.syslog('modify_dns_zone_txt:"'||input_old_hostname||'","'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" WHERE "hostname" = input_old_hostname AND "zone" = input_old_zone AND "text" = input_new_value);
|
|
END IF;
|
|
ELSE
|
|
IF input_old_hostname IS NULL THEN
|
|
PERFORM api.syslog('modify_dns_zone_txt:"'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" WHERE "hostname" IS NULL AND "zone" = input_old_zone AND "text" = input_old_text);
|
|
ELSE
|
|
PERFORM api.syslog('modify_dns_zone_txt:"'||input_old_hostname||'","'||input_old_zone||'","'||input_field||'","'||input_new_value||'"');
|
|
RETURN QUERY (SELECT * FROM "dns"."zone_txt" WHERE "hostname" = input_old_hostname AND "zone" = input_old_zone AND "text" = input_old_text);
|
|
END IF;
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_dns_zone_txt(input_old_hostname text, input_old_zone text, input_old_text text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_dns_zone_txt(input_old_hostname text, input_old_zone text, input_old_text text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_dns_zone_txt(input_old_hostname text, input_old_zone text, input_old_text text, input_field text, input_new_value text) IS 'Modify an existing DNS zone_txt record';
|
|
|
|
|
|
--
|
|
-- Name: modify_domain_state(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_domain_state(input_host text, input_domain text, input_action text) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
HostData RECORD;
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."system" WHERE "system_name" = input_domain) THEN
|
|
RAISE EXCEPTION 'Permission denied: Not VM owner';
|
|
END IF;
|
|
END IF;
|
|
|
|
SELECT * INTO HostData FROM "libvirt"."hosts" WHERE "system_name" = input_host;
|
|
|
|
RETURN api.control_libvirt_domain(HostData.uri,HostData.password,input_domain,input_action);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_domain_state(input_host text, input_domain text, input_action text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: modify_group(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_group(input_old_group text, input_field text, input_new_value text) RETURNS SETOF management.groups
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can modify groups';
|
|
END IF;
|
|
|
|
IF input_field !~* 'group|privilege|renew_interval|comment' THEN
|
|
RAISE EXCEPTION 'Invalid field specified (%)',input_field;
|
|
END IF;
|
|
|
|
IF input_field ~* 'renew_interval' THEN
|
|
EXECUTE 'UPDATE "management"."groups" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "group" = $1'
|
|
USING input_old_group, input_field, input_new_value::interval;
|
|
ELSE
|
|
EXECUTE 'UPDATE "management"."groups" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "group" = $1'
|
|
USING input_old_group, input_field, input_new_value;
|
|
END IF;
|
|
|
|
PERFORM api.syslog('modify_group:"'||input_old_group||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'group' THEN
|
|
RETURN QUERY (SELECT * FROM "management"."groups" WHERE "group" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "management"."groups" WHERE "group" = input_old_group);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_group(input_old_group text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_group(input_old_group text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_group(input_old_group text, input_field text, input_new_value text) IS 'Alter a group';
|
|
|
|
|
|
--
|
|
-- Name: modify_group_member(text, text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_group_member(input_old_group text, input_old_user text, input_field text, input_new_value text) RETURNS SETOF management.group_members
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF api.get_current_user() NOT IN (SELECT * FROM api.get_group_admins(input_old_group)) THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can modify group members';
|
|
END IF;
|
|
END IF;
|
|
|
|
IF input_field !~* 'group|user|privilege' THEN
|
|
RAISE EXCEPTION 'Invalid field specified (%)',input_field;
|
|
END IF;
|
|
|
|
EXECUTE 'UPDATE "management"."group_members" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "group" = $1 AND "user" = $2'
|
|
USING input_old_group, input_old_user, input_field, input_new_value;
|
|
|
|
PERFORM api.syslog('modify_group_member:"'||input_old_group||'","'||input_old_user||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'group' THEN
|
|
RETURN QUERY (SELECT * FROM "management"."group_members" WHERE "group" = input_new_value AND "user" = input_old_user);
|
|
ELSEIF input_field ~* 'user' THEN
|
|
RETURN QUERY (SELECT * FROM "management"."group_members" WHERE "group" = input_old_group AND "user" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "management"."group_members" WHERE "group" = input_old_group AND "user" = input_old_user);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_group_member(input_old_group text, input_old_user text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_group_member(input_old_group text, input_old_user text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_group_member(input_old_group text, input_old_user text, input_field text, input_new_value text) IS 'Modify a group member';
|
|
|
|
|
|
--
|
|
-- Name: modify_group_settings(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_group_settings(input_old_group text, input_field text, input_new_value text) RETURNS SETOF management.group_settings
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can create group provider settings';
|
|
END IF;
|
|
|
|
IF input_field !~* 'group|provider|id|hostname|username|password|privilege' THEN
|
|
RAISE EXCEPTION 'Invalid field specified (%)',input_field;
|
|
END IF;
|
|
|
|
EXECUTE 'UPDATE "management"."group_settings" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "group" = $1'
|
|
USING input_old_group, input_field, input_new_value;
|
|
|
|
PERFORM api.syslog('modify_group_settings:"'||input_old_group||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'group' THEN
|
|
RETURN QUERY (SELECT * FROM "management"."group_settings" WHERE "group" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "management"."group_settings" WHERE "group" = input_old_group);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_group_settings(input_old_group text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_group_settings(input_old_group text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_group_settings(input_old_group text, input_field text, input_new_value text) IS 'Modify group authentication and provider settings';
|
|
|
|
|
|
--
|
|
-- Name: modify_interface(macaddr, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_interface(input_old_mac macaddr, input_field text, input_new_value text) RETURNS SETOF systems.interfaces
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (SELECT "write" FROM api.get_system_permissions((SELECT "system_name" FROM "systems"."interfaces" WHERE "mac" = input_old_mac))) IS FALSE THEN
|
|
RAISE EXCEPTION 'Permission denied';
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'mac|comment|system_name|name' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Update record
|
|
|
|
IF input_field ~* 'mac' THEN
|
|
EXECUTE 'UPDATE "systems"."interfaces" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "mac" = $1'
|
|
H
|
|
USING input_old_mac, input_field, macaddr(input_new_value);
|
|
ELSE
|
|
EXECUTE 'UPDATE "systems"."interfaces" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "mac" = $1'
|
|
USING input_old_mac, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_interface:"'||input_old_mac||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'mac' THEN
|
|
RETURN QUERY (SELECT * FROM "systems"."interfaces" WHERE "mac" = macaddr(input_new_value));
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "systems"."interfaces" WHERE "mac" = input_old_mac);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_interface(input_old_mac macaddr, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_interface(input_old_mac macaddr, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_interface(input_old_mac macaddr, input_field text, input_new_value text) IS 'Modify an existing system interface';
|
|
|
|
|
|
--
|
|
-- Name: modify_interface_address(inet, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_interface_address(input_old_address inet, input_field text, input_new_value text) RETURNS SETOF systems.interface_addresses
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
DECLARE
|
|
isprim BOOLEAN;
|
|
primcount INTEGER;
|
|
BEGIN
|
|
|
|
-- Check privilegesinput_old_name
|
|
IF (SELECT "write" FROM api.get_system_permissions(api.get_interface_address_system(input_old_address))) IS FALSE THEN
|
|
RAISE EXCEPTION 'Permission denied';
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'comment|address|config|isprimary|mac|class|renew_date' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Check dynamic
|
|
IF api.ip_is_dynamic(input_old_address) IS TRUE THEN
|
|
IF input_field ~* 'config|class' THEN
|
|
RAISE EXCEPTION 'Cannot modify the configuration or class of a dynamic address';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check for primary
|
|
SELECT "isprimary" INTO isprim FROM "systems"."interface_addresses" WHERE "address" = input_old_address;
|
|
|
|
IF input_field ~* 'mac' THEN
|
|
SELECT COUNT(*) INTO primcount FROM "systems"."interface_addresses" WHERE "mac" = input_new_value::macaddr AND "isprimary" IS TRUE;
|
|
IF primcount = 0 THEN
|
|
isprim := TRUE;
|
|
ELSE
|
|
isprim := FALSE;
|
|
END IF;
|
|
END IF;
|
|
|
|
IF input_field ~* 'address' THEN
|
|
IF (SELECT "use" FROM "api"."get_ip_ranges"() WHERE "name" = (SELECT "api"."get_address_range"(input_new_value::inet))) ~* 'ROAM' THEN
|
|
RAISE EXCEPTION 'Specified new address (%) is contained within a Dynamic range',input_new_value;
|
|
END IF;
|
|
END IF;
|
|
|
|
IF input_field ~* 'renew_date' AND input_new_value IS NULL THEN
|
|
input_new_value := api.get_default_renew_date(api.get_interface_address_system(input_old_address));
|
|
END IF;
|
|
|
|
-- Update record
|
|
|
|
IF input_field ~* 'mac' THEN
|
|
EXECUTE 'UPDATE "systems"."interface_addresses" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user(), isprimary = $4
|
|
WHERE "address" = $1'
|
|
USING input_old_address, input_field, macaddr(input_new_value),isprim;
|
|
ELSIF input_field ~* 'address' THEN
|
|
EXECUTE 'UPDATE "systems"."interface_addresses" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "address" = $1'
|
|
USING input_old_address, input_field, inet(input_new_value);
|
|
ELSIF input_field ~* 'isprimary' THEN
|
|
EXECUTE 'UPDATE "systems"."interface_addresses" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "address" = $1'
|
|
USING input_old_address, input_field, bool(input_new_value);
|
|
ELSIF input_field ~* 'renew_date' THEN
|
|
EXECUTE 'UPDATE "systems"."interface_addresses" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "address" = $1'
|
|
USING input_old_address, input_field, input_new_value::date;
|
|
ELSEIF input_field ~* 'config' THEN
|
|
EXECUTE 'UPDATE "systems"."interface_addresses" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "address" = $1'
|
|
USING input_old_address, input_field, input_new_value;
|
|
-- Need to force DNS records to be created
|
|
IF input_new_value ~* 'static' THEN
|
|
UPDATE "dns"."a" SET "address" = input_old_address WHERE "address" = input_old_address;
|
|
END IF;
|
|
ELSE
|
|
EXECUTE 'UPDATE "systems"."interface_addresses" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "address" = $1'
|
|
USING input_old_address, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_interface_address:"'||input_old_address||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'address' THEN
|
|
RETURN QUERY (SELECT * FROM "systems"."interface_addresses" WHERE "address" = inet(input_new_value));
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "systems"."interface_addresses" WHERE "address" = input_old_address);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_interface_address(input_old_address inet, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_interface_address(input_old_address inet, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_interface_address(input_old_address inet, input_field text, input_new_value text) IS 'Modify an existing interface address';
|
|
|
|
|
|
--
|
|
-- Name: modify_ip_range(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_ip_range(input_old_name text, input_field text, input_new_value text) RETURNS SETOF ip.ranges
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to modify range (%). Not admin.',input_old_name;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'first_ip|last_ip|comment|use|name|subnet|class|zone' THEN
|
|
RAISE EXCEPTION 'Invalid field specified (%)',input_field;
|
|
END IF;
|
|
|
|
-- Update record
|
|
IF input_field ~* 'first_ip|last_ip' THEN
|
|
EXECUTE 'UPDATE "ip"."ranges" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "name" = $1'
|
|
USING input_old_name, input_field, inet(input_new_value);
|
|
ELSIF input_field ~* 'subnet' THEN
|
|
EXECUTE 'UPDATE "ip"."ranges" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "name" = $1'
|
|
USING input_old_name, input_field, cidr(input_new_value);
|
|
ELSE
|
|
EXECUTE 'UPDATE "ip"."ranges" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "name" = $1'
|
|
USING input_old_name, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_ip_range:"'||input_old_name||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'name' THEN
|
|
RETURN QUERY (SELECT * FROM "ip"."ranges" WHERE "name" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "ip"."ranges" WHERE "name" = input_old_name);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_ip_range(input_old_name text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_ip_range(input_old_name text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_ip_range(input_old_name text, input_field text, input_new_value text) IS 'Modify an IP range';
|
|
|
|
|
|
--
|
|
-- Name: modify_ip_subnet(cidr, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_ip_subnet(input_old_subnet cidr, input_field text, input_new_value text) RETURNS SETOF ip.subnets
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "ip"."subnets" WHERE "subnet" = input_old_subnet) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to edit subnet % denied. You are not owner',input_old_subnet;
|
|
END IF;
|
|
|
|
IF input_field ~* 'owner' AND input_new_value != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only administrators can define a different owner (%).',input_new_value;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'subnet|comment|autogen|name|owner|zone|dhcp_enable|datacenter|vlan' THEN
|
|
RAISE EXCEPTION 'Invalid field specified (%)',input_field;
|
|
END IF;
|
|
|
|
-- Update record
|
|
IF input_field ~* 'dhcp_enable|autogen' THEN
|
|
EXECUTE 'UPDATE "ip"."subnets" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "subnet" = $1'
|
|
USING input_old_subnet, input_field, bool(input_new_value);
|
|
ELSIF input_field ~* 'subnet' THEN
|
|
EXECUTE 'UPDATE "ip"."subnets" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "subnet" = $1'
|
|
USING input_old_subnet, input_field, cidr(input_new_value);
|
|
ELSIF input_field ~* 'vlan' THEN
|
|
EXECUTE 'UPDATE "ip"."subnets" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "subnet" = $1'
|
|
USING input_old_subnet, input_field, input_new_value::integer;
|
|
ELSE
|
|
EXECUTE 'UPDATE "ip"."subnets" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "subnet" = $1'
|
|
USING input_old_subnet, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_ip_subnet:"'||input_old_subnet||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'subnet' THEN
|
|
RETURN QUERY (SELECT * FROM "ip"."subnets" WHERE "subnet" = cidr(input_new_value));
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "ip"."subnets" WHERE "subnet" = input_old_subnet);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_ip_subnet(input_old_subnet cidr, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_ip_subnet(input_old_subnet cidr, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_ip_subnet(input_old_subnet cidr, input_field text, input_new_value text) IS 'Modify an IP subnet';
|
|
|
|
|
|
--
|
|
-- Name: modify_network_snmp(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_network_snmp(input_old_system text, input_field text, input_new_value text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."systems" WHERE "system_name" = input_old_system) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied: you are not owner';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check fields
|
|
IF input_field !~* 'ro_community|rw_community|system_name|address' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
IF input_field ~* 'address' THEN
|
|
IF(api.get_interface_address_system(input_new_value::inet) != input_old_system) THEN
|
|
RAISE EXCEPTION 'Address % is not a part of the system %',input_new_value,input_old_system;
|
|
END IF;
|
|
|
|
IF input_new_value::inet << api.get_site_configuration('DYNAMIC_SUBNET')::cidr THEN
|
|
RAISE EXCEPTION 'System address cannot be dynamic';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Mod it
|
|
IF input_field ~* 'address' THEN
|
|
EXECUTE 'UPDATE "network"."snmp" SET ' || quote_ident($2) || ' = $3
|
|
WHERE "system_name" = $1'
|
|
USING input_old_system, input_field, input_new_value::inet;
|
|
ELSE
|
|
EXECUTE 'UPDATE "network"."snmp" SET ' || quote_ident($2) || ' = $3
|
|
WHERE "system_name" = $1'
|
|
USING input_old_system, input_field, input_new_value;
|
|
END IF;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_network_snmp:"'||input_old_system||'","'||input_field||'","'||input_new_value||'"');
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_network_snmp(input_old_system text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_network_snmp(input_old_system text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_network_snmp(input_old_system text, input_field text, input_new_value text) IS 'Modify credentials for a system';
|
|
|
|
|
|
--
|
|
-- Name: modify_network_switchport_admin_state(inet, text, text, boolean); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_network_switchport_admin_state(input_address inet, input_port text, input_rw_community text, input_state boolean) RETURNS void
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
no warnings('redefine');
|
|
|
|
# Local variables and things
|
|
our $host = shift;
|
|
our $portName = shift;
|
|
our $community = shift;
|
|
our $state = shift;
|
|
|
|
# OID List
|
|
our $ifNameList_OID = '.1.3.6.1.2.1.31.1.1.1.1';
|
|
#our $ifAliasList_OID = '1.3.6.1.2.1.31.1.1.1.18';
|
|
|
|
# Stored data
|
|
our %ifIndexData;
|
|
our $ifAdminStatusOid = '.1.3.6.1.2.1.2.2.1.7';
|
|
|
|
# Establish session
|
|
our ($session,$error) = Net::SNMP->session (
|
|
-hostname => $host,
|
|
-community => $community,
|
|
);
|
|
|
|
# Get the index of all interfaces
|
|
my $ifNameList = $session->get_table(-baseoid => $ifNameList_OID);
|
|
while (my($ifIndex,$ifName) = each(%$ifNameList)) {
|
|
$ifIndex =~ s/$ifNameList_OID\.//;
|
|
if($ifIndex =~ m/\d{5}/) {
|
|
# $ifIndexData{$ifIndex} = $ifName;
|
|
if($ifName eq $portName) {
|
|
$ifAdminStatusOid .= ".$ifIndex";
|
|
}
|
|
}
|
|
# warn("$ifIndex - $ifName\n");
|
|
}
|
|
|
|
# Finalize the data
|
|
my $snmpState = 1;
|
|
if($state eq 'f') {
|
|
$snmpState = 2;
|
|
}
|
|
|
|
# Set the new description
|
|
my $result = $session->set_request(
|
|
-varbindlist => [ $ifAdminStatusOid, INTEGER, $snmpState ],
|
|
);
|
|
#die($state);
|
|
#die($ifAdminStatusOid);
|
|
|
|
if(!$result) {
|
|
die("Error: ",$session->error());
|
|
}
|
|
|
|
# Close initial session
|
|
$session->close();
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_network_switchport_admin_state(input_address inet, input_port text, input_rw_community text, input_state boolean) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_network_switchport_admin_state(input_address inet, input_port text, input_rw_community text, input_state boolean); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_network_switchport_admin_state(input_address inet, input_port text, input_rw_community text, input_state boolean) IS 'Modify the admin state of a network switchport';
|
|
|
|
|
|
--
|
|
-- Name: modify_network_switchport_description(inet, text, text, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_network_switchport_description(input_address inet, input_port text, input_rw_community text, input_description text) RETURNS void
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SNMP;
|
|
no warnings('redefine');
|
|
|
|
# Local variables and things
|
|
our $host = shift;
|
|
our $portName = shift;
|
|
our $community = shift;
|
|
our $description = shift;
|
|
|
|
# OID List
|
|
our $ifNameList_OID = '.1.3.6.1.2.1.31.1.1.1.1';
|
|
our $ifAliasList_OID = '1.3.6.1.2.1.31.1.1.1.18';
|
|
|
|
# Stored data
|
|
our %ifIndexData;
|
|
our $ifAliasOid = '1.3.6.1.2.1.31.1.1.1.18';
|
|
|
|
# Establish session
|
|
our ($session,$error) = Net::SNMP->session (
|
|
-hostname => $host,
|
|
-community => $community,
|
|
);
|
|
|
|
# Get the index of all interfaces
|
|
my $ifNameList = $session->get_table(-baseoid => $ifNameList_OID);
|
|
while (my($ifIndex,$ifName) = each(%$ifNameList)) {
|
|
$ifIndex =~ s/$ifNameList_OID\.//;
|
|
if($ifIndex =~ m/\d{5}/) {
|
|
# $ifIndexData{$ifIndex} = $ifName;
|
|
if($ifName eq $portName) {
|
|
$ifAliasOid .= ".$ifIndex";
|
|
}
|
|
}
|
|
# warn("$ifIndex - $ifName\n");
|
|
}
|
|
|
|
# Set the new description
|
|
my $result = $session->set_request(
|
|
-varbindlist => [ $ifAliasOid, OCTET_STRING, $description ],
|
|
);
|
|
|
|
if(!$result) {
|
|
die("Error: ",$session->error());
|
|
}
|
|
|
|
# Close initial session
|
|
$session->close();
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_network_switchport_description(input_address inet, input_port text, input_rw_community text, input_description text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_network_switchport_description(input_address inet, input_port text, input_rw_community text, input_description text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_network_switchport_description(input_address inet, input_port text, input_rw_community text, input_description text) IS 'Modify the description of a network switchport';
|
|
|
|
|
|
--
|
|
-- Name: modify_platform(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_platform(input_old_name text, input_field text, input_new_value text) RETURNS SETOF systems.platforms
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to edit platform denied. You are not admin';
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'platform_name|architecture|disk|cpu|memory' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
IF input_field ~* 'memory' THEN
|
|
EXECUTE 'UPDATE "systems"."platforms" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "platform_name" = $1'
|
|
USING input_old_name, input_field, input_new_value::integer;
|
|
ELSE
|
|
EXECUTE 'UPDATE "systems"."platforms" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "platform_name" = $1'
|
|
USING input_old_name, input_field, input_new_value;
|
|
END IF;
|
|
|
|
PERFORM api.syslog('modify_platform:"'||input_old_name||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'platform_name' THEN
|
|
RETURN QUERY (SELECT * FROM "systems"."platforms" WHERE "platform_name" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "systems"."platforms" WHERE "platform_name" = input_old_name);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_platform(input_old_name text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_platform(input_old_name text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_platform(input_old_name text, input_field text, input_new_value text) IS 'Modify a hardware platform';
|
|
|
|
|
|
--
|
|
-- Name: modify_site_configuration(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_site_configuration(input_directive text, input_value text) RETURNS SETOF management.configuration
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can modify site directives';
|
|
END IF;
|
|
|
|
-- Create directive
|
|
UPDATE "management"."configuration" SET "value" = input_value WHERE "option" = input_directive;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_site_configuration:"'||input_directive||'","'||input_value||'"');
|
|
RETURN QUERY (SELECT * FROM "management"."configuration" WHERE "option" = input_directive AND "value" = input_value);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_site_configuration(input_directive text, input_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_site_configuration(input_directive text, input_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_site_configuration(input_directive text, input_value text) IS 'Modify a site configuration directive';
|
|
|
|
|
|
--
|
|
-- Name: modify_system(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_system(input_old_name text, input_field text, input_new_value text) RETURNS SETOF systems.systems
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (SELECT "write" FROM api.get_system_permissions(input_old_name)) IS FALSE THEN
|
|
RAISE EXCEPTION 'Permission denied';
|
|
END IF;
|
|
|
|
-- Check allowed fields
|
|
IF input_field !~* 'system_name|owner|comment|type|os_name|platform_name|asset|group|datacenter|location' THEN
|
|
RAISE EXCEPTION 'Invalid field % specified',input_field;
|
|
END IF;
|
|
|
|
-- Update record
|
|
|
|
EXECUTE 'UPDATE "systems"."systems" SET ' || quote_ident($2) || ' = $3,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "system_name" = $1'
|
|
USING input_old_name, input_field, input_new_value;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('modify_system:"'||input_old_name||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'system_name' THEN
|
|
RETURN QUERY (SELECT * FROM "systems"."systems" WHERE "system_name" = input_new_value);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "systems"."systems" WHERE "system_name" = input_old_name);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_system(input_old_name text, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_system(input_old_name text, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_system(input_old_name text, input_field text, input_new_value text) IS 'Modify an existing system';
|
|
|
|
|
|
--
|
|
-- Name: modify_vlan(text, integer, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.modify_vlan(input_old_datacenter text, input_old_vlan integer, input_field text, input_new_value text) RETURNS SETOF network.vlans
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Only admins can create VLANs';
|
|
END IF;
|
|
|
|
IF input_field !~* 'datacenter|vlan|name|comment' THEN
|
|
RAISE EXCEPTION 'Invalid field %',input_field;
|
|
END IF;
|
|
|
|
IF input_field ~* 'vlan' THEN
|
|
EXECUTE 'UPDATE "network"."vlans" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "datacenter" = $1 AND "vlan" = $2'
|
|
USING input_old_datacenter, input_old_vlan, input_field, input_new_value::integer;
|
|
ELSE
|
|
EXECUTE 'UPDATE "network"."vlans" SET ' || quote_ident($3) || ' = $4,
|
|
date_modified = localtimestamp(0), last_modifier = api.get_current_user()
|
|
WHERE "datacenter" = $1 AND "vlan" = $2'
|
|
USING input_old_datacenter, input_old_vlan, input_field, input_new_value;
|
|
END IF;
|
|
|
|
PERFORM api.syslog('modify_vlan:"'||input_old_datacenter||'","'||input_old_vlan||'","'||input_field||'","'||input_new_value||'"');
|
|
IF input_field ~* 'datacenter' THEN
|
|
RETURN QUERY (SELECT * FROM "network"."vlans" WHERE "datacenter" = input_new_value AND "vlan" = input_old_vlan);
|
|
ELSEIF input_field ~* 'vlan' THEN
|
|
RETURN QUERY (SELECT * FROM "network"."vlans" WHERE "datacenter" = input_old_datacenter AND "vlan" = input_new_value::integer);
|
|
ELSE
|
|
RETURN QUERY (SELECT * FROM "network"."vlans" WHERE "datacenter" = input_old_datacenter AND "vlan" = input_old_vlan);
|
|
END IF;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.modify_vlan(input_old_datacenter text, input_old_vlan integer, input_field text, input_new_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION modify_vlan(input_old_datacenter text, input_old_vlan integer, input_field text, input_new_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.modify_vlan(input_old_datacenter text, input_old_vlan integer, input_field text, input_new_value text) IS 'Modify a VLAN';
|
|
|
|
|
|
--
|
|
-- Name: notify_expiring_addresses(); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.notify_expiring_addresses() RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
SystemData RECORD;
|
|
BEGIN
|
|
FOR SystemData IN (SELECT api.get_interface_address_owner("address") AS "owner","address","renew_date" FROM "systems"."interface_addresses" WHERE "renew_date" <= current_date + api.get_site_configuration('EMAIL_NOTIFICATION_INTERVAL')::interval) LOOP
|
|
PERFORM "api"."send_renewal_email"(api.get_user_email(SystemData.owner), SystemData.address, api.get_interface_address_system(SystemData.address), (SELECT "api"."get_site_configuration"('EMAIL_DOMAIN')), (SELECT api.get_site_configuration('WEB_URL')),(SELECT api.get_site_configuration('MAIL_HOST')));
|
|
PERFORM api.syslog('notified '||api.get_user_email(SystemData.owner)||' of expiring address: '||SystemData.address);
|
|
END LOOP;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.notify_expiring_addresses() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION notify_expiring_addresses(); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.notify_expiring_addresses() IS 'Notify users of soon-to-expire addresses';
|
|
|
|
|
|
--
|
|
-- Name: nslookup(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.nslookup(input_address inet) RETURNS TABLE(fqdn text)
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY (SELECT "hostname"||'.'||"zone" FROM "dns"."a" WHERE "address" = input_address);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.nslookup(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION nslookup(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.nslookup(input_address inet) IS 'Get the DNS name of an IP address in the database';
|
|
|
|
|
|
--
|
|
-- Name: nsupdate(text, text, text, inet, text, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.nsupdate(zone text, keyname text, key text, server inet, action text, record text) RETURNS text
|
|
LANGUAGE plperlu
|
|
AS $_$ use strict;
|
|
use warnings;
|
|
use v5.10;
|
|
use Net::DNS;
|
|
no warnings('redefine');
|
|
|
|
# Local variable information
|
|
our $zone = shift(@_) or die("Invalid zone argument");
|
|
our $keyname = shift(@_) or die("Invalid keyname argument");
|
|
our $key = shift(@_) or die("Invalid key argument");
|
|
our $server = shift(@_) or die("Invalid server argument");
|
|
our $action = shift(@_) or die("Invalid action argument");
|
|
our $record = shift(@_) or die("Invalid record argument");
|
|
|
|
# DNS Server
|
|
our $res = Net::DNS::Resolver->new;
|
|
$res->nameservers($server);
|
|
|
|
|
|
# Update packet
|
|
our $update = Net::DNS::Update->new($zone);
|
|
|
|
# Do something
|
|
my $returnCode;
|
|
if($action eq "DELETE") {
|
|
$returnCode = &delete();
|
|
}
|
|
elsif($action eq "ADD") {
|
|
$returnCode = &add();
|
|
}
|
|
else {
|
|
$returnCode = "INVALID ACTION";
|
|
}
|
|
|
|
# Delete a record
|
|
sub delete() {
|
|
# The record must be there to delete it
|
|
# $update->push(pre => yxrrset($record));
|
|
|
|
# Delete the record
|
|
$update->push(update => rr_del($record));
|
|
|
|
# Sign it
|
|
$update->sign_tsig($keyname, $key);
|
|
|
|
# Send it
|
|
&send();
|
|
}
|
|
|
|
# Add a record
|
|
sub add() {
|
|
# MX and TXT records will already exist. Otherwise the record you are
|
|
# creating should not already be in the zone. That would be silly.
|
|
#
|
|
# Frak it, you better be sure IMPULSE owns your DNS zone. Otherwise old records
|
|
# WILL be overwriten.
|
|
#
|
|
# if($record !~ m/\s(MX|TXT|NS)\s/) {
|
|
# $update->push(pre => nxrrset($record));
|
|
# }
|
|
|
|
# Add the record
|
|
$update->push(update => rr_add($record));
|
|
|
|
# Sign it
|
|
$update->sign_tsig($keyname, $key);
|
|
|
|
# Send it
|
|
&send();
|
|
}
|
|
|
|
# Send an update
|
|
sub send() {
|
|
my $reply = $res->send($update);
|
|
if($reply) {
|
|
if($reply->header->rcode eq 'NOERROR') {
|
|
return 0;
|
|
}
|
|
else {
|
|
return &interpret_error($reply->header->rcode);
|
|
}
|
|
}
|
|
else {
|
|
return &interpret_error($res->errorstring);
|
|
}
|
|
}
|
|
|
|
# Interpret the error codes if any
|
|
sub interpret_error() {
|
|
my $error = shift(@_);
|
|
|
|
given ($error) {
|
|
when (/NXRRSET/) { return "Error $error: Name does not exist"; }
|
|
when (/YXRRSET/) { return "Error $error: Name exists"; }
|
|
when (/NOTAUTH/) { return "Error $error: Not authorized. Check system clocks and or key"; }
|
|
default { return "$error unrecognized"; }
|
|
}
|
|
}
|
|
|
|
return $returnCode;$_$;
|
|
|
|
|
|
ALTER FUNCTION api.nsupdate(zone text, keyname text, key text, server inet, action text, record text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: ping(inet); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.ping(inet) RETURNS boolean
|
|
LANGUAGE plperlu
|
|
AS $_X$
|
|
#! /usr/bin/perl
|
|
use strict;
|
|
use warnings;
|
|
use Net::IP qw(ip_get_version);
|
|
|
|
my $res = 1;
|
|
|
|
if (ip_get_version($_[0]) == 6) {
|
|
$res = system("ping6 -W 1 -c 1 $_[0] > /dev/null");
|
|
} else {
|
|
$res = system("ping -W 1 -c 1 $_[0] > /dev/null");
|
|
}
|
|
|
|
if($res == 0) {
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.ping(inet) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION ping(inet); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.ping(inet) IS 'See if a host is up on the network';
|
|
|
|
|
|
--
|
|
-- Name: query_address_reverse(inet); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.query_address_reverse(inet) RETURNS text
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::DNS;
|
|
use Net::IP;
|
|
use Net::IP qw(:PROC);
|
|
use v5.10;
|
|
|
|
# Define some variables
|
|
my $address = shift(@_) or die "Unable to get address";
|
|
|
|
# Generate the reverse string (d.c.b.a.in-addr.arpa.)
|
|
my $reverse = new Net::IP ($address)->reverse_ip() or die (Net::IP::Error());
|
|
|
|
# Create the resolver
|
|
my $res = Net::DNS::Resolver->new;
|
|
|
|
# Run the query
|
|
my $rr = $res->query($reverse,'PTR');
|
|
|
|
# Check for a response
|
|
if(!defined($rr)) {
|
|
return;
|
|
}
|
|
|
|
# Parse the response
|
|
my @answer = $rr->answer;
|
|
foreach my $response(@answer) {
|
|
return $response->ptrdname;
|
|
}
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.query_address_reverse(inet) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION query_address_reverse(inet); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.query_address_reverse(inet) IS 'Print the forward host of a reverse lookup';
|
|
|
|
|
|
--
|
|
-- Name: query_axfr(text, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.query_axfr(text, text) RETURNS SETOF dns.zone_audit_data
|
|
LANGUAGE plperlu
|
|
AS $_X$
|
|
use strict;
|
|
use warnings;
|
|
use Net::DNS;
|
|
use v5.10;
|
|
use Data::Dumper;
|
|
|
|
my $zone = shift(@_) or die "Unable to get zone";
|
|
my $nameserver = shift(@_) or die "Unable to get nameserver for zone";
|
|
|
|
my $res = Net::DNS::Resolver->new;
|
|
$res->nameservers($nameserver);
|
|
|
|
my @answer = $res->axfr($zone);
|
|
|
|
foreach my $result (@answer) {
|
|
&print_data($result);
|
|
}
|
|
|
|
sub print_data() {
|
|
my $rr = $_[0];
|
|
given($rr->type) {
|
|
when (/^A|AAAA$/) {
|
|
return_next({host=>$rr->name, ttl=>$rr->ttl, type=>$rr->type, address=>$rr->address});
|
|
}
|
|
when (/^CNAME$/) {
|
|
return_next({host=>$rr->name,ttl=>$rr->ttl,type=>$rr->type,target=>$rr->cname});
|
|
}
|
|
when (/^SRV$/) {
|
|
return_next({host=>$rr->name,ttl=>$rr->ttl,type=>$rr->type,priority=>$rr->priority,weight=>$rr->weight,port=>$rr->port,target=>$rr->target});
|
|
}
|
|
when (/^NS$/) {
|
|
return_next({host=>$rr->nsdname, ttl=>$rr->ttl, type=>$rr->type});
|
|
}
|
|
when (/^MX$/) {
|
|
return_next({host=>$rr->exchange, ttl=>$rr->ttl, type=>$rr->type, preference=>$rr->preference});
|
|
}
|
|
when (/^TXT$/) {
|
|
return_next({host=>$rr->name, ttl=>$rr->ttl, type=>$rr->type, text=>$rr->char_str_list});
|
|
}
|
|
when (/^SOA$/) {
|
|
return_next({host=>$rr->name, target=>$rr->mname, ttl=>$rr->ttl, contact=>$rr->rname, serial=>$rr->serial, refresh=>$rr->refresh, retry=>$rr->retry, expire=>$rr->expire, minimum=>$rr->minimum, type=>$rr->type});
|
|
}
|
|
when (/^PTR$/) {
|
|
return_next({host=>$rr->name, target=>$rr->ptrdname, ttl=>$rr->ttl, type=>$rr->type});
|
|
}
|
|
}
|
|
}
|
|
return undef;
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.query_axfr(text, text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION query_axfr(text, text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.query_axfr(text, text) IS 'Query a nameserver for the DNS zone transfer to use for auditing';
|
|
|
|
|
|
--
|
|
-- Name: query_dns_soa(text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.query_dns_soa(text) RETURNS SETOF dns.soa
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::DNS;
|
|
|
|
# Get the zone
|
|
my $zone = shift(@_) or die "Unable to get DNS zone to query";
|
|
|
|
# Date
|
|
my $date = spi_exec_query("SELECT localtimestamp(0)");
|
|
$date = $date->{rows}[0]->{timestamp};
|
|
my $user = spi_exec_query("SELECT api.get_current_user()");
|
|
$user = $user->{rows}[0]->{get_current_user};
|
|
|
|
# Establish the resolver and make the query
|
|
my $res = Net::DNS::Resolver->new;
|
|
my $rr = $res->query($zone,'soa');
|
|
|
|
# Check if it actually returned
|
|
if(!defined($rr)) {
|
|
die "Unable to find record for zone $zone";
|
|
}
|
|
|
|
# Spit out the serial
|
|
my @answer = $rr->answer;
|
|
return_next({zone=>$zone, nameserver=>$answer[0]->mname, ttl=>$answer[0]->ttl, contact=>$answer[0]->rname, serial=>$answer[0]->serial, refresh=>$answer[0]->refresh, retry=>$answer[0]->retry, expire=>$answer[0]->expire, minimum=>$answer[0]->minimum, date_created=>$date, date_modified=>$date, last_modifier=>$user});
|
|
return undef;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.query_dns_soa(text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION query_dns_soa(text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.query_dns_soa(text) IS 'Use the hosts resolver to query and create an SOA';
|
|
|
|
|
|
--
|
|
-- Name: query_zone_serial(text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.query_zone_serial(text) RETURNS text
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::DNS;
|
|
|
|
# Get the zone
|
|
my $zone = shift(@_) or die "Unable to get DNS zone to query";
|
|
|
|
# Establish the resolver and make the query
|
|
my $res = Net::DNS::Resolver->new;
|
|
my $rr = $res->query($zone,'soa');
|
|
|
|
# Check if it actually returned
|
|
if(!defined($rr)) {
|
|
die "Unable to find record for zone $zone";
|
|
}
|
|
|
|
# Spit out the serial
|
|
my @answer = $rr->answer;
|
|
return $answer[0]->serial;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.query_zone_serial(text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION query_zone_serial(text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.query_zone_serial(text) IS 'Query this hosts resolver for the serial number of the zone.';
|
|
|
|
|
|
--
|
|
-- Name: reload_cam(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.reload_cam(input_system_name text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF api.get_current_user() != (SELECT "owner" FROM "systems"."systems" WHERE "system_name" = input_system_name) THEN
|
|
RAISE EXCEPTION 'Permission denied: Not owner';
|
|
END IF;
|
|
END IF;
|
|
|
|
INSERT INTO "network"."cam_cache" ("system_name","mac","vlan","date_created","date_modified","last_modifier","ifindex") (
|
|
SELECT input_system_name,mac,vlan,localtimestamp(0),localtimestamp(0),api.get_current_user(),ifindex
|
|
FROM api.get_switchview_device_cam(input_system_name)
|
|
);
|
|
DELETE FROM "network"."cam_cache" WHERE "system_name" = input_system_name AND "date_created" != localtimestamp(0);
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.reload_cam(input_system_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION reload_cam(input_system_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.reload_cam(input_system_name text) IS 'Reload the cam cache for a system';
|
|
|
|
|
|
--
|
|
-- Name: reload_group_members(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.reload_group_members(input_group text) RETURNS SETOF management.group_members
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
MemberData RECORD;
|
|
ReloadData RECORD;
|
|
Settings RECORD;
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can reload group members';
|
|
END IF;
|
|
|
|
SELECT * INTO Settings FROM api.get_group_settings(input_group);
|
|
|
|
IF Settings."provider" !~* 'ldap|vcloud|ad' THEN
|
|
RAISE EXCEPTION 'Cannot reload local group';
|
|
END IF;
|
|
|
|
IF Settings."provider" IS NULL THEN
|
|
RAISE EXCEPTION 'Cannot reload group with no provider: %',input_group;
|
|
END IF;
|
|
|
|
FOR MemberData IN (SELECT * FROM api.get_group_members(input_group)) LOOP
|
|
PERFORM api.remove_group_member(input_group, MemberData."user");
|
|
END LOOP;
|
|
|
|
IF Settings."provider" ~* 'LDAP' THEN
|
|
FOR ReloadData IN (SELECT * FROM api.get_ldap_group_members(Settings."hostname", Settings."id", Settings."username", Settings."password")) LOOP
|
|
PERFORM api.create_group_member(input_group, ReloadData.get_ldap_group_members, Settings."privilege");
|
|
END LOOP;
|
|
END IF;
|
|
|
|
IF Settings."provider" ~* 'vcloud' THEN
|
|
FOR ReloadData IN (SELECT * FROM api.get_vcloud_group_members(Settings."hostname", Settings."id", Settings."username", Settings."password")) LOOP
|
|
PERFORM api.create_group_member(input_group, ReloadData.get_vcloud_group_members, Settings."privilege");
|
|
END LOOP;
|
|
END IF;
|
|
|
|
PERFORM api.syslog('reload_group_members:"'||input_group||'"');
|
|
RETURN QUERY (SELECT * FROM api.get_group_members(input_group));
|
|
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.reload_group_members(input_group text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: remove_availability_zone(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_availability_zone(input_datacenter text, input_zone text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied: Only admins can remove availability_zones';
|
|
END IF;
|
|
|
|
-- Perform delete
|
|
DELETE FROM "systems"."availability_zones" WHERE "datacenter" = input_datacenter AND "zone" = input_zone;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_availability_zone:"'||input_datacenter||'","'||input_zone||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_availability_zone(input_datacenter text, input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_availability_zone(input_datacenter text, input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_availability_zone(input_datacenter text, input_zone text) IS 'Remove an availability zone';
|
|
|
|
|
|
--
|
|
-- Name: remove_datacenter(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_datacenter(input_name text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied: Only admins can remove datacenters';
|
|
END IF;
|
|
|
|
-- Perform delete
|
|
DELETE FROM "systems"."datacenters" WHERE "datacenter" = input_name;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_datacenter:"'||input_name||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_datacenter(input_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_datacenter(input_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_datacenter(input_name text) IS 'remove a datacenter';
|
|
|
|
|
|
--
|
|
-- Name: remove_dhcp_class(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dhcp_class(input_class text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to remove dhcp class denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Remove class
|
|
DELETE FROM "dhcp"."classes" WHERE "class" = input_class;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_dhcp_class:"'||input_class||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dhcp_class(input_class text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dhcp_class(input_class text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dhcp_class(input_class text) IS 'Delete an existing DHCP class';
|
|
|
|
|
|
--
|
|
-- Name: remove_dhcp_class_option(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dhcp_class_option(input_class text, input_option text, input_value text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to remove dhcp class option denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Remove class option
|
|
DELETE FROM "dhcp"."class_options"
|
|
WHERE "class" = input_class AND "option" = input_option AND "value" = input_value;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_dhcp_class_option:"'||input_class||'","'||input_option||'","'||input_value||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dhcp_class_option(input_class text, input_option text, input_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dhcp_class_option(input_class text, input_option text, input_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dhcp_class_option(input_class text, input_option text, input_value text) IS 'Delete an existing DHCP class option';
|
|
|
|
|
|
--
|
|
-- Name: remove_dhcp_global_option(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dhcp_global_option(input_option text, input_value text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to remove dhcp global option denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Delete global option
|
|
DELETE FROM "dhcp"."global_options"
|
|
WHERE "option" = input_option AND "value" = input_value;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_dhcp_global_option:"'||input_option||'","'||input_value||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dhcp_global_option(input_option text, input_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dhcp_global_option(input_option text, input_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dhcp_global_option(input_option text, input_value text) IS 'Delete an existing DHCP global option';
|
|
|
|
|
|
--
|
|
-- Name: remove_dhcp_range_option(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dhcp_range_option(input_range text, input_option text, input_value text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to remove dhcp range option denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Remove range option
|
|
DELETE FROM "dhcp"."range_options"
|
|
WHERE "name" = input_range AND "option" = input_option;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_dhcp_range_option:"'||input_range||'","'||input_option||'","'||input_value||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dhcp_range_option(input_range text, input_option text, input_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dhcp_range_option(input_range text, input_option text, input_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dhcp_range_option(input_range text, input_option text, input_value text) IS 'Delete an existing DHCP range option';
|
|
|
|
|
|
--
|
|
-- Name: remove_dhcp_subnet_option(cidr, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dhcp_subnet_option(input_subnet cidr, input_option text, input_value text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
RAISE EXCEPTION 'Permission to remove dhcp subnet option denied for %. Not admin.',api.get_current_user();
|
|
END IF;
|
|
|
|
-- Delete subnet option
|
|
DELETE FROM "dhcp"."subnet_options"
|
|
WHERE "subnet" = input_subnet AND "option" = input_option AND "value" = input_value;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_dhcp_subnet_option:"'||input_subnet||'","'||input_option||'","'||input_value||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dhcp_subnet_option(input_subnet cidr, input_option text, input_value text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dhcp_subnet_option(input_subnet cidr, input_option text, input_value text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dhcp_subnet_option(input_subnet cidr, input_option text, input_value text) IS 'Delete an existing DHCP subnet option';
|
|
|
|
|
|
--
|
|
-- Name: remove_dns_address(inet, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dns_address(input_address inet, input_zone text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."a" WHERE "address" = input_address AND "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied for % (%) on DNS address %. You are not owner.',api.get_current_user(),api.get_current_user_level(),input_address;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove record
|
|
DELETE FROM "dns"."a" WHERE "address" = input_address AND "zone" = input_zone;
|
|
|
|
PERFORM api.syslog('remove_dns_address:"'||input_address||'","'||input_zone||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dns_address(input_address inet, input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dns_address(input_address inet, input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dns_address(input_address inet, input_zone text) IS 'delete an A or AAAA record';
|
|
|
|
|
|
--
|
|
-- Name: remove_dns_cname(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dns_cname(input_alias text, input_zone text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."cname" WHERE "alias" = input_alias AND "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied for % (%) on DNS CNAME %. You are not owner.',api.get_current_user(),api.get_current_user_level(),input_alias||'.'||input_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove record
|
|
DELETE FROM "dns"."cname" WHERE "alias" = input_alias AND "zone" = input_zone;
|
|
|
|
PERFORM api.syslog('remove_dns_cname:"'||input_alias||'","'||input_zone||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dns_cname(input_alias text, input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dns_cname(input_alias text, input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dns_cname(input_alias text, input_zone text) IS 'remove a dns cname record for a host';
|
|
|
|
|
|
--
|
|
-- Name: remove_dns_key(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dns_key(input_keyname text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."keys" WHERE "keyname" = input_keyname) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied for % (%) on key %. You are not owner.',api.get_current_user(),api.get_current_user_level(),input_keyname;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove key
|
|
DELETE FROM "dns"."keys" WHERE "keyname" = input_keyname;
|
|
|
|
PERFORM api.syslog('remove_dns_key:"'||input_keyname||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dns_key(input_keyname text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dns_key(input_keyname text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dns_key(input_keyname text) IS 'Delete existing DNS key';
|
|
|
|
|
|
--
|
|
-- Name: remove_dns_mailserver(text, integer); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dns_mailserver(input_zone text, input_preference integer) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."mx" WHERE "zone" = input_zone AND "preference" = input_preference) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied for % (%) on DNS MX %. You are not owner.',api.get_current_user(),api.get_current_user_level(),input_hostname||'.'||input_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove record
|
|
DELETE FROM "dns"."mx" WHERE "zone" = input_zone AND "preference" = input_preference;
|
|
|
|
PERFORM api.syslog('remove_dns_mailserver:"'||input_zone||'","'||input_preference||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dns_mailserver(input_zone text, input_preference integer) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dns_mailserver(input_zone text, input_preference integer); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dns_mailserver(input_zone text, input_preference integer) IS 'Delete an existing MX record for a zone';
|
|
|
|
|
|
--
|
|
-- Name: remove_dns_ns(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dns_ns(input_zone text, input_nameserver text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied for % (%) on DNS NS %. You are not owner.',api.get_current_user(),api.get_current_user_level(),input_nameserver;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove record
|
|
DELETE FROM "dns"."ns" WHERE "zone" = input_zone AND "nameserver" = input_nameserver;
|
|
|
|
PERFORM api.syslog('remove_dns_ns:"'||input_zone||'","'||input_nameserver||'"');
|
|
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dns_ns(input_zone text, input_nameserver text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dns_ns(input_zone text, input_nameserver text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dns_ns(input_zone text, input_nameserver text) IS 'Remove a DNS NS record from the zone';
|
|
|
|
|
|
--
|
|
-- Name: remove_dns_soa(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dns_soa(input_zone text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied for % (%) on zone %. You are not owner.',api.get_current_user(),api.get_current_user_level(),input_soa;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Delete soa
|
|
DELETE FROM "dns"."soa"
|
|
WHERE "zone" = input_zone;
|
|
|
|
PERFORM api.syslog('remove_dns_soa:"'||input_zone||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dns_soa(input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dns_soa(input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dns_soa(input_zone text) IS 'Delete existing DNS soa';
|
|
|
|
|
|
--
|
|
-- Name: remove_dns_srv(text, text, integer, integer, integer); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dns_srv(input_alias text, input_zone text, input_priority integer, input_weight integer, input_port integer) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."srv" WHERE "alias" = input_alias AND "zone" = input_zone AND "priority" = input_priority AND "weight" = input_weight AND "port" = input_port) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied for % (%) on DNS SRV %. You are not owner.',api.get_current_user(),api.get_current_user_level(),input_alias||'.'||input_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove record
|
|
DELETE FROM "dns"."srv" WHERE "alias" = input_alias AND "zone" = input_zone AND "priority" = input_priority AND "weight" = input_weight AND "port" = input_port;
|
|
|
|
PERFORM api.syslog('remove_dns_srv:"'||input_alias||'","'||input_zone||'","'||input_priority||'","'||input_weight||'","'||input_port||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dns_srv(input_alias text, input_zone text, input_priority integer, input_weight integer, input_port integer) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dns_srv(input_alias text, input_zone text, input_priority integer, input_weight integer, input_port integer); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dns_srv(input_alias text, input_zone text, input_priority integer, input_weight integer, input_port integer) IS 'remove a dns srv record';
|
|
|
|
|
|
--
|
|
-- Name: remove_dns_txt(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dns_txt(input_hostname text, input_zone text, input_text text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."txt" WHERE "hostname" = input_hostname AND "zone" = input_zone AND "text" = input_text) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied for % (%) on DNS TXT %. You are not owner.',api.get_current_user(),api.get_current_user_level(),input_hostname||'.'||input_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove record
|
|
DELETE FROM "dns"."txt" WHERE "hostname" = input_hostname AND "zone" = input_zone AND "text" = input_text;
|
|
|
|
PERFORM api.syslog('remove_dns_txt:"'||input_hostname||'","'||input_zone||'","'||input_text||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dns_txt(input_hostname text, input_zone text, input_text text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dns_txt(input_hostname text, input_zone text, input_text text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dns_txt(input_hostname text, input_zone text, input_text text) IS 'remove a dns text record for a host';
|
|
|
|
|
|
--
|
|
-- Name: remove_dns_zone(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dns_zone(input_zone text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied for % (%) on zone %. You are not owner.',api.get_current_user(),api.get_current_user_level(),input_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Delete zone
|
|
DELETE FROM "dns"."zones"
|
|
WHERE "zone" = input_zone;
|
|
|
|
PERFORM api.syslog('remove_dns_zone:"'||input_zone||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dns_zone(input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dns_zone(input_zone text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dns_zone(input_zone text) IS 'Delete existing DNS zone';
|
|
|
|
|
|
--
|
|
-- Name: remove_dns_zone_a(text, inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dns_zone_a(input_zone text, input_address inet) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied for % (%) on DNS zone %. You are not owner.',api.get_current_user(),api.get_current_user_level(),input_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove record
|
|
DELETE FROM "dns"."zone_a" WHERE "address" = input_address AND "zone" = input_zone;
|
|
|
|
PERFORM api.syslog('remove_dns_zone_a:"'||input_zone||'","'||input_address||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dns_zone_a(input_zone text, input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dns_zone_a(input_zone text, input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dns_zone_a(input_zone text, input_address inet) IS 'delete a zone A or AAAA record';
|
|
|
|
|
|
--
|
|
-- Name: remove_dns_zone_txt(text, text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_dns_zone_txt(input_hostname text, input_zone text, input_text text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "dns"."zones" WHERE "zone" = input_zone) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied for % (%) on DNS zone_txt %. You are not owner.',api.get_current_user(),api.get_current_user_level(),input_hostname||'.'||input_zone;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove record
|
|
IF input_hostname IS NULL THEN
|
|
PERFORM api.syslog('remove_dns_zone_txt:"'||input_zone||'","'||input_text||'"');
|
|
DELETE FROM "dns"."zone_txt" WHERE "hostname" IS NULL AND "zone" = input_zone AND "text" = input_text;
|
|
ELSE
|
|
PERFORM api.syslog('remove_dns_zone_txt:"'||input_hostname||'","'||input_zone||'","'||input_text||'"');
|
|
DELETE FROM "dns"."zone_txt" WHERE "hostname" = input_hostname AND "zone" = input_zone AND "text" = input_text;
|
|
END IF;
|
|
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_dns_zone_txt(input_hostname text, input_zone text, input_text text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_dns_zone_txt(input_hostname text, input_zone text, input_text text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_dns_zone_txt(input_hostname text, input_zone text, input_text text) IS 'remove a dns text record for a host';
|
|
|
|
|
|
--
|
|
-- Name: remove_group(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_group(input_group text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can remove groups.';
|
|
END IF;
|
|
|
|
DELETE FROM "management"."groups" WHERE "group" = input_group;
|
|
|
|
PERFORM api.syslog('remove_group:"'||input_group||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_group(input_group text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_group(input_group text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_group(input_group text) IS 'Remove a group';
|
|
|
|
|
|
--
|
|
-- Name: remove_group_member(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_group_member(input_group text, input_user text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF api.get_current_user() NOT IN (SELECT * FROM api.get_group_admins(input_group)) THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can remove groups members';
|
|
END IF;
|
|
END IF;
|
|
|
|
DELETE FROM "management"."group_members" WHERE "group" = input_group AND "user" = input_user;
|
|
|
|
PERFORM api.syslog('remove_group_member:"'||input_group||'","'||input_user||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_group_member(input_group text, input_user text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_group_member(input_group text, input_user text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_group_member(input_group text, input_user text) IS 'Remove a group member';
|
|
|
|
|
|
--
|
|
-- Name: remove_group_settings(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_group_settings(input_group text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can remove group provider settings';
|
|
END IF;
|
|
|
|
DELETE FROM "management"."group_settings" WHERE "group" = input_group;
|
|
|
|
PERFORM api.syslog('remove_group_settings:"'||input_group||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_group_settings(input_group text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_group_settings(input_group text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_group_settings(input_group text) IS 'remove group authentication providers';
|
|
|
|
|
|
--
|
|
-- Name: remove_interface(macaddr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_interface(input_mac macaddr) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."interfaces"
|
|
JOIN "systems"."systems" ON "systems"."systems"."system_name" = "systems"."interfaces"."system_name"
|
|
WHERE "systems"."interfaces"."mac" = input_mac) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on interface %. You are not owner.',input_mac;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove interface
|
|
DELETE FROM "systems"."interfaces" WHERE "mac" = input_mac;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_interface:"'||input_mac||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_interface(input_mac macaddr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_interface(input_mac macaddr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_interface(input_mac macaddr) IS 'delete an interface based on MAC address';
|
|
|
|
|
|
--
|
|
-- Name: remove_interface_address(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_interface_address(input_address inet) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."interface_addresses"
|
|
JOIN "systems"."interfaces" ON "systems"."interfaces"."mac" = "systems"."interface_addresses"."mac"
|
|
JOIN "systems"."systems" ON "systems"."systems"."system_name" = "systems"."interfaces"."system_name"
|
|
WHERE "systems"."interface_addresses"."address" = input_address) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on interface address %. You are not owner.',input_address;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove address
|
|
DELETE FROM "systems"."interface_addresses" WHERE "address" = input_address;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_interface_address:"'||input_address||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_interface_address(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_interface_address(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_interface_address(input_address inet) IS 'delete an interface address';
|
|
|
|
|
|
--
|
|
-- Name: remove_ip_range(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_ip_range(input_name text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "ip"."subnets" WHERE "subnet" =
|
|
(SELECT "subnet" FROM "ip"."ranges" WHERE "name" = input_range)) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to delete range % denied. Not owner',input_name;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Delete range
|
|
DELETE FROM "ip"."ranges" WHERE "name" = input_name;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_ip_range:"'||input_name||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_ip_range(input_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_ip_range(input_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_ip_range(input_name text) IS 'Delete an existing IP range';
|
|
|
|
|
|
--
|
|
-- Name: remove_ip_subnet(cidr); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_ip_subnet(input_subnet cidr) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
WasAuto BOOLEAN;
|
|
BEGIN
|
|
-- Check privileges
|
|
IF (api.get_current_user_level() !~* 'ADMIN') THEN
|
|
IF (SELECT "owner" FROM "ip"."subnets" WHERE "subnet" = input_subnet) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission to delete subnet % denied. Not owner',input_subnet;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Delete RDNS zone
|
|
PERFORM api.remove_dns_zone(api.get_reverse_domain(input_subnet));
|
|
|
|
-- Delete subnet
|
|
DELETE FROM "ip"."subnets" WHERE "subnet" = input_subnet;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_ip_subnet:"'||input_subnet||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_ip_subnet(input_subnet cidr) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_ip_subnet(input_subnet cidr); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_ip_subnet(input_subnet cidr) IS 'Delete/deactivate an existing subnet';
|
|
|
|
|
|
--
|
|
-- Name: remove_libvirt_domain(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_libvirt_domain(input_host text, input_domain text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "system"."systems" WHERE "system_name" = input_host) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only admins can remove VM hosts';
|
|
END IF;
|
|
IF (SELECT "owner" FROM "system"."systems" WHERE "system_name" = input_domain) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Only admins can remove VM hosts';
|
|
END IF;
|
|
END IF;
|
|
|
|
DELETE FROM "libvirt"."domains" WHERE "domain_name" = input_domain AND "host_name" = input_host;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_libvirt_domain(input_host text, input_domain text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_libvirt_domain(input_host text, input_domain text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_libvirt_domain(input_host text, input_domain text) IS 'Remove a libvirt domain';
|
|
|
|
|
|
--
|
|
-- Name: remove_libvirt_host(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_libvirt_host(input_system text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Only admins can remove VM hosts';
|
|
END IF;
|
|
|
|
DELETE FROM "libvirt"."hosts" WHERE "system_name" = input_system;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_libvirt_host(input_system text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_libvirt_host(input_system text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_libvirt_host(input_system text) IS 'Remove libvirt connection credentials for a system';
|
|
|
|
|
|
--
|
|
-- Name: remove_libvirt_platform(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_libvirt_platform(input_name text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Only admins can remove VM hosts';
|
|
END IF;
|
|
|
|
DELETE FROM "libvirt"."platforms" WHERE "platform_name" = input_name;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_libvirt_platform(input_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_libvirt_platform(input_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_libvirt_platform(input_name text) IS 'Remove libvirt platform';
|
|
|
|
|
|
--
|
|
-- Name: remove_network_snmp(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_network_snmp(input_system text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."systems" WHERE "system_name" = input_system) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied: you are not owner';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Create it
|
|
DELETE FROM "network"."snmp" WHERE "system_name" = input_system;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_network_snmp:"'||input_system||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_network_snmp(input_system text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_network_snmp(input_system text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_network_snmp(input_system text) IS 'Remove credentials for a system';
|
|
|
|
|
|
--
|
|
-- Name: remove_platform(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_platform(input_name text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied: Only admins can remove platforms';
|
|
END IF;
|
|
|
|
DELETE FROM "systems"."platforms" WHERE "platform_name" = input_name;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_platform(input_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_platform(input_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_platform(input_name text) IS 'Remove a platform';
|
|
|
|
|
|
--
|
|
-- Name: remove_range_group(text, text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_range_group(input_range text, input_group text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Only admins can assign range resources to groups';
|
|
END IF;
|
|
|
|
-- Remove
|
|
DELETE FROM "ip"."range_groups" WHERE "range_name" = input_range AND "group_name" = input_group;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_range_group:"'||input_range||'","'||input_group||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_range_group(input_range text, input_group text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_range_group(input_range text, input_group text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_range_group(input_range text, input_group text) IS 'Remove a range group';
|
|
|
|
|
|
--
|
|
-- Name: remove_site_configuration(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_site_configuration(input_directive text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied. Only admins can remove site directives';
|
|
END IF;
|
|
|
|
-- Create directive
|
|
DELETE FROM "management"."configuration" WHERE "option" = input_directive;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_site_configuration:"'||input_directive||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_site_configuration(input_directive text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_site_configuration(input_directive text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_site_configuration(input_directive text) IS 'Remove a site configuration directive';
|
|
|
|
|
|
--
|
|
-- Name: remove_system(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_system(input_system_name text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
IF (SELECT "owner" FROM "systems"."systems" WHERE "system_name" = input_system_name) != api.get_current_user() THEN
|
|
RAISE EXCEPTION 'Permission denied on system %. You are not owner.',input_system_name;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Remove system
|
|
DELETE FROM "systems"."systems" WHERE "system_name" = input_system_name;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_system:"'||input_system_name||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_system(input_system_name text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_system(input_system_name text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_system(input_system_name text) IS 'Delete an existing system';
|
|
|
|
|
|
--
|
|
-- Name: remove_users_systems(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_users_systems(username text) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
|
|
-- Check privileges
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Permission denied: Only admins can remove all systems from a user';
|
|
END IF;
|
|
|
|
-- Perform delete
|
|
DELETE FROM "systems"."systems" WHERE "owner" = username;
|
|
|
|
-- Done
|
|
PERFORM api.syslog('remove_users_systems:"'||username||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_users_systems(username text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_users_systems(username text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_users_systems(username text) IS 'Remove all systems owned by a user';
|
|
|
|
|
|
--
|
|
-- Name: remove_vlan(text, integer); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.remove_vlan(input_datacenter text, input_vlan integer) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF api.get_current_user_level() !~* 'ADMIN' THEN
|
|
RAISE EXCEPTION 'Only admins can remove VLANs';
|
|
END IF;
|
|
|
|
DELETE FROM "network"."vlans" WHERE "datacenter" = input_datacenter AND "vlan" = input_vlan;
|
|
PERFORM api.syslog('remove_vlan:"'||input_datacenter||'","'||input_vlan||'"');
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.remove_vlan(input_datacenter text, input_vlan integer) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION remove_vlan(input_datacenter text, input_vlan integer); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.remove_vlan(input_datacenter text, input_vlan integer) IS 'Remove a VLAN';
|
|
|
|
|
|
--
|
|
-- Name: renew_interface_address(inet); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.renew_interface_address(input_address inet) RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
UPDATE "systems"."interface_addresses"
|
|
SET "renew_date" = date(('now'::text)::date + (SELECT "renew_interval" FROM "management"."groups" JOIN "systems"."systems" ON "systems"."systems"."group" = "management"."groups"."group" WHERE "system_name" = api.get_interface_address_system(input_address)))
|
|
WHERE "address" = input_address;
|
|
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.renew_interface_address(input_address inet) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION renew_interface_address(input_address inet); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.renew_interface_address(input_address inet) IS 'renew an interface address registration for another interval';
|
|
|
|
|
|
--
|
|
-- Name: resolve(text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.resolve(text) RETURNS inet
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Socket qw(inet_ntoa);
|
|
|
|
my $hostname = shift() or die "Unable to get name argument";
|
|
my ($name,$aliases,$addrtype,$length,@addrs) = gethostbyname($hostname);
|
|
return inet_ntoa($addrs[0]);
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.resolve(text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: send_renewal_email(text, inet, text, text, text, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.send_renewal_email(text, inet, text, text, text, text) RETURNS void
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
use strict;
|
|
use warnings;
|
|
use Net::SMTP;
|
|
use POSIX;
|
|
|
|
my $email = shift(@_) or die "Unable to get email";
|
|
my $address = shift(@_) or die "Unable to get address";
|
|
my $system = shift(@_) or die "Unable to get system";
|
|
my $domain = shift(@_) or die "Unable to get mail domain";
|
|
my $url = shift(@_) or die "Unable to get URL";
|
|
my $mailserver = shift(@_) or die "Unable to get mailserver";
|
|
|
|
my $smtp = Net::SMTP->new($mailserver);
|
|
|
|
if(!$smtp) { die "Unable to connect to \"$mailserver\"\n"; }
|
|
|
|
$smtp->mail("starrs-noreply\@$domain");
|
|
$smtp->recipient("$email");
|
|
$smtp->data;
|
|
$smtp->datasend("Date: " . strftime("%a, %d %b %Y %H:%M:%S %z", localtime) . "\n");
|
|
$smtp->datasend("From: starrs-noreply\@$domain\n");
|
|
$smtp->datasend("To: $email\n");
|
|
$smtp->datasend("Subject: STARRS Renewal Notification - $address\n");
|
|
$smtp->datasend("\n");
|
|
$smtp->datasend("Your registered address $address on system $system will expire in less than 7 days and may be removed from STARRS automatically. You can click $url/addresses/viewrenew to renew your address(s). Alternatively you can navigate to the Interface Address view and click the Renew button. If you have any questions, please see your local system administrator.");
|
|
|
|
$smtp->datasend;
|
|
$smtp->quit;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.send_renewal_email(text, inet, text, text, text, text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION send_renewal_email(text, inet, text, text, text, text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.send_renewal_email(text, inet, text, text, text, text) IS 'Send an email to a user saying their address is about to expire';
|
|
|
|
|
|
--
|
|
-- Name: syslog(text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.syslog(input_message text) RETURNS void
|
|
LANGUAGE plperlu
|
|
AS $_$
|
|
#!/usr/bin/perl
|
|
use strict;
|
|
use warnings;
|
|
use Sys::Syslog qw( :DEFAULT setlogsock);
|
|
|
|
#my $sev = shift(@_) or die "Unable to get severity";
|
|
my $sev = "info";
|
|
my $msg = shift(@_) or die "Unable to get message.";
|
|
my $facility = spi_exec_query("SELECT api.get_site_configuration('SYSLOG_FACILITY')")->{rows}[0]->{"get_site_configuration"};
|
|
my $user= spi_exec_query("SELECT api.get_current_user()")->{rows}[0]->{"get_current_user"};
|
|
setlogsock('unix');
|
|
openlog("STARRS",'',$facility);
|
|
syslog($sev, "$user $msg");
|
|
closelog;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION api.syslog(input_message text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION syslog(input_message text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.syslog(input_message text) IS 'Log to syslog';
|
|
|
|
|
|
--
|
|
-- Name: validate_domain(text, text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.validate_domain(hostname text, domain text) RETURNS boolean
|
|
LANGUAGE plperlu
|
|
AS $_X$
|
|
use strict;
|
|
use warnings;
|
|
use Data::Validate::Domain qw(is_domain);
|
|
# die("LOLZ");
|
|
|
|
# Usage: PERFORM api.validate_domain([hostname OR NULL],[domain OR NULL]);
|
|
|
|
# Declare the string to check later on
|
|
my $domain;
|
|
|
|
# This script can deal with just domain validation rather than host-domain. Note that the
|
|
# module this depends on requires a valid TLD, so one is picked for this purpose.
|
|
if (!$_[0])
|
|
{
|
|
# We are checking a domain name only
|
|
$domain = $_[1];
|
|
}
|
|
elsif (!$_[1])
|
|
{
|
|
# We are checking a hostname only
|
|
$domain = "$_[0].me";
|
|
}
|
|
else
|
|
{
|
|
# We have enough for a FQDN
|
|
$domain = "$_[0].$_[1]";
|
|
}
|
|
|
|
if($_[0] eq "0") {
|
|
return 'TRUE';
|
|
}
|
|
|
|
# Return a boolean value of whether the input forms a valid domain
|
|
if (is_domain($domain))
|
|
{
|
|
return 'TRUE';
|
|
}
|
|
else
|
|
{
|
|
# This module sucks and should be disabled
|
|
#return 'TRUE';
|
|
# Seems to be working normally... Keep an eye on your domain validation
|
|
return 'FALSE';
|
|
}
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.validate_domain(hostname text, domain text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION validate_domain(hostname text, domain text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.validate_domain(hostname text, domain text) IS 'Validate hostname, domain, FQDN based on known rules. Requires Perl module';
|
|
|
|
|
|
--
|
|
-- Name: validate_name(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.validate_name(input text) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
BadCrap TEXT;
|
|
BEGIN
|
|
BadCrap = regexp_replace(input, E'[a-z0-9\:\_\/ ]*\-*', '', 'gi');
|
|
IF BadCrap != '' THEN
|
|
RAISE EXCEPTION 'Invalid characters detected in string "%"',input;
|
|
END IF;
|
|
IF input = '' THEN
|
|
RAISE EXCEPTION 'Name cannot be blank';
|
|
END IF;
|
|
RETURN input;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.validate_name(input text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION validate_name(input text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.validate_name(input text) IS 'Allow certain characters for names';
|
|
|
|
|
|
--
|
|
-- Name: validate_nospecial(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.validate_nospecial(input text) RETURNS text
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
BadCrap TEXT;
|
|
BEGIN
|
|
BadCrap = regexp_replace(input, E'[a-z0-9]*', '', 'gi');
|
|
IF BadCrap != '' THEN
|
|
RAISE EXCEPTION 'Invalid characters detected in string "%"',input;
|
|
END IF;
|
|
RETURN input;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.validate_nospecial(input text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION validate_nospecial(input text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.validate_nospecial(input text) IS 'Block all special characters';
|
|
|
|
|
|
--
|
|
-- Name: validate_soa_contact(text); Type: FUNCTION; Schema: api; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION api.validate_soa_contact(input text) RETURNS boolean
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
BadCrap TEXT;
|
|
BEGIN
|
|
BadCrap = regexp_replace(input, E'[a-z0-9\.]*\-*', '', 'gi');
|
|
IF BadCrap != '' THEN
|
|
RAISE EXCEPTION 'Invalid characters detected in string "%"',input;
|
|
END IF;
|
|
IF input = '' THEN
|
|
RAISE EXCEPTION 'Contact cannot be blank';
|
|
END IF;
|
|
RETURN TRUE;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION api.validate_soa_contact(input text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION validate_soa_contact(input text); Type: COMMENT; Schema: api; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.validate_soa_contact(input text) IS 'Ensure that the SOA contact is properly formatted';
|
|
|
|
|
|
--
|
|
-- Name: validate_srv(text); Type: FUNCTION; Schema: api; Owner: postgres
|
|
--
|
|
|
|
CREATE FUNCTION api.validate_srv(text) RETURNS boolean
|
|
LANGUAGE plperl
|
|
AS $_X$ my $srv = $_[0];
|
|
my @parts = split('\.',$srv);
|
|
# Check for two parts: the service and the transport
|
|
if (scalar(@parts) ne 2)
|
|
{
|
|
die "Improper number of parts in record\n";
|
|
}
|
|
|
|
# Define parts of the record
|
|
my $service = $parts[0];
|
|
my $transport = $parts[1];
|
|
|
|
# Check if transport is valid
|
|
if ($transport !~ m/_tcp|_udp/i)
|
|
{
|
|
return "false";
|
|
}
|
|
|
|
# Check that service is valid
|
|
if ($service !~ m/^_[\w-]+$/i)
|
|
{
|
|
return "false";
|
|
}
|
|
|
|
# Good!
|
|
return "true";
|
|
$_X$;
|
|
|
|
|
|
ALTER FUNCTION api.validate_srv(text) OWNER TO postgres;
|
|
|
|
--
|
|
-- Name: FUNCTION validate_srv(text); Type: COMMENT; Schema: api; Owner: postgres
|
|
--
|
|
|
|
COMMENT ON FUNCTION api.validate_srv(text) IS 'Validate SRV records';
|
|
|
|
|
|
--
|
|
-- Name: a_insert(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.a_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$ DECLARE
|
|
RowCount INTEGER;
|
|
BEGIN
|
|
/*
|
|
-- Check for zone mismatch
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."subnets"
|
|
WHERE "ip"."subnets"."zone" = NEW."zone"
|
|
AND NEW."address" << "ip"."subnets"."subnet";
|
|
IF (RowCount < 1) THEN
|
|
RAISE EXCEPTION 'IP address and DNS Zone do not match (%, %)',NEW."address",NEW."zone";
|
|
END IF;
|
|
*/
|
|
-- Autofill type
|
|
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.a_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION a_insert(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.a_insert() IS 'Creating a new A or AAAA record';
|
|
|
|
|
|
--
|
|
-- Name: a_update(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.a_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
BEGIN
|
|
-- Address/Zone mismatch
|
|
IF NEW."address" != OLD."address" THEN
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."subnets"
|
|
WHERE "ip"."subnets"."zone" = NEW."zone"
|
|
AND NEW."address" << "ip"."subnets"."subnet";
|
|
IF (RowCount < 1) THEN
|
|
RAISE EXCEPTION 'IP address and DNS Zone do not match (%, %)',NEW."address",NEW."zone";
|
|
END IF;
|
|
|
|
-- Autofill Type
|
|
END IF;
|
|
|
|
-- New zone mismatch
|
|
IF NEW."zone" != OLD."zone" THEN
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."subnets"
|
|
WHERE "ip"."subnets"."zone" = NEW."zone"
|
|
AND NEW."address" << "ip"."subnets"."subnet";
|
|
IF (RowCount < 1) THEN
|
|
RAISE EXCEPTION 'IP address and DNS Zone do not match (%, %)',NEW."address",NEW."zone";
|
|
END IF;
|
|
END IF;
|
|
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.a_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION a_update(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.a_update() IS 'Update an existing A or AAAA record';
|
|
|
|
|
|
--
|
|
-- Name: cname_insert(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.cname_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
BEGIN
|
|
-- Check if alias name already exists
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."a"
|
|
WHERE "dns"."a"."hostname" = NEW."alias";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Alias name (%) already exists',NEW."alias";
|
|
END IF;
|
|
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."srv"
|
|
WHERE "dns"."srv"."alias" = NEW."alias";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Alias name (%) already exists as a SRV',NEW."alias";
|
|
END IF;
|
|
|
|
-- Autopopulate address
|
|
NEW."address" := dns.dns_autopopulate_address(NEW."hostname",NEW."zone");
|
|
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.cname_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION cname_insert(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.cname_insert() IS 'Check if the alias already exists as an address record';
|
|
|
|
|
|
--
|
|
-- Name: cname_update(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.cname_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
BEGIN
|
|
-- Check if alias name already exists
|
|
IF NEW."alias" != OLD."alias" THEN
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."a"
|
|
WHERE "dns"."a"."hostname" = NEW."alias";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Alias name (%) already exists',NEW."alias";
|
|
END IF;
|
|
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."srv"
|
|
WHERE "dns"."srv"."alias" = NEW."alias";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Alias name (%) already exists as a SRV',NEW."alias";
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Autopopulate address
|
|
IF NEW."address" != OLD."address" THEN
|
|
NEW."address" := dns.dns_autopopulate_address(NEW."hostname",NEW."zone");
|
|
END IF;
|
|
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.cname_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION cname_update(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.cname_update() IS 'Check if the new alias already exists as an address record';
|
|
|
|
|
|
--
|
|
-- Name: dns_autopopulate_address(text, text); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.dns_autopopulate_address(input_hostname text, input_zone text) RETURNS inet
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
address INET;
|
|
BEGIN
|
|
SELECT "dns"."a"."address" INTO address
|
|
FROM "dns"."a"
|
|
WHERE "dns"."a"."hostname" = input_hostname
|
|
AND "dns"."a"."zone" = input_zone LIMIT 1;
|
|
|
|
IF address IS NULL THEN
|
|
RAISE EXCEPTION 'Unable to find address for given host % and zone %',input_hostname,input_zone;
|
|
ELSE
|
|
RETURN address;
|
|
END IF;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.dns_autopopulate_address(input_hostname text, input_zone text) OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION dns_autopopulate_address(input_hostname text, input_zone text); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.dns_autopopulate_address(input_hostname text, input_zone text) IS 'Fill in the address portion of the foreign key relationship';
|
|
|
|
|
|
--
|
|
-- Name: mx_insert(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.mx_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
NEW."address" := dns.dns_autopopulate_address(NEW."hostname",NEW."zone");
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.mx_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION mx_insert(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.mx_insert() IS 'Create new MX record';
|
|
|
|
|
|
--
|
|
-- Name: mx_update(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.mx_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF NEW."address" != OLD."address" THEN
|
|
NEW."address" := dns.dns_autopopulate_address(NEW."hostname",NEW."zone");
|
|
END IF;
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.mx_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION mx_update(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.mx_update() IS 'Modify a MX record';
|
|
|
|
|
|
--
|
|
-- Name: ns_query_delete(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.ns_query_delete() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
DECLARE
|
|
ReturnCode TEXT; -- Return code from the nsupdate function
|
|
DnsKeyName TEXT; -- The DNS keyname to sign with
|
|
DnsKey TEXT; -- The DNS key to sign with
|
|
DnsServer INET; -- The nameserver to send the update to
|
|
DnsRecord TEXT; -- The formatted string that is the record
|
|
BEGIN
|
|
IF (SELECT "ddns" FROM "dns"."zones" WHERE "dns"."zones"."zone" = OLD."zone") IS FALSE THEN
|
|
RETURN OLD;
|
|
END IF;
|
|
|
|
-- If this is a forward zone:
|
|
IF (SELECT "forward" FROM "dns"."zones" WHERE "zone" = OLD."zone") IS TRUE THEN
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."zones"."zone" = OLD."zone";
|
|
-- If this is a reverse zone:
|
|
ELSE
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."ns"."zone" = (SELECT "ip"."subnets"."zone" FROM "ip"."subnets" WHERE api.get_reverse_domain("subnet") = OLD."zone");
|
|
END IF;
|
|
|
|
-- Just make sure no-one is forcing a bogus type
|
|
IF OLD."type" !~* '^NS$' THEN
|
|
RAISE EXCEPTION 'Trying to create a non-NS record in an NS table!';
|
|
END IF;
|
|
|
|
-- Create and fire off the update
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."nameserver";
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
-- Check for result
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing NS-DELETE %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
-- Done!
|
|
RETURN OLD;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION dns.ns_query_delete() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION ns_query_delete(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.ns_query_delete() IS 'Delete an old NS record from the server';
|
|
|
|
|
|
--
|
|
-- Name: ns_query_insert(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.ns_query_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
DECLARE
|
|
ReturnCode TEXT; -- Return code from the nsupdate function
|
|
DnsKeyName TEXT; -- The DNS keyname to sign with
|
|
DnsKey TEXT; -- The DNS key to sign with
|
|
DnsServer INET; -- The nameserver to send the update to
|
|
DnsRecord TEXT; -- The formatted string that is the record
|
|
BEGIN
|
|
IF (SELECT "ddns" FROM "dns"."zones" WHERE "dns"."zones"."zone" = NEW."zone") IS FALSE THEN
|
|
RETURN NEW;
|
|
END IF;
|
|
|
|
-- If this is a forward zone:
|
|
IF (SELECT "forward" FROM "dns"."zones" WHERE "zone" = NEW."zone") IS TRUE THEN
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key","address"
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."ns"
|
|
JOIN "dns"."zones" ON "dns"."ns"."zone" = "dns"."zones"."zone"
|
|
JOIN "dns"."keys" ON "dns"."zones"."keyname" = "dns"."keys"."keyname"
|
|
WHERE "dns"."ns"."zone" = NEW."zone" AND "dns"."ns"."nameserver" IN (SELECT "nameserver" FROM "dns"."soa" WHERE "dns"."soa"."zone" = NEW."zone");
|
|
-- If this is a reverse zone:
|
|
ELSE
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key","dns"."ns"."address"
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."ns"
|
|
JOIN "dns"."zones" ON "dns"."ns"."zone" = "dns"."zones"."zone"
|
|
JOIN "dns"."keys" ON "dns"."zones"."keyname" = "dns"."keys"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."ns"."zone"
|
|
WHERE "dns"."ns"."nameserver" = "dns"."soa"."nameserver"
|
|
AND "dns"."ns"."zone" = (SELECT "ip"."subnets"."zone" FROM "ip"."subnets" WHERE api.get_reverse_domain("subnet") = NEW."zone");
|
|
END IF;
|
|
|
|
-- Just make sure no-one is forcing a bogus type
|
|
IF NEW."type" !~* '^NS$' THEN
|
|
RAISE EXCEPTION 'Trying to create a non-NS record in an NS table!';
|
|
END IF;
|
|
|
|
-- Create and fire off the update
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."nameserver";
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
|
|
-- Check for result
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
-- Done!
|
|
RETURN NEW;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION dns.ns_query_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION ns_query_insert(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.ns_query_insert() IS 'Update the nameserver with a new NS record';
|
|
|
|
|
|
--
|
|
-- Name: ns_query_update(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.ns_query_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
DECLARE
|
|
ReturnCode TEXT; -- Return code from the nsupdate function
|
|
DnsKeyName TEXT; -- The DNS keyname to sign with
|
|
DnsKey TEXT; -- The DNS key to sign with
|
|
DnsServer INET; -- The nameserver to send the update to
|
|
DnsRecord TEXT; -- The formatted string that is the record
|
|
BEGIN
|
|
IF (SELECT "ddns" FROM "dns"."zones" WHERE "dns"."zones"."zone" = OLD."zone") IS FALSE THEN
|
|
RETURN NEW;
|
|
END IF;
|
|
|
|
-- If this is a forward zone:
|
|
IF (SELECT "forward" FROM "dns"."zones" WHERE "zone" = NEW."zone") IS TRUE THEN
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."zones"."zone" = NEW."zone";
|
|
-- If this is a reverse zone:
|
|
ELSE
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."ns"."zone" = (SELECT "ip"."subnets"."zone" FROM "ip"."subnets" WHERE api.get_reverse_domain("subnet") = NEW."zone");
|
|
END IF;
|
|
|
|
-- Just make sure no-one is forcing a bogus type
|
|
IF NEW."type" !~* '^NS$' THEN
|
|
RAISE EXCEPTION 'Trying to create a non-NS record in an NS table!';
|
|
END IF;
|
|
|
|
-- Delete the record first
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."nameserver";
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
-- Check for result
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing NS-UPDATE-DELETE %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
IF (SELECT "ddns" FROM "dns"."zones" WHERE "dns"."zones"."zone" = NEW."zone") IS FALSE THEN
|
|
RETURN NEW;
|
|
END IF;
|
|
|
|
-- Create and fire off the update
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."nameserver";
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
|
|
-- Check for result
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing NS-UPDATE-INSERT %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
-- Done!
|
|
RETURN NEW;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION dns.ns_query_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION ns_query_update(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.ns_query_update() IS 'Update the nameserver with a new NS record';
|
|
|
|
|
|
--
|
|
-- Name: queue_delete(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.queue_delete() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
DECLARE
|
|
ReturnCode TEXT;
|
|
DnsKeyName TEXT;
|
|
DnsKey TEXT;
|
|
DnsServer INET;
|
|
DnsRecord TEXT;
|
|
RevZone TEXT;
|
|
RevSubnet CIDR;
|
|
BEGIN
|
|
IF (SELECT "ddns" FROM "dns"."zones" WHERE "dns"."zones"."zone" = OLD."zone") IS FALSE THEN
|
|
RETURN OLD;
|
|
END IF;
|
|
|
|
|
|
-- This needs cleaned up a lot. See github bug #211 for more details. This fix works but is
|
|
-- not exactly great.
|
|
IF true THEN
|
|
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."zones"."zone" = OLD."zone";
|
|
|
|
IF OLD."type" ~* '^A|AAAA$' THEN
|
|
--NULL hostname means zone address
|
|
IF OLD."hostname" IS NULL THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||host(OLD."address");
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
ELSE
|
|
-- Do the forward record first
|
|
DnsRecord := OLD."hostname"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||host(OLD."address");
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
-- Check for errors
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
-- Get the proper zone for the reverse A record
|
|
SELECT "zone" INTO RevZone
|
|
FROM "ip"."subnets"
|
|
WHERE OLD."address" << "subnet";
|
|
|
|
-- Get the subnet
|
|
SELECT "subnet" INTO RevSubnet
|
|
FROM "ip"."subnets"
|
|
WHERE OLD."address" << "subnet";
|
|
|
|
-- If it is in this domain, add the reverse entry
|
|
IF RevZone = OLD."zone" AND OLD."reverse" IS TRUE AND NOT OLD."address" << api.get_site_configuration('DYNAMIC_SUBNET')::cidr THEN
|
|
DnsRecord := api.get_reverse_domain(OLD."address")||' '||OLD."ttl"||' PTR '||OLD."hostname"||'.'||OLD."zone"||'.';
|
|
ReturnCode := api.nsupdate(api.get_reverse_domain(RevSubnet),DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
END IF;
|
|
END IF;
|
|
|
|
ELSEIF OLD."type" ~* '^NS$' THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."nameserver";
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
ELSEIF OLD."type" ~* '^MX$' THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."preference"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
ELSEIF OLD."type" ~* '^SRV$' THEN
|
|
DnsRecord := OLD."alias"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."priority"||' '||OLD."weight"||' '||OLD."port"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
ELSEIF OLD."type" ~* '^CNAME$' THEN
|
|
DnsRecord := OLD."alias"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
ELSEIF OLD."type" ~* '^TXT$' THEN
|
|
-- For zone TXT records
|
|
IF OLD."hostname" IS NULL THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
ELSE
|
|
DnsRecord := OLD."hostname"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
END IF;
|
|
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
ELSE
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."zones"."zone" = OLD."zone";
|
|
|
|
IF OLD."type" ~* '^NS$' THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."nameserver";
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
ELSEIF OLD."type" ~* '^MX$' THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."preference"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
ELSEIF OLD."type" ~* '^SRV$' THEN
|
|
DnsRecord := OLD."alias"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."priority"||' '||OLD."weight"||' '||OLD."port"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
ELSEIF OLD."type" ~* '^CNAME$' THEN
|
|
DnsRecord := OLD."alias"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
ELSEIF OLD."type" ~* '^TXT$' THEN
|
|
-- For zone TXT records
|
|
IF OLD."hostname" IS NULL THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
ELSE
|
|
DnsRecord := OLD."hostname"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
END IF;
|
|
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
END IF;
|
|
|
|
RETURN OLD;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION dns.queue_delete() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION queue_delete(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.queue_delete() IS 'Add a delete directive to the queue';
|
|
|
|
|
|
--
|
|
-- Name: queue_insert(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.queue_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $_$ DECLARE
|
|
ReturnCode TEXT;
|
|
DnsKeyName TEXT;
|
|
DnsKey TEXT;
|
|
DnsServer INET;
|
|
DnsRecord TEXT;
|
|
RevZone TEXT;
|
|
RevSubnet CIDR;
|
|
BEGIN
|
|
IF (SELECT "ddns" FROM "dns"."zones" WHERE "dns"."zones"."zone" = NEW."zone") IS FALSE THEN
|
|
RETURN NEW;
|
|
END IF;
|
|
|
|
IF (SELECT "config" FROM api.get_system_interface_address(NEW."address")) ~* 'static|dhcpv6' THEN
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."zones"."zone" = NEW."zone";
|
|
|
|
IF NEW."type" ~* '^A|AAAA$' THEN
|
|
--NULL hostname means zone address
|
|
IF NEW."hostname" IS NULL THEN
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||host(NEW."address");
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSE
|
|
-- Do the forward record first
|
|
DnsRecord := NEW."hostname"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||host(NEW."address");
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
|
|
-- Check for errors
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
-- Get the proper zone for the reverse A record
|
|
SELECT "zone" INTO RevZone
|
|
FROM "ip"."subnets"
|
|
WHERE NEW."address" << "subnet";
|
|
|
|
-- Get the subnet
|
|
SELECT "subnet" INTO RevSubnet
|
|
FROM "ip"."subnets"
|
|
WHERE NEW."address" << "subnet";
|
|
|
|
-- If it is in this domain, add the reverse entry
|
|
IF RevZone = NEW."zone" AND NEW."reverse" IS TRUE THEN
|
|
DnsRecord := api.get_reverse_domain(NEW."address")||' '||NEW."ttl"||' PTR '||NEW."hostname"||'.'||NEW."zone"||'.';
|
|
ReturnCode := api.nsupdate(api.get_reverse_domain(RevSubnet),DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
END IF;
|
|
END IF;
|
|
|
|
ELSEIF NEW."type" ~* '^NS$' THEN
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."nameserver";
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^MX$' THEN
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."preference"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^SRV$' THEN
|
|
DnsRecord := NEW."alias"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."priority"||' '||NEW."weight"||' '||NEW."port"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^CNAME$' THEN
|
|
DnsRecord := NEW."alias"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^TXT$' THEN
|
|
-- For zone TXT records
|
|
IF NEW."hostname" IS NULL THEN
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
ELSE
|
|
DnsRecord := NEW."hostname"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
END IF;
|
|
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
ELSE
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."zones"."zone" = NEW."zone";
|
|
|
|
IF NEW."type" ~* '^NS$' THEN
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."nameserver";
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^MX$' THEN
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."preference"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^SRV$' THEN
|
|
DnsRecord := NEW."alias"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."priority"||' '||NEW."weight"||' '||NEW."port"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^CNAME$' THEN
|
|
DnsRecord := NEW."alias"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^TXT$' THEN
|
|
-- For zone TXT records
|
|
IF NEW."hostname" IS NULL THEN
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
ELSE
|
|
DnsRecord := NEW."hostname"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
END IF;
|
|
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
END IF;
|
|
|
|
RETURN NEW;
|
|
END;$_$;
|
|
|
|
|
|
ALTER FUNCTION dns.queue_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION queue_insert(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.queue_insert() IS 'Add an add directive to the queue';
|
|
|
|
|
|
--
|
|
-- Name: queue_update(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.queue_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $_$ DECLARE
|
|
ReturnCode TEXT;
|
|
DnsKeyName TEXT;
|
|
DnsKey TEXT;
|
|
DnsServer INET;
|
|
DnsRecord TEXT;
|
|
RevZone TEXT;
|
|
RevSubnet CIDR;
|
|
BEGIN
|
|
IF (SELECT "ddns" FROM "dns"."zones" WHERE "dns"."zones"."zone" = NEW."zone") IS FALSE THEN
|
|
RETURN NEW;
|
|
END IF;
|
|
|
|
IF (SELECT "config" FROM api.get_system_interface_address(NEW."address")) ~* 'static|dhcpv6' THEN
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."zones"."zone" = NEW."zone";
|
|
|
|
IF NEW."type" ~* '^A|AAAA$' THEN
|
|
--NULL hostname means zone address
|
|
IF NEW."hostname" IS NULL THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||host(OLD."address");
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||host(NEW."address");
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSE
|
|
-- Do the forward record first
|
|
DnsRecord := OLD."hostname"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||host(OLD."address");
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
-- Check for errors
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
-- Get the proper zone for the reverse A record
|
|
SELECT "zone" INTO RevZone
|
|
FROM "ip"."subnets"
|
|
WHERE OLD."address" << "subnet";
|
|
|
|
-- Get the subnet
|
|
SELECT "subnet" INTO RevSubnet
|
|
FROM "ip"."subnets"
|
|
WHERE OLD."address" << "subnet";
|
|
|
|
-- If it is in this domain, add the reverse entry
|
|
IF RevZone = OLD."zone" AND OLD."reverse" IS TRUE THEN
|
|
DnsRecord := api.get_reverse_domain(OLD."address")||' '||OLD."ttl"||' PTR '||OLD."hostname"||'.'||OLD."zone"||'.';
|
|
ReturnCode := Returncode||api.nsupdate(api.get_reverse_domain(RevSubnet),DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
END IF;
|
|
|
|
-- Do the forward record first
|
|
DnsRecord := NEW."hostname"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||host(NEW."address");
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
|
|
-- Check for errors
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
-- Get the proper zone for the reverse A record
|
|
SELECT "zone" INTO RevZone
|
|
FROM "ip"."subnets"
|
|
WHERE NEW."address" << "subnet";
|
|
|
|
-- Get the subnet
|
|
SELECT "subnet" INTO RevSubnet
|
|
FROM "ip"."subnets"
|
|
WHERE NEW."address" << "subnet";
|
|
|
|
-- If it is in this domain, add the reverse entry
|
|
IF RevZone = NEW."zone" AND NEW."reverse" IS TRUE THEN
|
|
DnsRecord := api.get_reverse_domain(NEW."address")||' '||NEW."ttl"||' PTR '||NEW."hostname"||'.'||NEW."zone"||'.';
|
|
ReturnCode := Returncode||api.nsupdate(api.get_reverse_domain(RevSubnet),DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
END IF;
|
|
END IF;
|
|
|
|
ELSEIF NEW."type" ~* '^NS$' THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."nameserver";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."nameserver";
|
|
ReturnCode := Returncode||api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^MX$' THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."preference"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."preference"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := Returncode||api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^SRV$' THEN
|
|
DnsRecord := OLD."alias"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."priority"||' '||OLD."weight"||' '||OLD."port"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
DnsRecord := NEW."alias"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."priority"||' '||NEW."weight"||' '||NEW."port"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := Returncode||api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^CNAME$' THEN
|
|
DnsRecord := OLD."alias"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
DnsRecord := NEW."alias"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := Returncode||api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^TXT$' THEN
|
|
-- For zone TXT records
|
|
IF OLD."hostname" IS NULL THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
ELSE
|
|
DnsRecord := OLD."hostname"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
IF NEW."hostname" IS NULL THEN
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
ELSE
|
|
DnsRecord := NEW."hostname"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
END IF;
|
|
ELSE
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."zones"."zone" = NEW."zone";
|
|
|
|
IF NEW."type" ~* '^NS$' THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."nameserver";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."nameserver";
|
|
ReturnCode := Returncode||api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^MX$' THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."preference"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."preference"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := Returncode||api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^SRV$' THEN
|
|
DnsRecord := OLD."alias"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."priority"||' '||OLD."weight"||' '||OLD."port"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
DnsRecord := NEW."alias"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."priority"||' '||NEW."weight"||' '||NEW."port"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := Returncode||api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^CNAME$' THEN
|
|
DnsRecord := OLD."alias"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' '||OLD."hostname"||'.'||OLD."zone";
|
|
ReturnCode := Returncode||api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
DnsRecord := NEW."alias"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' '||NEW."hostname"||'.'||NEW."zone";
|
|
ReturnCode := Returncode||api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
ELSEIF NEW."type" ~* '^TXT$' THEN
|
|
-- For zone TXT records
|
|
IF OLD."hostname" IS NULL THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
ELSE
|
|
DnsRecord := OLD."hostname"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
IF NEW."hostname" IS NULL THEN
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
ELSE
|
|
DnsRecord := NEW."hostname"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
END IF;
|
|
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
END IF;
|
|
RETURN NEW;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION dns.queue_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION queue_update(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.queue_update() IS 'Add a delete then add directive to the queue';
|
|
|
|
|
|
--
|
|
-- Name: srv_insert(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.srv_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
BEGIN
|
|
-- Check if alias name already exists
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."a"
|
|
WHERE "dns"."a"."hostname" = NEW."alias";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Alias name (%) already exists',NEW."alias";
|
|
END IF;
|
|
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."cname"
|
|
WHERE "dns"."cname"."alias" = NEW."alias";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Alias name (%) already exists as a CNAME',NEW."alias";
|
|
END IF;
|
|
|
|
-- Autopopulate address
|
|
NEW."address" := dns.dns_autopopulate_address(NEW."hostname",NEW."zone");
|
|
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.srv_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION srv_insert(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.srv_insert() IS 'Check if the alias already exists as an address record';
|
|
|
|
|
|
--
|
|
-- Name: srv_update(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.srv_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
BEGIN
|
|
-- Check if alias name already exists
|
|
IF NEW."alias" != OLD."alias" THEN
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."a"
|
|
WHERE "dns"."a"."hostname" = NEW."alias";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Alias name (%) already exists',NEW."alias";
|
|
END IF;
|
|
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."cname"
|
|
WHERE "dns"."cname"."alias" = NEW."alias";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Alias name (%) already exists as a CNAME',NEW."alias";
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Autopopulate address
|
|
IF NEW."address" != OLD."address" THEN
|
|
NEW."address" := dns.dns_autopopulate_address(NEW."hostname",NEW."zone");
|
|
END IF;
|
|
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.srv_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION srv_update(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.srv_update() IS 'Check if the new alias already exists as an address record';
|
|
|
|
|
|
--
|
|
-- Name: txt_insert(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.txt_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
NEW."address" := dns.dns_autopopulate_address(NEW."hostname",NEW."zone");
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.txt_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION txt_insert(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.txt_insert() IS 'Create new TXT record';
|
|
|
|
|
|
--
|
|
-- Name: txt_query_delete(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.txt_query_delete() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
DECLARE
|
|
ReturnCode TEXT; -- Return code from the nsupdate function
|
|
DnsKeyName TEXT; -- The DNS keyname to sign with
|
|
DnsKey TEXT; -- The DNS key to sign with
|
|
DnsServer INET; -- The nameserver to send the update to
|
|
DnsRecord TEXT; -- The formatted string that is the record
|
|
BEGIN
|
|
IF (SELECT "ddns" FROM "dns"."zones" WHERE "dns"."zones"."zone" = OLD."zone") IS FALSE THEN
|
|
RETURN OLD;
|
|
END IF;
|
|
|
|
-- If this is a forward zone:
|
|
IF (SELECT "forward" FROM "dns"."zones" WHERE "zone" = OLD."zone") IS TRUE THEN
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."zones"."zone" = OLD."zone";
|
|
-- If this is a reverse zone:
|
|
ELSE
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."ns"."zone" = (SELECT "ip"."subnets"."zone" FROM "ip"."subnets" WHERE api.get_reverse_domain("subnet") = OLD."zone");
|
|
END IF;
|
|
|
|
-- Just make sure no-one is forcing a bogus type
|
|
IF OLD."type" !~* '^TXT$' THEN
|
|
RAISE EXCEPTION 'Trying to delete a non-TXT record in a TXT table!';
|
|
END IF;
|
|
|
|
-- Create and fire off the update
|
|
-- For zone TXT records
|
|
IF OLD."hostname" IS NULL THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
ELSE
|
|
DnsRecord := OLD."hostname"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
-- Check for result
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing TXT-DELETE %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
-- Done!
|
|
RETURN OLD;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION dns.txt_query_delete() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION txt_query_delete(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.txt_query_delete() IS 'Delete an old TXT record from the server';
|
|
|
|
|
|
--
|
|
-- Name: txt_query_insert(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.txt_query_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
DECLARE
|
|
ReturnCode TEXT; -- Return code from the nsupdate function
|
|
DnsKeyName TEXT; -- The DNS keyname to sign with
|
|
DnsKey TEXT; -- The DNS key to sign with
|
|
DnsServer INET; -- The nameserver to send the update to
|
|
DnsRecord TEXT; -- The formatted string that is the record
|
|
BEGIN
|
|
IF (SELECT "ddns" FROM "dns"."zones" WHERE "dns"."zones"."zone" = NEW."zone") IS FALSE THEN
|
|
RETURN NEW;
|
|
END IF;
|
|
|
|
-- If this is a forward zone:
|
|
IF (SELECT "forward" FROM "dns"."zones" WHERE "zone" = NEW."zone") IS TRUE THEN
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."zones"."zone" = NEW."zone";
|
|
-- If this is a reverse zone:
|
|
ELSE
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."ns"."zone" = (SELECT "ip"."subnets"."zone" FROM "ip"."subnets" WHERE api.get_reverse_domain("subnet") = NEW."zone");
|
|
END IF;
|
|
|
|
-- Just make sure no-one is forcing a bogus type
|
|
IF NEW."type" !~* '^TXT$' THEN
|
|
RAISE EXCEPTION 'Trying to create a non-TXT record in a TXT table!';
|
|
END IF;
|
|
|
|
-- Create and fire off the update
|
|
-- For zone TXT records
|
|
IF NEW."hostname" IS NULL THEN
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
ELSE
|
|
DnsRecord := NEW."hostname"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
|
|
-- Check for result
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing TXT-INSERT %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
-- Done!
|
|
RETURN NEW;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION dns.txt_query_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION txt_query_insert(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.txt_query_insert() IS 'Update the nameserver with a new TXT record';
|
|
|
|
|
|
--
|
|
-- Name: txt_query_update(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.txt_query_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
DECLARE
|
|
ReturnCode TEXT; -- Return code from the nsupdate function
|
|
DnsKeyName TEXT; -- The DNS keyname to sign with
|
|
DnsKey TEXT; -- The DNS key to sign with
|
|
DnsServer INET; -- The nameserver to send the update to
|
|
DnsRecord TEXT; -- The formatted string that is the record
|
|
BEGIN
|
|
-- If this is a forward zone:
|
|
IF (SELECT "forward" FROM "dns"."zones" WHERE "zone" = NEW."zone") IS TRUE THEN
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."zones"."zone" = NEW."zone";
|
|
-- If this is a reverse zone:
|
|
ELSE
|
|
SELECT "dns"."keys"."keyname","dns"."keys"."key",api.resolve("dns"."soa"."nameserver")
|
|
INTO DnsKeyName, DnsKey, DnsServer
|
|
FROM "dns"."zones"
|
|
JOIN "dns"."keys" ON "dns"."keys"."keyname" = "dns"."zones"."keyname"
|
|
JOIN "dns"."soa" ON "dns"."soa"."zone" = "dns"."zones"."zone"
|
|
WHERE "dns"."ns"."zone" = (SELECT "ip"."subnets"."zone" FROM "ip"."subnets" WHERE api.get_reverse_domain("subnet") = NEW."zone");
|
|
END IF;
|
|
|
|
-- Just make sure no-one is forcing a bogus type
|
|
IF NEW."type" !~* '^TXT$' THEN
|
|
RAISE EXCEPTION 'Trying to update a non-TXT record in a TXT table!';
|
|
END IF;
|
|
|
|
IF (SELECT "ddns" FROM "dns"."zones" WHERE "dns"."zones"."zone" = OLD."zone") IS FALSE THEN
|
|
RETURN NEW;
|
|
END IF;
|
|
|
|
-- Delete the record first
|
|
IF OLD."hostname" IS NULL THEN
|
|
DnsRecord := OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
ELSE
|
|
DnsRecord := OLD."hostname"||'.'||OLD."zone"||' '||OLD."ttl"||' '||OLD."type"||' "'||OLD."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(OLD."zone",DnsKeyName,DnsKey,DnsServer,'DELETE',DnsRecord);
|
|
|
|
-- Check for result
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing TXT-UPDATE-DELETE %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
IF (SELECT "ddns" FROM "dns"."zones" WHERE "dns"."zones"."zone" = NEW."zone") IS FALSE THEN
|
|
RETURN NEW;
|
|
END IF;
|
|
|
|
-- Create and fire off the update
|
|
IF NEW."hostname" IS NULL THEN
|
|
DnsRecord := NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
ELSE
|
|
DnsRecord := NEW."hostname"||'.'||NEW."zone"||' '||NEW."ttl"||' '||NEW."type"||' "'||NEW."text"||'"';
|
|
END IF;
|
|
ReturnCode := api.nsupdate(NEW."zone",DnsKeyName,DnsKey,DnsServer,'ADD',DnsRecord);
|
|
|
|
-- Check for result
|
|
IF ReturnCode != '0' THEN
|
|
RAISE EXCEPTION 'DNS Error: % when performing TXT-UPDATE-INSERT %',ReturnCode,DnsRecord;
|
|
END IF;
|
|
|
|
-- Done!
|
|
RETURN NEW;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION dns.txt_query_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION txt_query_update(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.txt_query_update() IS 'Update the nameserver with a new TXT record';
|
|
|
|
|
|
--
|
|
-- Name: txt_update(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.txt_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF NEW."address" != OLD."address" THEN
|
|
NEW."address" := dns.dns_autopopulate_address(NEW."hostname",NEW."zone");
|
|
END IF;
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.txt_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION txt_update(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.txt_update() IS 'Modify a TXT record';
|
|
|
|
|
|
--
|
|
-- Name: zone_a_delete(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.zone_a_delete() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF family(OLD."address") = 4 THEN
|
|
OLD."type" = 'A';
|
|
ELSE
|
|
OLD."type" = 'AAAA';
|
|
END IF;
|
|
RETURN OLD;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.zone_a_delete() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION zone_a_delete(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.zone_a_delete() IS 'Auto-fill the type based on the address family.';
|
|
|
|
|
|
--
|
|
-- Name: zone_a_insert(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.zone_a_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF family(NEW."address") = 4 THEN
|
|
NEW."type" = 'A';
|
|
ELSE
|
|
NEW."type" = 'AAAA';
|
|
END IF;
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.zone_a_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION zone_a_insert(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.zone_a_insert() IS 'Auto-fill the type based on the address family.';
|
|
|
|
|
|
--
|
|
-- Name: zone_a_update(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.zone_a_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF family(NEW."address") = 4 THEN
|
|
NEW."type" = 'A';
|
|
ELSE
|
|
NEW."type" = 'AAAA';
|
|
END IF;
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.zone_a_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION zone_a_update(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.zone_a_update() IS 'Auto-fill the type based on the address family.';
|
|
|
|
|
|
--
|
|
-- Name: zone_txt_insert(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.zone_txt_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
|
|
BEGIN
|
|
IF NEW."hostname" IS NOT NULL THEN
|
|
-- Check if hostname name already exists as an A
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."a"
|
|
WHERE "dns"."a"."hostname" = NEW."hostname";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Hostname (%) already exists',NEW."hostname";
|
|
END IF;
|
|
|
|
-- Check if hostname name already exists as an SRV
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."srv"
|
|
WHERE "dns"."srv"."alias" = NEW."hostname";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'hostname (%) already exists as a SRV',NEW."hostname";
|
|
END IF;
|
|
|
|
-- Check if hostname name already exists as an CNAME
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."cname"
|
|
WHERE "dns"."cname"."alias" = NEW."hostname";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'hostname (%) already exists as a CNAME',NEW."hostname";
|
|
END IF;
|
|
END IF;
|
|
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.zone_txt_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION zone_txt_insert(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.zone_txt_insert() IS 'Check if the hostname already exists in other tables and insert the zone TXT record';
|
|
|
|
|
|
--
|
|
-- Name: zone_txt_update(); Type: FUNCTION; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION dns.zone_txt_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
|
|
BEGIN
|
|
-- Check if hostname name already exists
|
|
IF NEW."hostname" != OLD."hostname" THEN
|
|
IF NEW."hostname" IS NOT NULL THEN
|
|
-- Check if hostname name already exists as an A
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."a"
|
|
WHERE "dns"."a"."hostname" = NEW."hostname";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Hostname (%) already exists',NEW."hostname";
|
|
END IF;
|
|
|
|
-- Check if hostname name already exists as an SRV
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."srv"
|
|
WHERE "dns"."srv"."alias" = NEW."hostname";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'hostname (%) already exists as a SRV',NEW."hostname";
|
|
END IF;
|
|
|
|
-- Check if hostname name already exists as an CNAME
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "dns"."cname"
|
|
WHERE "dns"."cname"."alias" = NEW."hostname";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'hostname (%) already exists as a CNAME',NEW."hostname";
|
|
END IF;
|
|
END IF;
|
|
END IF;
|
|
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION dns.zone_txt_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION zone_txt_update(); Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION dns.zone_txt_update() IS 'Check if the new hostname already exists in other tables and update the zone TXT record';
|
|
|
|
|
|
--
|
|
-- Name: addresses_insert(); Type: FUNCTION; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION ip.addresses_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
BEGIN
|
|
-- Done
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION ip.addresses_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION addresses_insert(); Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION ip.addresses_insert() IS 'Activate a new IP address in the application';
|
|
|
|
|
|
--
|
|
-- Name: ranges_insert(); Type: FUNCTION; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION ip.ranges_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
LowerBound INET;
|
|
UpperBound INET;
|
|
query_result RECORD;
|
|
RowCount INTEGER;
|
|
BEGIN
|
|
-- Check for illegal addresses
|
|
IF host(NEW."subnet") = host(NEW."first_ip") THEN
|
|
RAISE EXCEPTION 'You cannot have a boundry that is the network identifier';
|
|
END IF;
|
|
|
|
-- Check address vs subnet
|
|
IF NOT NEW."first_ip" << NEW."subnet" OR NOT NEW."last_ip" << NEW."subnet" THEN
|
|
RAISE EXCEPTION 'Range addresses must be inside the specified subnet';
|
|
END IF;
|
|
|
|
-- Check valid range
|
|
IF NEW."first_ip" >= NEW."last_ip" THEN
|
|
RAISE EXCEPTION 'First address is larger or equal to last address.';
|
|
END IF;
|
|
|
|
-- IPv6
|
|
IF family(NEW."subnet") = 6 THEN
|
|
INSERT INTO "ip"."addresses" ("address") (SELECT * FROM "api"."get_range_addresses"(NEW."first_ip", NEW."last_ip") AS "potential" WHERE "potential" NOT IN (SELECT "address" FROM "ip"."addresses" WHERE "ip"."addresses"."address" << NEW."subnet"));
|
|
END IF;
|
|
|
|
-- Check address existance
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."addresses"
|
|
WHERE "ip"."addresses"."address" = NEW."first_ip";
|
|
IF (RowCount != 1) THEN
|
|
RAISE EXCEPTION 'First address (%) not found in address pool.',NEW."first_ip";
|
|
END IF;
|
|
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."addresses"
|
|
WHERE "ip"."addresses"."address" = NEW."last_ip";
|
|
IF (RowCount != 1) THEN
|
|
RAISE EXCEPTION 'Last address (%) not found in address pool.',NEW."last_ip";
|
|
END IF;
|
|
|
|
-- Define lower boundary for range
|
|
-- Loop through all ranges and find what is near the new range
|
|
FOR query_result IN SELECT "first_ip","last_ip" FROM "ip"."ranges" WHERE "subnet" = NEW."subnet" ORDER BY "last_ip" LOOP
|
|
IF NEW."first_ip" >= query_result.first_ip AND NEW."first_ip" <= query_result.last_ip THEN
|
|
RAISE EXCEPTION 'First address out of bounds.';
|
|
ELSIF NEW."first_ip" > query_result.last_ip THEN
|
|
LowerBound := query_result.last_ip;
|
|
END IF;
|
|
IF NEW."last_ip" >= query_result.first_ip AND NEW."last_ip" <= query_result.last_ip THEN
|
|
RAISE EXCEPTION 'Last address is out of bounds';
|
|
END IF;
|
|
END LOOP;
|
|
|
|
-- Define upper boundry for range
|
|
SELECT "first_ip" INTO UpperBound
|
|
FROM "ip"."ranges"
|
|
WHERE "first_ip" >= LowerBound
|
|
ORDER BY "first_ip" LIMIT 1;
|
|
|
|
-- Check for range spanning
|
|
IF NEW."last_ip" >= UpperBound THEN
|
|
RAISE EXCEPTION 'Last address is out of bounds';
|
|
END IF;
|
|
|
|
-- Done
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION ip.ranges_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION ranges_insert(); Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION ip.ranges_insert() IS 'Insert a new range of addresses for use';
|
|
|
|
|
|
--
|
|
-- Name: ranges_update(); Type: FUNCTION; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION ip.ranges_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
LowerBound INET;
|
|
UpperBound INET;
|
|
query_result RECORD;
|
|
RowCount INTEGER;
|
|
BEGIN
|
|
IF NEW."first_ip" != OLD."first_ip" OR NEW."last_ip" != OLD."last_ip" THEN
|
|
-- Check for illegal addresses
|
|
IF host(NEW."subnet") = host(NEW."first_ip") THEN
|
|
RAISE EXCEPTION 'You cannot have a boundry that is the network identifier';
|
|
END IF;
|
|
|
|
-- Check address vs subnet
|
|
IF NOT NEW."first_ip" << NEW."subnet" OR NOT NEW."last_ip" << NEW."subnet" THEN
|
|
RAISE EXCEPTION 'Range addresses must be inside the specified subnet';
|
|
END IF;
|
|
|
|
-- Check valid range
|
|
IF NEW."first_ip" >= NEW."last_ip" THEN
|
|
RAISE EXCEPTION 'First address is larger or equal to last address.';
|
|
END IF;
|
|
|
|
-- Check address existance
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."addresses"
|
|
WHERE "ip"."addresses"."address" = NEW."first_ip";
|
|
IF (RowCount != 1) THEN
|
|
RAISE EXCEPTION 'First address (%) not found in address pool.',NEW."first_ip";
|
|
END IF;
|
|
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."addresses"
|
|
WHERE "ip"."addresses"."address" = NEW."last_ip";
|
|
IF (RowCount != 1) THEN
|
|
RAISE EXCEPTION 'Last address (%) not found in address pool.',NEW."last_ip";
|
|
END IF;
|
|
|
|
-- Define lower boundary for range
|
|
-- Loop through all ranges and find what is near the new range
|
|
FOR query_result IN SELECT "first_ip","last_ip" FROM "ip"."ranges" WHERE "subnet" = NEW."subnet" AND "first_ip" != OLD."first_ip" ORDER BY "last_ip" LOOP
|
|
-- Check if the new first_ip is contained within the next lower range
|
|
IF NEW."first_ip" >= query_result.first_ip AND NEW."first_ip" <= query_result.last_ip THEN
|
|
RAISE EXCEPTION 'First address out of bounds.';
|
|
|
|
--Check if the new last_ip is contained with the next lower range
|
|
ELSIF NEW."last_ip" >= query_result.first_ip AND NEW."last_ip" <= query_result.last_ip THEN
|
|
RAISE EXCEPTION 'Last address LOLOLOL is out of bounds';
|
|
ELSIF NEW."first_ip" > query_result.last_ip THEN
|
|
LowerBound := query_result.last_ip;
|
|
END IF;
|
|
|
|
END LOOP;
|
|
|
|
-- Define upper boundry for range
|
|
SELECT "first_ip" INTO UpperBound
|
|
FROM "ip"."ranges"
|
|
WHERE "first_ip" > LowerBound
|
|
AND "name" != NEW."name"
|
|
ORDER BY "first_ip" DESC LIMIT 1;
|
|
|
|
-- Check for range spanning
|
|
IF NEW."last_ip" >= UpperBound THEN
|
|
RAISE EXCEPTION 'Last address HAHAH is out of bounds';
|
|
END IF;
|
|
END IF;
|
|
-- Done
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION ip.ranges_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION ranges_update(); Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION ip.ranges_update() IS 'Alter a range of addresses for use';
|
|
|
|
|
|
--
|
|
-- Name: subnets_delete(); Type: FUNCTION; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION ip.subnets_delete() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
BEGIN
|
|
-- Check for inuse addresses
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."addresses"
|
|
WHERE EXISTS (
|
|
SELECT "address"
|
|
FROM "systems"."interface_addresses"
|
|
WHERE "systems"."interface_addresses"."address" = "ip"."addresses"."address" )
|
|
AND "ip"."addresses"."address" << OLD."subnet";
|
|
IF (RowCount >= 1) THEN
|
|
RAISE EXCEPTION 'Inuse addresses found. Aborting delete.';
|
|
END IF;
|
|
|
|
-- Delete autogenerated addresses
|
|
IF OLD."autogen" = TRUE THEN
|
|
DELETE FROM "ip"."addresses" WHERE "address" << OLD."subnet";
|
|
END IF;
|
|
|
|
-- Done
|
|
RETURN OLD;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION ip.subnets_delete() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION subnets_delete(); Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION ip.subnets_delete() IS 'You can only delete a subnet if no addresses from it are inuse.';
|
|
|
|
|
|
--
|
|
-- Name: subnets_insert(); Type: FUNCTION; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION ip.subnets_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
SubnetAddresses RECORD;
|
|
BEGIN
|
|
-- Check for larger subnets
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."subnets"
|
|
WHERE NEW."subnet" << "ip"."subnets"."subnet";
|
|
IF (RowCount > 1) THEN
|
|
RAISE EXCEPTION 'A larger existing subnet was detected. Nested subnets are not supported.';
|
|
END IF;
|
|
|
|
-- Check for smaller subnets
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."subnets"
|
|
WHERE NEW."subnet" >> "ip"."subnets"."subnet";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'A smaller existing subnet was detected. Nested subnets are not supported.';
|
|
END IF;
|
|
|
|
-- Check for existing addresses
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."addresses"
|
|
WHERE "ip"."addresses"."address" << NEW."subnet";
|
|
IF RowCount >= 1 THEN
|
|
RAISE EXCEPTION 'Existing addresses detected for your subnet. Modify the existing subnet.';
|
|
END IF;
|
|
|
|
-- Autogenerate addresses & firewall default
|
|
IF NEW."autogen" IS TRUE THEN
|
|
FOR SubnetAddresses IN SELECT api.get_subnet_addresses(NEW."subnet") LOOP
|
|
INSERT INTO "ip"."addresses" ("address") VALUES (SubnetAddresses.get_subnet_addresses);
|
|
END LOOP;
|
|
END IF;
|
|
|
|
-- Done
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION ip.subnets_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION subnets_insert(); Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION ip.subnets_insert() IS 'Create a subnet';
|
|
|
|
|
|
--
|
|
-- Name: subnets_update(); Type: FUNCTION; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION ip.subnets_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
SubnetAddresses RECORD;
|
|
BEGIN
|
|
IF NEW."subnet" != OLD."subnet" THEN
|
|
-- Check for larger subnets
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."subnets"
|
|
WHERE NEW."subnet" << "ip"."subnets"."subnet";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'A larger existing subnet was detected. Nested subnets are not supported.';
|
|
END IF;
|
|
|
|
-- Check for smaller subnets
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."subnets"
|
|
WHERE NEW."subnet" >> "ip"."subnets"."subnet"
|
|
AND OLD."subnet" <> "ip"."subnets"."subnet";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'A smaller existing subnet was detected. Nested subnets are not supported.';
|
|
END IF;
|
|
|
|
-- Check for existing addresses
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."addresses"
|
|
WHERE "ip"."addresses"."address" << NEW."subnet";
|
|
IF RowCount >= 1 THEN
|
|
RAISE EXCEPTION 'Existing addresses detected for your subnet. Modify the existing subnet.';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Autogenerate addresses
|
|
IF NEW."autogen" != OLD."autogen" THEN
|
|
IF NEW."autogen" IS TRUE THEN
|
|
DELETE FROM "ip"."addresses" WHERE "ip"."addresses"."address" << OLD."subnet";
|
|
FOR SubnetAddresses IN SELECT api.get_subnet_addresses(NEW."subnet") LOOP
|
|
INSERT INTO "ip"."addresses" ("address") VALUES (SubnetAddresses.get_subnet_addresses);
|
|
END LOOP;
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Done
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION ip.subnets_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION subnets_update(); Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION ip.subnets_update() IS 'Modify an existing new subnet';
|
|
|
|
|
|
--
|
|
-- Name: switchport_states_update(); Type: FUNCTION; Schema: network; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION network.switchport_states_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
BEGIN
|
|
IF NEW."admin_state" != OLD."admin_state" THEN
|
|
PERFORM api.modify_network_switchport_admin_state(api.get_system_primary_address(NEW."system_name"),NEW."port_name",(SELECT "snmp_rw_community" FROM "network"."switchview" WHERE "system_name" = NEW."system_name"),NEW."admin_state");
|
|
END IF;
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION network.switchport_states_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: switchports_insert(); Type: FUNCTION; Schema: network; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION network.switchports_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
DeviceType TEXT;
|
|
BEGIN
|
|
-- Check for system types
|
|
SELECT "type" INTO DeviceType
|
|
FROM "systems"."systems"
|
|
WHERE "systems"."systems"."system_name" = NEW."system_name";
|
|
IF DeviceType !~* 'Router|Switch|Hub|Wireless Access Point' THEN
|
|
RAISE EXCEPTION 'Cannot create a switchport on non-network device type (%)',DeviceType;
|
|
END IF;
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION network.switchports_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION switchports_insert(); Type: COMMENT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION network.switchports_insert() IS 'verifications for network switchports';
|
|
|
|
|
|
--
|
|
-- Name: switchports_update(); Type: FUNCTION; Schema: network; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION network.switchports_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
DeviceType TEXT;
|
|
BEGIN
|
|
-- Check for system types
|
|
IF NEW."system_name" != OLD."system_name" THEN
|
|
SELECT "type" INTO DeviceType
|
|
FROM "systems"."systems"
|
|
WHERE "systems"."systems"."system_name" = NEW."system_name";
|
|
IF DeviceType !~* 'Router|Switch|Hub|Wireless Access Point' THEN
|
|
RAISE EXCEPTION 'Cannot create a switchport on non-network device type %',DeviceType;
|
|
END IF;
|
|
END IF;
|
|
|
|
IF NEW."description" != OLD."description" THEN
|
|
PERFORM api.modify_network_switchport_description(api.get_system_primary_address(NEW."system_name"),NEW."port_name",(SELECT "snmp_rw_community" FROM "network"."switchview" WHERE "system_name" = NEW."system_name"),NEW."description");
|
|
END IF;
|
|
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION network.switchports_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION switchports_update(); Type: COMMENT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION network.switchports_update() IS 'verifications for network switchports';
|
|
|
|
|
|
--
|
|
-- Name: interface_addresses_insert(); Type: FUNCTION; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION systems.interface_addresses_insert() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $$ DECLARE
|
|
RowCount INTEGER;
|
|
ConfigFamily INTEGER;
|
|
PrimaryName TEXT;
|
|
Owner TEXT;
|
|
BEGIN
|
|
-- Set address family
|
|
NEW."family" := family(NEW."address");
|
|
|
|
-- Check if address is within a subnet
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."subnets"
|
|
WHERE NEW."address" << "ip"."subnets"."subnet";
|
|
IF (RowCount < 1) THEN
|
|
RAISE EXCEPTION 'IP address (%) must be within a managed subnet.',NEW."address";
|
|
END IF;
|
|
|
|
-- Check if primary address exists (it shouldnt)
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "systems"."interface_addresses"
|
|
WHERE "systems"."interface_addresses"."isprimary" = TRUE
|
|
AND "systems"."interface_addresses"."family" = NEW."family"
|
|
AND "systems"."interface_addresses"."mac" = NEW."mac";
|
|
IF NEW."isprimary" IS TRUE AND RowCount > 0 THEN
|
|
-- There is a primary address already registered and this was supposed to be one.
|
|
RAISE EXCEPTION 'Primary address for this interface and family already exists';
|
|
ELSIF NEW."isprimary" IS FALSE AND RowCount = 0 THEN
|
|
-- There is no primary and this is set to not be one.
|
|
RAISE EXCEPTION 'No primary address exists for this interface (%) and family (%).',NEW."mac",NEW."family";
|
|
END IF;
|
|
|
|
-- Check for one DHCPable address per MAC
|
|
IF NEW."config" !~* 'static' THEN
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "systems"."interface_addresses"
|
|
WHERE "systems"."interface_addresses"."family" = NEW."family"
|
|
AND "systems"."interface_addresses"."config" ~* 'dhcp'
|
|
AND "systems"."interface_addresses"."mac" = NEW."mac";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Only one DHCP/Autoconfig-able address per MAC (%) is allowed',NEW."mac";
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check address family against config type
|
|
IF NEW."config" !~* 'static' THEN
|
|
SELECT "family" INTO ConfigFamily
|
|
FROM "dhcp"."config_types"
|
|
WHERE "dhcp"."config_types"."config" = NEW."config";
|
|
IF NEW."family" != ConfigFamily THEN
|
|
RAISE EXCEPTION 'Invalid configuration type selected (%) for your address family (%)',NEW."config",NEW."family";
|
|
END IF;
|
|
END IF;
|
|
|
|
-- IPv6 Autoconfiguration
|
|
IF NEW."family" = 6 AND NEW."config" ~* 'dhcpv6|static' THEN
|
|
SELECT "systems"."systems"."owner" INTO Owner
|
|
FROM "systems"."interfaces"
|
|
JOIN "systems"."systems" ON
|
|
"systems"."systems"."system_name" = "systems"."interfaces"."system_name"
|
|
WHERE "systems"."interfaces"."mac" = NEW."mac";
|
|
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."addresses"
|
|
WHERE "ip"."addresses"."address" = NEW."address";
|
|
IF (RowCount = 0) THEN
|
|
INSERT INTO "ip"."addresses" ("address","owner") VALUES (NEW."address",Owner);
|
|
END IF;
|
|
|
|
END IF;
|
|
|
|
RETURN NEW;
|
|
END;
|
|
$$;
|
|
|
|
|
|
ALTER FUNCTION systems.interface_addresses_insert() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION interface_addresses_insert(); Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION systems.interface_addresses_insert() IS 'Create a new address based on a very complex ruleset';
|
|
|
|
|
|
--
|
|
-- Name: interface_addresses_update(); Type: FUNCTION; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE FUNCTION systems.interface_addresses_update() RETURNS trigger
|
|
LANGUAGE plpgsql
|
|
AS $_$
|
|
DECLARE
|
|
RowCount INTEGER;
|
|
ConfigFamily INTEGER;
|
|
PrimaryName TEXT;
|
|
Owner TEXT;
|
|
BEGIN
|
|
IF NEW."address" != OLD."address" THEN
|
|
-- Set family
|
|
NEW."family" := family(NEW."address");
|
|
|
|
-- Check if IP is within our controlled subnets
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."subnets"
|
|
WHERE NEW."address" << "ip"."subnets"."subnet";
|
|
IF (RowCount < 1) THEN
|
|
RAISE EXCEPTION 'IP address (%) must be within a managed subnet.',NEW."address";
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check if primary for the family already exists. It shouldnt.
|
|
IF NEW."isprimary" != OLD."isprimary" THEN
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "systems"."interface_addresses"
|
|
WHERE "systems"."interface_addresses"."isprimary" = TRUE
|
|
AND "systems"."interface_addresses"."family" = NEW."family"
|
|
AND "systems"."interface_addresses"."mac" = NEW."mac";
|
|
IF NEW."isprimary" IS TRUE AND RowCount > 0 THEN
|
|
-- There is a primary address already registered and this was supposed to be one.
|
|
RAISE EXCEPTION 'Primary address for this interface and family already exists';
|
|
ELSIF NEW."isprimary" IS FALSE AND RowCount = 0 THEN
|
|
-- There is no primary and this is set to not be one.
|
|
RAISE EXCEPTION 'No primary address exists for this interface and family and this will not be one.';
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check for only one DHCPable address per MAC address
|
|
IF NEW."config" != OLD."config" THEN
|
|
IF NEW."config" ~* '^dhcp$' THEN
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "systems"."interface_addresses"
|
|
WHERE "systems"."interface_addresses"."family" = NEW."family"
|
|
AND "systems"."interface_addresses"."config" ~* 'dhcp'
|
|
AND "systems"."interface_addresses"."mac" = NEW."mac";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Only one DHCP/Autoconfig-able address per MAC (%) is allowed',NEW."mac";
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check address family against config type
|
|
IF NEW."config" !~* 'static' THEN
|
|
SELECT "family" INTO ConfigFamily
|
|
FROM "dhcp"."config_types"
|
|
WHERE "dhcp"."config_types"."config" = NEW."config";
|
|
IF NEW."family" != ConfigFamily THEN
|
|
RAISE EXCEPTION 'Invalid configuration type selected (%) for your address family (%)',NEW."config",NEW."family";
|
|
END IF;
|
|
END IF;
|
|
|
|
-- IPv6 Autoconfiguration
|
|
IF NEW."family" = 6 AND NEW."config" ~* 'autoconf' THEN
|
|
SELECT COUNT(*) INTO RowCount
|
|
FROM "ip"."addresses"
|
|
WHERE "ip"."addresses"."address" = NEW."address";
|
|
IF (RowCount > 0) THEN
|
|
RAISE EXCEPTION 'Existing address (%) detected. Cannot continue.',NEW."address";
|
|
END IF;
|
|
|
|
SELECT "systems"."systems"."owner" INTO Owner
|
|
FROM "systems"."interfaces"
|
|
JOIN "systems"."systems" ON
|
|
"systems"."systems"."system_name" = "systems"."interfaces"."system_name"
|
|
WHERE "systems"."interfaces"."mac" = NEW."mac";
|
|
|
|
INSERT INTO "ip"."addresses" ("address","owner") VALUES (NEW."address",Owner);
|
|
END IF;
|
|
|
|
-- Remove old autoconf addresses
|
|
IF OLD."config" ~* 'autoconf' THEN
|
|
DELETE FROM "ip"."addresses" WHERE "address" = OLD."address";
|
|
END IF;
|
|
END IF;
|
|
|
|
-- Check for IPv6 secondary name
|
|
/*
|
|
IF NEW."family" = 6 AND NEW."isprimary" = FALSE THEN
|
|
SELECT "name" INTO PrimaryName
|
|
FROM "systems"."interface_addresses"
|
|
WHERE "systems"."interface_addresses"."mac" = NEW."mac"
|
|
AND "systems"."interface_addresses"."isprimary" = TRUE;
|
|
IF NEW."name" != PrimaryName THEN
|
|
RAISE EXCEPTION 'IPv6 secondaries must have the same interface name (%) as the primary (%)',NEW."name",PrimaryName;
|
|
END IF;
|
|
END IF;
|
|
*/
|
|
RETURN NEW;
|
|
END;
|
|
$_$;
|
|
|
|
|
|
ALTER FUNCTION systems.interface_addresses_update() OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: FUNCTION interface_addresses_update(); Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON FUNCTION systems.interface_addresses_update() IS 'Modify an existing address based on a very complex ruleset';
|
|
|
|
|
|
--
|
|
-- Name: types; Type: TABLE; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE dns.types (
|
|
type text NOT NULL,
|
|
comment text,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE dns.types OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE types; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE dns.types IS 'All DNS record types';
|
|
|
|
|
|
--
|
|
-- Name: addresses; Type: TABLE; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE ip.addresses (
|
|
address inet NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL,
|
|
owner text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE ip.addresses OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE addresses; Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE ip.addresses IS 'Master list of all controlled addresses in the application';
|
|
|
|
|
|
--
|
|
-- Name: range_uses; Type: TABLE; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE ip.range_uses (
|
|
use character varying(4) NOT NULL,
|
|
comment text,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE ip.range_uses OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE range_uses; Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE ip.range_uses IS 'Ranges are intended for a specific purpose.';
|
|
|
|
|
|
--
|
|
-- Name: log_master; Type: TABLE; Schema: management; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE management.log_master (
|
|
"timestamp" timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
"user" text NOT NULL,
|
|
message text NOT NULL,
|
|
source text NOT NULL,
|
|
severity text NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE management.log_master OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE log_master; Type: COMMENT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE management.log_master IS 'Record every single transaction that occurs in this application.';
|
|
|
|
|
|
--
|
|
-- Name: output_id_seq; Type: SEQUENCE; Schema: management; Owner: starrs
|
|
--
|
|
|
|
CREATE SEQUENCE management.output_id_seq
|
|
START WITH 1
|
|
INCREMENT BY 1
|
|
NO MINVALUE
|
|
NO MAXVALUE
|
|
CACHE 1;
|
|
|
|
|
|
ALTER TABLE management.output_id_seq OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: SEQUENCE output_id_seq; Type: COMMENT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON SEQUENCE management.output_id_seq IS 'Identifier for all output results';
|
|
|
|
|
|
--
|
|
-- Name: output; Type: TABLE; Schema: management; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE management.output (
|
|
output_id integer DEFAULT nextval('management.output_id_seq'::regclass) NOT NULL,
|
|
value text,
|
|
file text,
|
|
"timestamp" timestamp without time zone NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE management.output OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE output; Type: COMMENT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE management.output IS 'Destination of the output functions rather than write a file to disk.';
|
|
|
|
|
|
--
|
|
-- Name: snmp3; Type: TABLE; Schema: network; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE network.snmp3 (
|
|
system_name text NOT NULL,
|
|
"user" text NOT NULL,
|
|
auth_encryption text DEFAULT 'md5'::text NOT NULL,
|
|
password text NOT NULL,
|
|
priv_encryption text DEFAULT 'aes'::text NOT NULL,
|
|
priv_password text NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE network.snmp3 OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE snmp3; Type: COMMENT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE network.snmp3 IS 'SNMPv3 credentials for network hosts';
|
|
|
|
|
|
--
|
|
-- Name: os; Type: TABLE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE systems.os (
|
|
name text NOT NULL,
|
|
family text,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE systems.os OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE os; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE systems.os IS 'Track what primary operating systems are in use on the network.';
|
|
|
|
|
|
--
|
|
-- Name: os_family; Type: TABLE; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TABLE systems.os_family (
|
|
family text NOT NULL,
|
|
date_created timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
date_modified timestamp without time zone DEFAULT ('now'::text)::timestamp(0) without time zone NOT NULL,
|
|
last_modifier text DEFAULT api.get_current_user() NOT NULL
|
|
);
|
|
|
|
|
|
ALTER TABLE systems.os_family OWNER TO starrs;
|
|
|
|
--
|
|
-- Name: TABLE os_family; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON TABLE systems.os_family IS 'General classification for operating systems.';
|
|
|
|
|
|
--
|
|
-- Name: class_options class_options_class_option_value_key; Type: CONSTRAINT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dhcp.class_options
|
|
ADD CONSTRAINT class_options_class_option_value_key UNIQUE (option, value, class);
|
|
|
|
|
|
--
|
|
-- Name: CONSTRAINT class_options_class_option_value_key ON class_options; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON CONSTRAINT class_options_class_option_value_key ON dhcp.class_options IS 'No two directives can be the same';
|
|
|
|
|
|
--
|
|
-- Name: class_options class_options_pkey; Type: CONSTRAINT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dhcp.class_options
|
|
ADD CONSTRAINT class_options_pkey PRIMARY KEY (option, value, class);
|
|
|
|
|
|
--
|
|
-- Name: classes classes_pkey; Type: CONSTRAINT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dhcp.classes
|
|
ADD CONSTRAINT classes_pkey PRIMARY KEY (class);
|
|
|
|
|
|
--
|
|
-- Name: config_types config_types_pkey; Type: CONSTRAINT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dhcp.config_types
|
|
ADD CONSTRAINT config_types_pkey PRIMARY KEY (config);
|
|
|
|
|
|
--
|
|
-- Name: global_options global_options_pkey; Type: CONSTRAINT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dhcp.global_options
|
|
ADD CONSTRAINT global_options_pkey PRIMARY KEY (option);
|
|
|
|
|
|
--
|
|
-- Name: range_options range_options_pkey; Type: CONSTRAINT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dhcp.range_options
|
|
ADD CONSTRAINT range_options_pkey PRIMARY KEY (name, option);
|
|
|
|
|
|
--
|
|
-- Name: subnet_options subnet_option_subnet_option_value_key; Type: CONSTRAINT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dhcp.subnet_options
|
|
ADD CONSTRAINT subnet_option_subnet_option_value_key UNIQUE (option, value, subnet);
|
|
|
|
|
|
--
|
|
-- Name: CONSTRAINT subnet_option_subnet_option_value_key ON subnet_options; Type: COMMENT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON CONSTRAINT subnet_option_subnet_option_value_key ON dhcp.subnet_options IS 'No two directives can be the same';
|
|
|
|
|
|
--
|
|
-- Name: subnet_options subnet_options_pkey; Type: CONSTRAINT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dhcp.subnet_options
|
|
ADD CONSTRAINT subnet_options_pkey PRIMARY KEY (option, value, subnet);
|
|
|
|
|
|
--
|
|
-- Name: a a_address_zone_key; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.a
|
|
ADD CONSTRAINT a_address_zone_key UNIQUE (address, zone);
|
|
|
|
|
|
--
|
|
-- Name: CONSTRAINT a_address_zone_key ON a; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON CONSTRAINT a_address_zone_key ON dns.a IS 'Addresses in this table must be unique';
|
|
|
|
|
|
--
|
|
-- Name: a a_hostname_zone_type_key; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.a
|
|
ADD CONSTRAINT a_hostname_zone_type_key UNIQUE (hostname, type, zone);
|
|
|
|
|
|
--
|
|
-- Name: CONSTRAINT a_hostname_zone_type_key ON a; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON CONSTRAINT a_hostname_zone_type_key ON dns.a IS 'Can only have 1 of each A or AAAA';
|
|
|
|
|
|
--
|
|
-- Name: a a_pkey; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.a
|
|
ADD CONSTRAINT a_pkey PRIMARY KEY (hostname, address, zone);
|
|
|
|
|
|
--
|
|
-- Name: cname cname_alias_zone_key; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.cname
|
|
ADD CONSTRAINT cname_alias_zone_key UNIQUE (alias, zone);
|
|
|
|
|
|
--
|
|
-- Name: CONSTRAINT cname_alias_zone_key ON cname; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON CONSTRAINT cname_alias_zone_key ON dns.cname IS 'Cannot have two of the same alises in the same zone';
|
|
|
|
|
|
--
|
|
-- Name: cname cname_pkey; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.cname
|
|
ADD CONSTRAINT cname_pkey PRIMARY KEY (alias, hostname, address, zone);
|
|
|
|
|
|
--
|
|
-- Name: mx dns_mx_preference_zone_key; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.mx
|
|
ADD CONSTRAINT dns_mx_preference_zone_key UNIQUE (preference, zone);
|
|
|
|
|
|
--
|
|
-- Name: CONSTRAINT dns_mx_preference_zone_key ON mx; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON CONSTRAINT dns_mx_preference_zone_key ON dns.mx IS 'No two MX servers can have the same preference in a domain';
|
|
|
|
|
|
--
|
|
-- Name: txt dns_txt_hostname_zone_text_key; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.txt
|
|
ADD CONSTRAINT dns_txt_hostname_zone_text_key UNIQUE (hostname, zone, text);
|
|
|
|
|
|
--
|
|
-- Name: CONSTRAINT dns_txt_hostname_zone_text_key ON txt; Type: COMMENT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON CONSTRAINT dns_txt_hostname_zone_text_key ON dns.txt IS 'No duplicate TXT records';
|
|
|
|
|
|
--
|
|
-- Name: zone_a dns_zone_a_pkey; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.zone_a
|
|
ADD CONSTRAINT dns_zone_a_pkey PRIMARY KEY (zone, type);
|
|
|
|
|
|
--
|
|
-- Name: keys keys_pkey; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.keys
|
|
ADD CONSTRAINT keys_pkey PRIMARY KEY (keyname);
|
|
|
|
|
|
--
|
|
-- Name: mx mx_pkey; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.mx
|
|
ADD CONSTRAINT mx_pkey PRIMARY KEY (hostname, address, zone);
|
|
|
|
|
|
--
|
|
-- Name: ns ns_pkey; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.ns
|
|
ADD CONSTRAINT ns_pkey PRIMARY KEY (zone, nameserver);
|
|
|
|
|
|
--
|
|
-- Name: soa soa_pkey; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.soa
|
|
ADD CONSTRAINT soa_pkey PRIMARY KEY (zone);
|
|
|
|
|
|
--
|
|
-- Name: srv srv_pkey; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.srv
|
|
ADD CONSTRAINT srv_pkey PRIMARY KEY (alias, hostname, address, zone, priority, weight, port);
|
|
|
|
|
|
--
|
|
-- Name: txt txt_pkey; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.txt
|
|
ADD CONSTRAINT txt_pkey PRIMARY KEY (text, hostname, address, zone);
|
|
|
|
|
|
--
|
|
-- Name: types types_pkey; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.types
|
|
ADD CONSTRAINT types_pkey PRIMARY KEY (type);
|
|
|
|
|
|
--
|
|
-- Name: zone_txt zone_txt_hostname_zone_text_key; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.zone_txt
|
|
ADD CONSTRAINT zone_txt_hostname_zone_text_key UNIQUE (hostname, zone, text);
|
|
|
|
|
|
--
|
|
-- Name: zones zones_pkey; Type: CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.zones
|
|
ADD CONSTRAINT zones_pkey PRIMARY KEY (zone);
|
|
|
|
|
|
--
|
|
-- Name: addresses addresses_pkey; Type: CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.addresses
|
|
ADD CONSTRAINT addresses_pkey PRIMARY KEY (address);
|
|
|
|
|
|
--
|
|
-- Name: range_groups ip_range_group_pkey; Type: CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.range_groups
|
|
ADD CONSTRAINT ip_range_group_pkey PRIMARY KEY (range_name, group_name);
|
|
|
|
|
|
--
|
|
-- Name: range_uses range_uses_pkey; Type: CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.range_uses
|
|
ADD CONSTRAINT range_uses_pkey PRIMARY KEY (use);
|
|
|
|
|
|
--
|
|
-- Name: ranges ranges_first_ip_key; Type: CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.ranges
|
|
ADD CONSTRAINT ranges_first_ip_key UNIQUE (first_ip);
|
|
|
|
|
|
--
|
|
-- Name: CONSTRAINT ranges_first_ip_key ON ranges; Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON CONSTRAINT ranges_first_ip_key ON ip.ranges IS 'Unique starting IP''s';
|
|
|
|
|
|
--
|
|
-- Name: ranges ranges_last_ip_key; Type: CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.ranges
|
|
ADD CONSTRAINT ranges_last_ip_key UNIQUE (last_ip);
|
|
|
|
|
|
--
|
|
-- Name: CONSTRAINT ranges_last_ip_key ON ranges; Type: COMMENT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON CONSTRAINT ranges_last_ip_key ON ip.ranges IS 'Unique ending IP''s';
|
|
|
|
|
|
--
|
|
-- Name: ranges ranges_pkey; Type: CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.ranges
|
|
ADD CONSTRAINT ranges_pkey PRIMARY KEY (name);
|
|
|
|
|
|
--
|
|
-- Name: subnets subnets_pkey; Type: CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.subnets
|
|
ADD CONSTRAINT subnets_pkey PRIMARY KEY (subnet);
|
|
|
|
|
|
--
|
|
-- Name: hosts libvirt_hosts_pkey; Type: CONSTRAINT; Schema: libvirt; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY libvirt.hosts
|
|
ADD CONSTRAINT libvirt_hosts_pkey PRIMARY KEY (system_name);
|
|
|
|
|
|
--
|
|
-- Name: platforms libvirt_platforms_name_pkey; Type: CONSTRAINT; Schema: libvirt; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY libvirt.platforms
|
|
ADD CONSTRAINT libvirt_platforms_name_pkey PRIMARY KEY (platform_name);
|
|
|
|
|
|
--
|
|
-- Name: configuration configuration_pkey; Type: CONSTRAINT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY management.configuration
|
|
ADD CONSTRAINT configuration_pkey PRIMARY KEY (option);
|
|
|
|
|
|
--
|
|
-- Name: group_settings group_settings_pkey; Type: CONSTRAINT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY management.group_settings
|
|
ADD CONSTRAINT group_settings_pkey PRIMARY KEY ("group");
|
|
|
|
|
|
--
|
|
-- Name: group_members management_group_members_pkey; Type: CONSTRAINT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY management.group_members
|
|
ADD CONSTRAINT management_group_members_pkey PRIMARY KEY ("group", "user");
|
|
|
|
|
|
--
|
|
-- Name: groups management_groups_pkey; Type: CONSTRAINT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY management.groups
|
|
ADD CONSTRAINT management_groups_pkey PRIMARY KEY ("group");
|
|
|
|
|
|
--
|
|
-- Name: output output_pkey; Type: CONSTRAINT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY management.output
|
|
ADD CONSTRAINT output_pkey PRIMARY KEY (output_id);
|
|
|
|
|
|
--
|
|
-- Name: snmp3 network_snmp3_pkey; Type: CONSTRAINT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY network.snmp3
|
|
ADD CONSTRAINT network_snmp3_pkey PRIMARY KEY (system_name);
|
|
|
|
|
|
--
|
|
-- Name: snmp network_snmp_pkey; Type: CONSTRAINT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY network.snmp
|
|
ADD CONSTRAINT network_snmp_pkey PRIMARY KEY (system_name);
|
|
|
|
|
|
--
|
|
-- Name: vlans network_vlans_pkey; Type: CONSTRAINT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY network.vlans
|
|
ADD CONSTRAINT network_vlans_pkey PRIMARY KEY (datacenter, vlan);
|
|
|
|
|
|
--
|
|
-- Name: device_types device_types_pkey; Type: CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.device_types
|
|
ADD CONSTRAINT device_types_pkey PRIMARY KEY (type);
|
|
|
|
|
|
--
|
|
-- Name: interface_addresses interface_addresses_pkey; Type: CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.interface_addresses
|
|
ADD CONSTRAINT interface_addresses_pkey PRIMARY KEY (address);
|
|
|
|
|
|
--
|
|
-- Name: interfaces interfaces_pkey; Type: CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.interfaces
|
|
ADD CONSTRAINT interfaces_pkey PRIMARY KEY (mac);
|
|
|
|
|
|
--
|
|
-- Name: interfaces interfaces_system_name_name_key; Type: CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.interfaces
|
|
ADD CONSTRAINT interfaces_system_name_name_key UNIQUE (system_name, name);
|
|
|
|
|
|
--
|
|
-- Name: CONSTRAINT interfaces_system_name_name_key ON interfaces; Type: COMMENT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
COMMENT ON CONSTRAINT interfaces_system_name_name_key ON systems.interfaces IS 'Inteface names must be unique on a system';
|
|
|
|
|
|
--
|
|
-- Name: os_family os_family_pkey; Type: CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.os_family
|
|
ADD CONSTRAINT os_family_pkey PRIMARY KEY (family);
|
|
|
|
|
|
--
|
|
-- Name: os os_pkey; Type: CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.os
|
|
ADD CONSTRAINT os_pkey PRIMARY KEY (name);
|
|
|
|
|
|
--
|
|
-- Name: architectures systems_architecture_pkey; Type: CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.architectures
|
|
ADD CONSTRAINT systems_architecture_pkey PRIMARY KEY (architecture);
|
|
|
|
|
|
--
|
|
-- Name: availability_zones systems_az_pkey; Type: CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.availability_zones
|
|
ADD CONSTRAINT systems_az_pkey PRIMARY KEY (datacenter, zone);
|
|
|
|
|
|
--
|
|
-- Name: datacenters systems_datacenter_pkey; Type: CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.datacenters
|
|
ADD CONSTRAINT systems_datacenter_pkey PRIMARY KEY (datacenter);
|
|
|
|
|
|
--
|
|
-- Name: systems systems_pkey; Type: CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.systems
|
|
ADD CONSTRAINT systems_pkey PRIMARY KEY (system_name);
|
|
|
|
|
|
--
|
|
-- Name: platforms systems_platforms_pkey; Type: CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.platforms
|
|
ADD CONSTRAINT systems_platforms_pkey PRIMARY KEY (platform_name);
|
|
|
|
|
|
--
|
|
-- Name: a dns_a_delete_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_a_delete_queue AFTER DELETE ON dns.a FOR EACH ROW EXECUTE FUNCTION dns.queue_delete();
|
|
|
|
|
|
--
|
|
-- Name: a dns_a_insert; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_a_insert BEFORE INSERT ON dns.a FOR EACH ROW EXECUTE FUNCTION dns.a_insert();
|
|
|
|
|
|
--
|
|
-- Name: a dns_a_insert_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_a_insert_queue AFTER INSERT ON dns.a FOR EACH ROW EXECUTE FUNCTION dns.queue_insert();
|
|
|
|
|
|
--
|
|
-- Name: a dns_a_update; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_a_update BEFORE UPDATE ON dns.a FOR EACH ROW EXECUTE FUNCTION dns.a_update();
|
|
|
|
|
|
--
|
|
-- Name: a dns_a_update_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_a_update_queue AFTER UPDATE ON dns.a FOR EACH ROW EXECUTE FUNCTION dns.queue_update();
|
|
|
|
|
|
--
|
|
-- Name: cname dns_cname_delete_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_cname_delete_queue AFTER DELETE ON dns.cname FOR EACH ROW EXECUTE FUNCTION dns.queue_delete();
|
|
|
|
|
|
--
|
|
-- Name: cname dns_cname_insert; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_cname_insert BEFORE INSERT ON dns.cname FOR EACH ROW EXECUTE FUNCTION dns.cname_insert();
|
|
|
|
|
|
--
|
|
-- Name: cname dns_cname_insert_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_cname_insert_queue AFTER INSERT ON dns.cname FOR EACH ROW EXECUTE FUNCTION dns.queue_insert();
|
|
|
|
|
|
--
|
|
-- Name: cname dns_cname_update; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_cname_update BEFORE UPDATE ON dns.cname FOR EACH ROW EXECUTE FUNCTION dns.cname_update();
|
|
|
|
|
|
--
|
|
-- Name: cname dns_cname_update_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_cname_update_queue AFTER UPDATE ON dns.cname FOR EACH ROW EXECUTE FUNCTION dns.queue_update();
|
|
|
|
|
|
--
|
|
-- Name: mx dns_mx_delete_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_mx_delete_queue AFTER DELETE ON dns.mx FOR EACH ROW EXECUTE FUNCTION dns.queue_delete();
|
|
|
|
|
|
--
|
|
-- Name: mx dns_mx_insert; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_mx_insert BEFORE INSERT ON dns.mx FOR EACH ROW EXECUTE FUNCTION dns.mx_insert();
|
|
|
|
|
|
--
|
|
-- Name: mx dns_mx_insert_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_mx_insert_queue AFTER INSERT ON dns.mx FOR EACH ROW EXECUTE FUNCTION dns.queue_insert();
|
|
|
|
|
|
--
|
|
-- Name: mx dns_mx_update; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_mx_update BEFORE UPDATE ON dns.mx FOR EACH ROW EXECUTE FUNCTION dns.mx_update();
|
|
|
|
|
|
--
|
|
-- Name: mx dns_mx_update_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_mx_update_queue AFTER UPDATE ON dns.mx FOR EACH ROW EXECUTE FUNCTION dns.queue_update();
|
|
|
|
|
|
--
|
|
-- Name: ns dns_ns_delete_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_ns_delete_queue AFTER DELETE ON dns.ns FOR EACH ROW EXECUTE FUNCTION dns.ns_query_delete();
|
|
|
|
|
|
--
|
|
-- Name: ns dns_ns_insert_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_ns_insert_queue AFTER INSERT ON dns.ns FOR EACH ROW EXECUTE FUNCTION dns.ns_query_insert();
|
|
|
|
|
|
--
|
|
-- Name: ns dns_ns_update_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_ns_update_queue AFTER UPDATE ON dns.ns FOR EACH ROW EXECUTE FUNCTION dns.ns_query_update();
|
|
|
|
|
|
--
|
|
-- Name: srv dns_srv_delete_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_srv_delete_queue AFTER DELETE ON dns.srv FOR EACH ROW EXECUTE FUNCTION dns.queue_delete();
|
|
|
|
|
|
--
|
|
-- Name: srv dns_srv_insert; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_srv_insert BEFORE INSERT ON dns.srv FOR EACH ROW EXECUTE FUNCTION dns.srv_insert();
|
|
|
|
|
|
--
|
|
-- Name: srv dns_srv_insert_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_srv_insert_queue AFTER INSERT ON dns.srv FOR EACH ROW EXECUTE FUNCTION dns.queue_insert();
|
|
|
|
|
|
--
|
|
-- Name: srv dns_srv_update; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_srv_update BEFORE UPDATE ON dns.srv FOR EACH ROW EXECUTE FUNCTION dns.srv_update();
|
|
|
|
|
|
--
|
|
-- Name: srv dns_srv_update_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_srv_update_queue AFTER UPDATE ON dns.srv FOR EACH ROW EXECUTE FUNCTION dns.queue_update();
|
|
|
|
|
|
--
|
|
-- Name: txt dns_txt_delete_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_txt_delete_queue AFTER DELETE ON dns.txt FOR EACH ROW EXECUTE FUNCTION dns.txt_query_delete();
|
|
|
|
|
|
--
|
|
-- Name: txt dns_txt_insert; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_txt_insert BEFORE INSERT ON dns.txt FOR EACH ROW EXECUTE FUNCTION dns.txt_insert();
|
|
|
|
|
|
--
|
|
-- Name: txt dns_txt_insert_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_txt_insert_queue AFTER INSERT ON dns.txt FOR EACH ROW EXECUTE FUNCTION dns.txt_query_insert();
|
|
|
|
|
|
--
|
|
-- Name: txt dns_txt_update; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_txt_update BEFORE UPDATE ON dns.txt FOR EACH ROW EXECUTE FUNCTION dns.txt_update();
|
|
|
|
|
|
--
|
|
-- Name: txt dns_txt_update_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_txt_update_queue AFTER UPDATE ON dns.txt FOR EACH ROW EXECUTE FUNCTION dns.txt_query_update();
|
|
|
|
|
|
--
|
|
-- Name: zone_a dns_zone_a_delete; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_zone_a_delete BEFORE DELETE ON dns.zone_a FOR EACH ROW EXECUTE FUNCTION dns.zone_a_delete();
|
|
|
|
|
|
--
|
|
-- Name: zone_a dns_zone_a_delete_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_zone_a_delete_queue AFTER DELETE ON dns.zone_a FOR EACH ROW EXECUTE FUNCTION dns.queue_delete();
|
|
|
|
|
|
--
|
|
-- Name: zone_a dns_zone_a_insert; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_zone_a_insert BEFORE INSERT ON dns.zone_a FOR EACH ROW EXECUTE FUNCTION dns.zone_a_insert();
|
|
|
|
|
|
--
|
|
-- Name: zone_a dns_zone_a_insert_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_zone_a_insert_queue AFTER INSERT ON dns.zone_a FOR EACH ROW EXECUTE FUNCTION dns.queue_insert();
|
|
|
|
|
|
--
|
|
-- Name: zone_a dns_zone_a_update; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_zone_a_update BEFORE UPDATE ON dns.zone_a FOR EACH ROW EXECUTE FUNCTION dns.zone_a_update();
|
|
|
|
|
|
--
|
|
-- Name: zone_a dns_zone_a_update_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_zone_a_update_queue AFTER UPDATE ON dns.zone_a FOR EACH ROW EXECUTE FUNCTION dns.queue_update();
|
|
|
|
|
|
--
|
|
-- Name: zone_txt dns_zone_txt_delete_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_zone_txt_delete_queue AFTER DELETE ON dns.zone_txt FOR EACH ROW EXECUTE FUNCTION dns.txt_query_delete();
|
|
|
|
|
|
--
|
|
-- Name: zone_txt dns_zone_txt_insert; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_zone_txt_insert BEFORE INSERT ON dns.zone_txt FOR EACH ROW EXECUTE FUNCTION dns.zone_txt_insert();
|
|
|
|
|
|
--
|
|
-- Name: zone_txt dns_zone_txt_insert_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_zone_txt_insert_queue AFTER INSERT ON dns.zone_txt FOR EACH ROW EXECUTE FUNCTION dns.txt_query_insert();
|
|
|
|
|
|
--
|
|
-- Name: zone_txt dns_zone_txt_update; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_zone_txt_update BEFORE UPDATE ON dns.zone_txt FOR EACH ROW EXECUTE FUNCTION dns.zone_txt_update();
|
|
|
|
|
|
--
|
|
-- Name: zone_txt dns_zone_txt_update_queue; Type: TRIGGER; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER dns_zone_txt_update_queue AFTER UPDATE ON dns.zone_txt FOR EACH ROW EXECUTE FUNCTION dns.txt_query_update();
|
|
|
|
|
|
--
|
|
-- Name: addresses ip_addresses_insert; Type: TRIGGER; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER ip_addresses_insert BEFORE INSERT ON ip.addresses FOR EACH ROW EXECUTE FUNCTION ip.addresses_insert();
|
|
|
|
|
|
--
|
|
-- Name: ranges ip_ranges_insert; Type: TRIGGER; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER ip_ranges_insert BEFORE INSERT ON ip.ranges FOR EACH ROW EXECUTE FUNCTION ip.ranges_insert();
|
|
|
|
|
|
--
|
|
-- Name: ranges ip_ranges_update; Type: TRIGGER; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER ip_ranges_update BEFORE UPDATE ON ip.ranges FOR EACH ROW EXECUTE FUNCTION ip.ranges_update();
|
|
|
|
|
|
--
|
|
-- Name: subnets ip_subnets_delete; Type: TRIGGER; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER ip_subnets_delete BEFORE DELETE ON ip.subnets FOR EACH ROW EXECUTE FUNCTION ip.subnets_delete();
|
|
|
|
|
|
--
|
|
-- Name: subnets ip_subnets_insert; Type: TRIGGER; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER ip_subnets_insert BEFORE INSERT ON ip.subnets FOR EACH ROW EXECUTE FUNCTION ip.subnets_insert();
|
|
|
|
|
|
--
|
|
-- Name: subnets ip_subnets_update; Type: TRIGGER; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER ip_subnets_update BEFORE UPDATE ON ip.subnets FOR EACH ROW EXECUTE FUNCTION ip.subnets_update();
|
|
|
|
|
|
--
|
|
-- Name: interface_addresses systems_interface_addresses_insert; Type: TRIGGER; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER systems_interface_addresses_insert BEFORE INSERT ON systems.interface_addresses FOR EACH ROW EXECUTE FUNCTION systems.interface_addresses_insert();
|
|
|
|
|
|
--
|
|
-- Name: interface_addresses systems_interface_addresses_update; Type: TRIGGER; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
CREATE TRIGGER systems_interface_addresses_update BEFORE UPDATE ON systems.interface_addresses FOR EACH ROW EXECUTE FUNCTION systems.interface_addresses_update();
|
|
|
|
|
|
--
|
|
-- Name: class_options fk_dhcp_class_options_class; Type: FK CONSTRAINT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dhcp.class_options
|
|
ADD CONSTRAINT fk_dhcp_class_options_class FOREIGN KEY (class) REFERENCES dhcp.classes(class) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: subnet_options fk_dhcp_subnet_options_subnet; Type: FK CONSTRAINT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dhcp.subnet_options
|
|
ADD CONSTRAINT fk_dhcp_subnet_options_subnet FOREIGN KEY (subnet) REFERENCES ip.subnets(subnet) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: range_options fk_range_options_name; Type: FK CONSTRAINT; Schema: dhcp; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dhcp.range_options
|
|
ADD CONSTRAINT fk_range_options_name FOREIGN KEY (name) REFERENCES ip.ranges(name) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: a fk_a_type; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.a
|
|
ADD CONSTRAINT fk_a_type FOREIGN KEY (type) REFERENCES dns.types(type) ON UPDATE RESTRICT ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: a fk_a_zone; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.a
|
|
ADD CONSTRAINT fk_a_zone FOREIGN KEY (zone) REFERENCES dns.zones(zone) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: cname fk_cname_fqdn; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.cname
|
|
ADD CONSTRAINT fk_cname_fqdn FOREIGN KEY (hostname, address, zone) REFERENCES dns.a(hostname, address, zone) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: a fk_dns_a_address; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.a
|
|
ADD CONSTRAINT fk_dns_a_address FOREIGN KEY (address) REFERENCES systems.interface_addresses(address) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: ns fk_dns_ns_zone; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.ns
|
|
ADD CONSTRAINT fk_dns_ns_zone FOREIGN KEY (zone) REFERENCES dns.zones(zone) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: zone_a fk_dns_zone_a_address; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.zone_a
|
|
ADD CONSTRAINT fk_dns_zone_a_address FOREIGN KEY (address) REFERENCES systems.interface_addresses(address) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: zones fk_dns_zones_keyname; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.zones
|
|
ADD CONSTRAINT fk_dns_zones_keyname FOREIGN KEY (keyname) REFERENCES dns.keys(keyname) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: mx fk_mx_fqdn; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.mx
|
|
ADD CONSTRAINT fk_mx_fqdn FOREIGN KEY (hostname, address, zone) REFERENCES dns.a(hostname, address, zone) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: mx fk_mx_type; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.mx
|
|
ADD CONSTRAINT fk_mx_type FOREIGN KEY (type) REFERENCES dns.types(type) ON UPDATE RESTRICT ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: soa fk_soa_zone; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.soa
|
|
ADD CONSTRAINT fk_soa_zone FOREIGN KEY (zone) REFERENCES dns.zones(zone) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: srv fk_srv_fqdn; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.srv
|
|
ADD CONSTRAINT fk_srv_fqdn FOREIGN KEY (hostname, address, zone) REFERENCES dns.a(hostname, address, zone) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: txt fk_txt_fqdn; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.txt
|
|
ADD CONSTRAINT fk_txt_fqdn FOREIGN KEY (hostname, address, zone) REFERENCES dns.a(hostname, address, zone) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: txt fk_txt_type; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.txt
|
|
ADD CONSTRAINT fk_txt_type FOREIGN KEY (type) REFERENCES dns.types(type) ON UPDATE RESTRICT ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: zone_a fk_zone_a_type; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.zone_a
|
|
ADD CONSTRAINT fk_zone_a_type FOREIGN KEY (type) REFERENCES dns.types(type) ON UPDATE RESTRICT ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: zone_a fk_zone_a_zone; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.zone_a
|
|
ADD CONSTRAINT fk_zone_a_zone FOREIGN KEY (zone) REFERENCES dns.zones(zone) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: zone_txt fk_zone_txt_zone; Type: FK CONSTRAINT; Schema: dns; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY dns.zone_txt
|
|
ADD CONSTRAINT fk_zone_txt_zone FOREIGN KEY (zone) REFERENCES dns.zones(zone) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: ranges fk_ip_ranges_subnet; Type: FK CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.ranges
|
|
ADD CONSTRAINT fk_ip_ranges_subnet FOREIGN KEY (subnet) REFERENCES ip.subnets(subnet) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: ranges fk_ip_ranges_use; Type: FK CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.ranges
|
|
ADD CONSTRAINT fk_ip_ranges_use FOREIGN KEY (use) REFERENCES ip.range_uses(use) ON UPDATE RESTRICT ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: range_groups fk_range_group_name; Type: FK CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.range_groups
|
|
ADD CONSTRAINT fk_range_group_name FOREIGN KEY (group_name) REFERENCES management.groups("group") ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: range_groups fk_range_name; Type: FK CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.range_groups
|
|
ADD CONSTRAINT fk_range_name FOREIGN KEY (range_name) REFERENCES ip.ranges(name) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: ranges fk_range_zone; Type: FK CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.ranges
|
|
ADD CONSTRAINT fk_range_zone FOREIGN KEY (datacenter, zone) REFERENCES systems.availability_zones(datacenter, zone) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: ranges fk_ranges_class; Type: FK CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.ranges
|
|
ADD CONSTRAINT fk_ranges_class FOREIGN KEY (class) REFERENCES dhcp.classes(class) ON UPDATE CASCADE ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: subnets fk_subnet_vlans; Type: FK CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.subnets
|
|
ADD CONSTRAINT fk_subnet_vlans FOREIGN KEY (datacenter, vlan) REFERENCES network.vlans(datacenter, vlan) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: subnets fk_subnets_datacenter; Type: FK CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.subnets
|
|
ADD CONSTRAINT fk_subnets_datacenter FOREIGN KEY (datacenter) REFERENCES systems.datacenters(datacenter) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: subnets fk_subnets_zone; Type: FK CONSTRAINT; Schema: ip; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY ip.subnets
|
|
ADD CONSTRAINT fk_subnets_zone FOREIGN KEY (zone) REFERENCES dns.zones(zone) ON UPDATE CASCADE ON DELETE SET DEFAULT;
|
|
|
|
|
|
--
|
|
-- Name: hosts fk_libvirt_host_name; Type: FK CONSTRAINT; Schema: libvirt; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY libvirt.hosts
|
|
ADD CONSTRAINT fk_libvirt_host_name FOREIGN KEY (system_name) REFERENCES systems.systems(system_name) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: platforms fk_libvirt_platform_name; Type: FK CONSTRAINT; Schema: libvirt; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY libvirt.platforms
|
|
ADD CONSTRAINT fk_libvirt_platform_name FOREIGN KEY (platform_name) REFERENCES systems.platforms(platform_name) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: group_settings fk_group_settings_group; Type: FK CONSTRAINT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY management.group_settings
|
|
ADD CONSTRAINT fk_group_settings_group FOREIGN KEY ("group") REFERENCES management.groups("group") ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: group_members fk_management_group_members; Type: FK CONSTRAINT; Schema: management; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY management.group_members
|
|
ADD CONSTRAINT fk_management_group_members FOREIGN KEY ("group") REFERENCES management.groups("group") ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: vlans fk_network_vlan_datacenter; Type: FK CONSTRAINT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY network.vlans
|
|
ADD CONSTRAINT fk_network_vlan_datacenter FOREIGN KEY (datacenter) REFERENCES systems.datacenters(datacenter) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: snmp fk_snmp_address; Type: FK CONSTRAINT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY network.snmp
|
|
ADD CONSTRAINT fk_snmp_address FOREIGN KEY (address) REFERENCES systems.interface_addresses(address) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: snmp fk_snmp_system_name; Type: FK CONSTRAINT; Schema: network; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY network.snmp
|
|
ADD CONSTRAINT fk_snmp_system_name FOREIGN KEY (system_name) REFERENCES systems.systems(system_name) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: platforms fk_platforms_architectures_arch; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.platforms
|
|
ADD CONSTRAINT fk_platforms_architectures_arch FOREIGN KEY (architecture) REFERENCES systems.architectures(architecture) ON UPDATE CASCADE ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: systems fk_system_group; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.systems
|
|
ADD CONSTRAINT fk_system_group FOREIGN KEY ("group") REFERENCES management.groups("group") ON UPDATE CASCADE ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: availability_zones fk_systems_az_datacenter; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.availability_zones
|
|
ADD CONSTRAINT fk_systems_az_datacenter FOREIGN KEY (datacenter) REFERENCES systems.datacenters(datacenter) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: systems fk_systems_datacenter; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.systems
|
|
ADD CONSTRAINT fk_systems_datacenter FOREIGN KEY (datacenter) REFERENCES systems.datacenters(datacenter) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: interface_addresses fk_systems_interface_address_class; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.interface_addresses
|
|
ADD CONSTRAINT fk_systems_interface_address_class FOREIGN KEY (class) REFERENCES dhcp.classes(class) ON UPDATE CASCADE ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: interface_addresses fk_systems_interface_address_config; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.interface_addresses
|
|
ADD CONSTRAINT fk_systems_interface_address_config FOREIGN KEY (config) REFERENCES dhcp.config_types(config) ON UPDATE RESTRICT ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: interface_addresses fk_systems_interface_addresses_mac; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.interface_addresses
|
|
ADD CONSTRAINT fk_systems_interface_addresses_mac FOREIGN KEY (mac) REFERENCES systems.interfaces(mac) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: interface_addresses fk_systems_interfaces_address; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.interface_addresses
|
|
ADD CONSTRAINT fk_systems_interfaces_address FOREIGN KEY (address) REFERENCES ip.addresses(address) ON UPDATE RESTRICT ON DELETE RESTRICT DEFERRABLE;
|
|
|
|
|
|
--
|
|
-- Name: interfaces fk_systems_interfaces_system_name; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.interfaces
|
|
ADD CONSTRAINT fk_systems_interfaces_system_name FOREIGN KEY (system_name) REFERENCES systems.systems(system_name) ON UPDATE CASCADE ON DELETE CASCADE;
|
|
|
|
|
|
--
|
|
-- Name: os fk_systems_os_family; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.os
|
|
ADD CONSTRAINT fk_systems_os_family FOREIGN KEY (family) REFERENCES systems.os_family(family) ON UPDATE RESTRICT ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: systems fk_systems_platform; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.systems
|
|
ADD CONSTRAINT fk_systems_platform FOREIGN KEY (platform_name) REFERENCES systems.platforms(platform_name) ON UPDATE CASCADE ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: systems fk_systems_systems_os; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.systems
|
|
ADD CONSTRAINT fk_systems_systems_os FOREIGN KEY (os_name) REFERENCES systems.os(name) ON UPDATE RESTRICT ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: systems fk_systems_systems_type; Type: FK CONSTRAINT; Schema: systems; Owner: starrs
|
|
--
|
|
|
|
ALTER TABLE ONLY systems.systems
|
|
ADD CONSTRAINT fk_systems_systems_type FOREIGN KEY (type) REFERENCES systems.device_types(type) ON UPDATE RESTRICT ON DELETE RESTRICT;
|
|
|
|
|
|
--
|
|
-- Name: DATABASE starrs; Type: ACL; Schema: -; Owner: starrs
|
|
--
|
|
|
|
GRANT ALL ON DATABASE starrs TO proxstar;
|
|
|
|
|
|
--
|
|
-- Name: SCHEMA api; Type: ACL; Schema: -; Owner: starrs
|
|
--
|
|
|
|
GRANT USAGE ON SCHEMA api TO proxstar;
|
|
|
|
|
|
--
|
|
-- Name: SCHEMA management; Type: ACL; Schema: -; Owner: starrs
|
|
--
|
|
|
|
GRANT ALL ON SCHEMA management TO proxstar;
|
|
|
|
|
|
--
|
|
-- PostgreSQL database dump complete
|
|
--
|
|
|