HOWTO: paquete avanzado de DNS dinámico para pfSense

Cómo programé el paquete 'dd_adv' para pfSense: un servicio de DNS dinámico que obtiene la IP pública a través de la interfaz que elijamos, paso a paso y con todo el código.

Traducción del original en catalán. Léela en: CatalàEnglish

Esta página estaba en el wiki de oriolrius.cat (2008–2012). La recupero aquí tal como era.

En este documento se describen los pasos que he seguido para programar un servicio de configuración de 'dynamic DNS' con un comportamiento distinto del servicio por defecto del propio pfSense. Este documento también puede servir de guía por si alguien quiere hacerse sus propios paquetes de pfSense para personalizar ciertos comportamientos del firewall.

Si tenéis dudas, preguntas o correcciones que hacer, por favor hacedlas en el artículo del blog:

Mi primer package de pfSense 'dd_adv'

Cómo funciona 'dynamic DNS' por defecto en pfSense

Hay que reconocer que el soporte es para muchos servicios públicos, y de pago, para publicar un nemónico para una IP dinámica. Cosa que lo hace muy bueno. Pero hay varios comportamientos del soporte que tiene pfSense para estas funciones que no se ajustaban a mis necesidades. Tal como está programado este soporte, lo que hace pfSense es coger la IP pública de la interfaz WAN y cada vez que esta cambia se hace la actualización de la IP pública en el servicio de DNS remoto.

El problema

Mi problema viene de dos sitios, por un lado la IP no la tengo asignada a la interfaz con internet, sino a otra interfaz. Por otro lado, la interfaz que tiene internet no tiene la IP pública asignada directamente a ella, sino que la tiene un router que a través de un proceso de NAT le da conectividad a internet. Así pues, el problema está, por un lado, en saber sobre qué interfaz accederemos a internet y, por otro lado, cuál es la IP pública a través de la cual se accede a la red. De rebote tenemos todavía otro problema debido a que la IP pública no está asignada a la interfaz del pfSense; supongo que es obvio que el problema es que no sabemos cuándo esta cambia. Por tanto, no sabemos cuándo tenemos que actualizarla en el servicio de DNS dinámico.

La solución

La solución que he adoptado es crear un nuevo servicio que, a través de un servicio de pooling, lo que hace es ir preguntando de forma periódica a internet cuál es la IP pública que tiene nuestra interfaz. Además se tiene que poder seleccionar cuál es esta interfaz sobre la que queremos verificar cuál es la IP pública. Ya que tenemos que forzar que el tráfico que se genera para descubrir la IP pública salga por la interfaz que realmente tiene conexión a internet. Esta casuística, por extraña que parezca, es muy habitual, porque en una oficina o similar nos podemos encontrar con la necesidad de tener dos líneas que van a internet, una que estará en la interfaz WAN del pfSense y otra que va por otra interfaz. A menudo en la interfaz WAN tenemos la salida principal a internet y en otra interfaz la salida de backup. Un ejemplo habitual en estos días que corren es usar una ADSL en la WAN y otra salida a través de un router 3G de Vodafone o similar por otra interfaz.

Configuración avanzada de DNS dinámico de pfSense
Configuración avanzada de DNS dinámico de pfSense

Cambiando el repositorio de paquetes de pfSense

Para crear un paquete de pfSense, lo primero que se tiene que hacer es dejar de usar el repositorio oficial de paquetes, creando en un servidor propio nuestro repositorio de paquetes que puede apuntar al resto de paquetes públicos. Pero que además puede tener nuestros propios paquetes añadidos a la lista. Para hacer esto primero de todo hay que disponer de un servidor HTTP con soporte de PHP. Después vamos al servidor y allí descargamos el fichero 'xmlrpc.tar.gz' del servidor de pfSense y lo descomprimimos en la raíz de uno de los dominios virtuales o del dominio real que tengamos en el servidor HTTP. La idea es que si hacemos 'http://host/pfSense/xmlrpc.php' allí se ejecute el servicio de XML-RPC del pfSense; por otro lado hay otro directorio que se creará al descomprimir el paquete 'xmlrpc.tar.gz', este directorio se llama 'packages'. Allí encontramos dos ficheros, uno de ellos el 'pkg_config.7.xml'. Este fichero contiene la lista de los paquetes que se pueden ver en el menú 'packages' del pfSense, así pues, aquí es donde añadiremos nuestro paquete justo entre las tags <packages>...</packages>.

Pasos:

/var/www/localhost/htdocs # wget http://www.pfsense.org/xmlrpc.tar.gz
/var/www/localhost/htdocs # tar xvfz xmlrpc.tar.gz
/var/www/localhost/htdocs/packages # vim pkg_config.7.xml

Añadimos nuestro paquete al fichero pkg_config.7.xml:

...
	<package>
		<name>DDNS_adv</name>
		<website>http://oriolrius.cat</website>
		<descr>Dynamic DNS advanced parameters for custom functonalities</descr>
		<category>Services</category>
		<config_file>http://mini4.joor.net/dd/dd.xml</config_file>
		<version>0.1</version>
		<status>ALPHA</status>
		<maintainer>oriol@joor.net</maintainer>
		<configurationfile>dd.xml</configurationfile>
		<required_version>1.2.1</required_version>
	</package>
  </packages>
</pfsensepkgs>

Fijaos que básicamente se trata de referenciar el nombre del paquete, la descripción, la versión, el status del mismo y otros datos del autor. Pero lo más importante es decir dónde está el fichero de configuración, básicamente se trata de especificar una URL de donde se descargará un XML que tenemos que definir describiendo dónde se instala el paquete y cómo queda integrado dentro del sistema del pfSense. En este caso fijaos que esta información está en:

<config_file>http://mini4.joor.net/dd/dd.xml</config_file>

Ahora hace falta que entremos por SSH en el pfSense o a través de su consola y que modifiquemos el fichero '/etc/inc/globalconf.inc'. Concretamente hay que buscar una variable que se llama '$xmlrpcurlbase' y poner el host donde tenemos nuestro nuevo servidor de paquetes. En nuestro caso la cosa queda así:

...
	$xmlrpcurlbase='oriol.joor.net',
...

Después de esto, si vamos al menú de los 'packages' ya podemos ver nuestro paquete en la lista de paquetes para instalar:

Lista de paquetes de pfSense con el paquete DDNS_adv
pfSense: lista de paquetes

Fichero de configuración del paquete

Como ya he comentado, este fichero contiene los detalles de cómo se tiene que instalar el paquete y cómo se integrará con el pfSense. Con esto quiero decir que dice de dónde se tienen que sacar otros ficheros necesarios, dónde se tienen que copiar y con qué permisos dentro del pfSense, si tiene que aparecer alguna nueva opción en el menú, qué campos tiene que tener el formulario para definir los parámetros de configuración de nuestro nuevo servicio. Además también se pueden definir los hooks necesarios para que el proceso de instalación, configuración y otros se ajusten a nuestras necesidades. Para que quede más claro todo el tema de los hooks explicaré cómo lo he tenido que usar en mi caso: lo único que me ha hecho falta es capturar el momento en que se guarda la configuración en el formulario y después de esto generar el fichero de configuración que nos hace falta para que funcione bien el demonio. Está muy bien disponer de todas las librerías de pfSense para hacer todo esto, aunque tienes que leer el código para entender cómo funcionan porque no he encontrado documentación. Pero nos permite, por ejemplo, integrar los parámetros de configuración de nuestro paquete en el fichero de configuración general del sistema.

El fichero de configuración que he hecho es 'dd.xml':

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE packagegui SYSTEM "./schema/packages.dtd">
<?xml-stylesheet type="text/xsl" href="./xsl/package.xsl"?>
<packagegui>
  <name>ddns_adv</name>
  <version>0.1</version>
  <title>DynDNS advanced settings</title>
  <configpath>['installedpackages']['ddnsadv']['config']</configpath>
  <additional_files_needed>
    <prefix>/usr/local/pkg/</prefix>
    <chmod>0644</chmod>
    <item>http://oriol.joor.net/dd/dd.inc</item>
  </additional_files_needed>
  <additional_files_needed>
    <prefix>/etc/rc.d/</prefix>
    <chmod>0700</chmod>
    <item>http://oriol.joor.net/dd/dd_service</item>
  </additional_files_needed>
  <additional_files_needed>
    <prefix>/usr/local/sbin/</prefix>
    <chmod>0700</chmod>
    <item>http://oriol.joor.net/dd/dd_adv.php.sh</item>
  </additional_files_needed>
  <additional_files_needed>
    <prefix>/etc/inc/</prefix>
    <chmod>0644</chmod>
    <item>http://oriol.joor.net/dd/dyndns_bis.class</item>
  </additional_files_needed>
  <service>
    <name>dd_adv</name>
    <rcfile>dd_service</rcfile>
    <executable>dd_service</executable>
  </service>
  <menu>
    <name>DDNS adv</name>
    <tooltiptext>Dynamic DNS advanced settings</tooltiptext>
    <section>Services</section>
    <url>/pkg_edit.php?xml=dd.xml&amp;id=0</url>
  </menu>
  <fields>
    <field>
      <fielddescr>Enable service</fielddescr>
      <fieldname>enabled</fieldname>
      <type>checkbox</type>
    </field>
    <field>
      <fielddescr>Get public IP across this interface...</fielddescr>
      <fieldname>selectinterface</fieldname>
      <description>Getting public IP across this interface...</description>
      <value>wan</value>
      <multiple>false</multiple>
      <size>5</size>
      <type>interfaces_selection</type>
    </field>
    <field>
    <fielddescr>Periode</fielddescr>
       <fieldname>periode</fieldname>
       <description>in minutes, every when check public IP address</description>
       <size>3</size>
       <type>input</type>
    </field>
  </fields>
<include_file>/usr/local/pkg/dd.inc</include_file>
<custom_php_resync_config_command>sync_package_dd();</custom_php_resync_config_command>
</packagegui>

A continuación comento los campos y secciones del fichero más importantes, empezaré por la siguiente tag:

<configpath>['installedpackages']['ddnsadv']['config']</configpath>

Aquí se indica en qué parte del fichero de configuración general del pfSense se guardará la configuración; este fichero de configuración es un fichero XML llamado 'config.xml' que básicamente es el fichero que se descarga al hacer una copia de seguridad del sistema. Como se trata de un fichero XML es sencillo referirse a una posición en su interior en forma de array multi-dimensional. Además, como mi paquete no forma parte de los paquetes por defecto, lo coloco en la sección de paquetes instalados, después indico dos nombres arbitrarios a partir de los cuales posteriormente podré acceder a los parámetros de configuración definidos más adelante en el mismo fichero.

Las secciones cerradas dentro de tags: 'additional_files_needed', tienen el siguiente aspecto y se refieren a ficheros que hay que instalar durante el proceso de instalación del paquete:

  <additional_files_needed>
    <prefix>/usr/local/pkg/</prefix>
    <chmod>0644</chmod>
    <item>http://oriol.joor.net/dd/dd.inc</item>
  </additional_files_needed>

Fijaos que se define dónde irá el fichero instalado, los permisos con los que se copiará el fichero y de qué URL se descargará. A través de estas secciones es desde donde podemos referenciar los paquetes binarios (tar.gz o similares) que pueden contener el código compilado necesario para que corra dentro del pfSense.

En caso de que nuestro paquete tenga que correr como demonio, podemos definir cómo se llamará el servicio y así después, a través de las funciones de control de demonios de pfSense, este se podrá poner en marcha, parar, reiniciar o iniciar cuando el pfSense se ponga en marcha.

  <service>
    <name>dd_adv</name>
    <rcfile>dd_service</rcfile>
    <executable>dd_service</executable>
  </service>

A menudo los ficheros que se referencian en esta sección se espera encontrarlos en /etc/rc.d; en mi caso, se lanzará el demonio vía '/etc/rc.d/dd_service'.

En las tags de 'menu' se define en qué menús se llamará la pantalla de configuración que se definirá más adelante en el mismo fichero XML. La sección menú tiene como única pieza difícil de entender el PATH de la URL que se llamará. Básicamente lo que se hace es llamar a un intérprete que será capaz de montar la pantalla de configuración del paquete a partir del XML:

  <menu>
    <name>DDNS adv</name>
    <tooltiptext>Dynamic DNS advanced settings</tooltiptext>
    <section>Services</section>
    <url>/pkg_edit.php?xml=dd.xml&amp;id=0</url>
  </menu>

Dentro de las etiquetas 'fields' se encierran la descripción de los campos: 'field', estos especifican lo que se verá en el formulario y que podrá configurar el usuario y también lo que se guardará en el fichero de configuración general. Si echáis un vistazo en esta sección os daréis cuenta de que el código es muy autodescriptivo y es muy sencillo de entender. Básicamente hay el nombre del campo, la descripción y el tipo de datos a guardar/pedir.

Otra etiqueta importante es la del 'include_file', a menudo con el mismo nombre que el fichero XML; en nuestro caso el fichero XML se llama 'dd.xml' y, por tanto, este fichero se llama 'dd.inc'. Se trata de un fichero con las funciones de PHP necesarias para los hooks que nos hagan falta:

<include_file>/usr/local/pkg/dd.inc</include_file>

Finalmente llega la hora de definir qué hooks usaremos; en mi caso solo uso uno definido con la etiqueta 'custom_php_resync_config_command':

<custom_php_resync_config_command>sync_package_dd();</custom_php_resync_config_command>

que como se puede ver solo llama a una función que está definida en el 'dd.inc'; este hook hace que se ejecute esta función después de guardar la configuración del formulario. En caso de que no queramos definir el código en el fichero INC también lo podemos hacer entre las dos tags, la de apertura y la de cierre del hook. Aunque bajo mi punto de vista siempre queda más ordenado y más limpio llamar solo a funciones desde los hooks y dejar todo el código PHP en el fichero INC.

El fichero /usr/local/pkg/dd.inc

En este fichero solo defino una función importante que, tal como ya se describe más arriba, solo sirve para dar el comportamiento que nos haga falta al sistema después de que se haya cambiado algo en la configuración del servicio:

<?php
require_once("config.inc");
require_once("functions.inc");
require_once("dyndns_bis.class");
require_once('globals.inc');
require_once('service-utils.inc');

function dd_notice ($msg) { syslog(LOG_NOTICE, "dd: {$msg}"); }
function dd_warn ($msg) { syslog(LOG_WARNING, "dd: {$msg}"); }

function sync_package_dd() {
	global $config;

	if ($config['installedpackages']['ddnsadv']['config'][0]['enabled']=='on') {
		$if = $config['installedpackages']['ddnsadv']['config'][0]['selectinterface'];
		$periode = $config['installedpackages']['ddnsadv']['config'][0]['periode']*60;
		
		$script = <<<EOD
#!/bin/sh

while true;
do
	/usr/local/sbin/dd_adv.php.sh
	sleep $periode
done

EOD;
		file_put_contents('/usr/local/sbin/dd_adv.sh',$script);
		system('chmod 700 /usr/local/sbin/dd_adv.sh');
		system('/etc/rc.d/dd_service restart');	
		dd_notice('started');
	} else {
		system('/etc/rc.d/dd_service stop');
		dd_notice('stoped');
	}
}

?>

En mi caso, lo que hago es rehacer el fichero '/usr/local/sbin/dd_adv.sh'. Este fichero es un fichero que tiene un bucle infinito que se repite cada N minutos, siendo N un parámetro definido en la configuración del servicio. En cada una de las iteraciones se ejecuta un código en PHP que es el encargado de hacer la actualización de la IP, si hace falta.

Todo esto se hace en caso de que el servicio haya sido activado desde la interfaz de configuración, pero si el servicio no ha sido activado directamente lo que hacemos es vaciar el fichero '/usr/local/sbin/dd_adv.sh'. El objetivo de esto, aunque también se pare el servicio, es que si se reinicia el firewall y se lanza el servicio cuando este llame al fichero en cuestión, como este no tendrá contenido no hará la iteración. Por tanto, será lo mismo que si no se hubiera lanzado. Quizá hay alguna forma más elegante de hacer esto, pero creo que cumple su función, así pues no me he complicado más.

Volviendo al fichero 'dd.inc', si os fijáis también define dos funciones más, la 'dd_notice' y la 'dd_warn', que básicamente se usan para enviar mensajes a syslog en caso de que en la función principal nos haga falta enviar algo sobre cuál es el estado del servicio.

El fichero '/usr/local/sbin/dd_adv.sh'

Este demonio, como hemos visto, se crea en tiempo de configuración dependiendo de los parámetros que tiene asignados. Su funcionalidad la he descrito unas líneas más arriba y es bien sencilla, pero como tiene entidad propia a continuación pego uno de los posibles aspectos que puede tener:

#!/bin/sh

while true;
do
	/usr/local/sbin/dd_adv.php.sh
	sleep 600
done

Como podéis ver, lo que hace es ejecutar el shell script programado en PHP y llamado 'dd_adv.php.sh' y después esperar 600 segundos hasta volver a pedir de nuevo la ejecución de este script. Por tanto, aquí tenemos el servicio de pooling.

Fichero '/usr/local/sbin/dd_adv.php.sh

El código de este script está hecho en PHP pero se lanzará como un shell script; como podemos ver en el código del fichero 'dd_adv.sh', se lanza periódicamente y lo único que hace es crear rutas estáticas que obliguen al pfSense a usar la interfaz definida en la configuración para llegar a 'http://checkip.dyndns.org'; esta web nos informa de la IP que hemos usado para conectarnos a ella. Por tanto, nuestra IP pública. Después, a través de la clase 'dyndns_bis.class' actualizamos la IP, si hace falta. Ahora ya podemos borrar las rutas estáticas y volver a dejarlo todo tal como estaba.

Hay que destacar que el script tiene en cuenta que la web a la que se accede puede tener más de una IP. Por eso se crean tantas rutas como IPs tiene la web que nos informa de nuestra IP. Además hay que fijarse en que nos apoyamos en varias librerías internas del pfSense para recoger informaciones como la configuración del sistema, saber cuál es el gateway de la interfaz que se ha definido como interfaz alternativa de salida a internet y para relacionarnos con el servicio de DNS dinámico usamos la librería 'dyndns_bis.class', que es una modificación de la librería 'dyndns.class' original del pfSense.

#!/usr/local/bin/php -q
<?php

require_once('/etc/inc/config.inc');
require_once('/etc/inc/functions.inc');
require_once('/etc/inc/dyndns_bis.class');
require_once('/etc/inc/pfsense-utils.inc');

$s = "checkip.dyndns.org";

	// getting interface gateway
        $if=$config['installedpackages']['ddnsadv']['config'][0]['selectinterface'];
        $gw=get_interface_gateway($if);

	// add static routes to $s;
	$ips=gethostbynamel($s);
	foreach ($ips as $ip) {
		$ruta="route add -net ".$ip."/32 ".$gw;
		system($ruta);
	}	

	// get public IP address via fixed interface
	$h=new updatedns_bis($config['dyndns']['type'],
                      $config['dyndns']['host'],
                      $config['dyndns']['username'],
                      $config['dyndns']['password'],
                      $config['dyndns']['wildcard'],
                      $config['dyndns']['mx']);
	// dump result
	var_dump($h);

	// remove static routes to $s
	foreach ($ips as $ip) {
		$ruta="route del -net ".$ip."/32 ".$gw;
		system($ruta);
	}

?>

Clase '/etc/inc/dyndns_bis.class'

Esta clase es una modificación muy y muy simple del código 'dyndns.class' del pfSense; básicamente añade un nuevo método privado que obtiene la IP pública de la interfaz después de conectarse a 'http://checkip.dyndns.org'. Así pues, en el resto de clases, cada vez que se intenta coger la IP pública a través de acceder a la IP de la interfaz WAN he modificado el código para que lo que haga sea acceder a la web en cuestión.

El código de la clase no lo pego aquí porque es muy largo, lo podéis encontrar en: URL_CODI; hay que notar que el código de la clase está bastante bien hecho e implementa un servicio de caché, que en caso de que la IP no haya cambiado no se envíe una actualización de la misma; además también controla el 'timestamp' de cuándo se hizo la última actualización para que se pueda controlar un mínimo de tiempo de cada cuándo se tiene que actualizar la IP aunque esta no haya cambiado. Todo ello me ha ahorrado mucho trabajo a la hora de no tener que montarme yo mi propio sistema de actualización de IPs.

Quizá lo que es un poco más curioso es ver cómo se parsea la información que se recibe de la web que nos da la IP pública; por cierto, este código no lo he escrito yo sino que lo he encontrado a través de los foros de pfSense. Aprovecho pues para darle las gracias a 'Tri Tu', el autor del código.

/* Private function for getting real IP */
/* Author: Tri Tu */
function _checkip() {
   log_error("DynDns: Running _checkip() for real WAN IP");
   $ch = curl_init();
   curl_setopt($ch, CURLOPT_URL, 'http://checkip.dyndns.com');
   curl_setopt($ch, CURLOPT_HEADER, 0);
   curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
   $data = curl_exec($ch);
   curl_close($ch);
   list($part1, $part2) = split(': ', $data, 2);
   list($ip, $junk) = split('<', $part2);
   return $ip;
}

Por cierto, fijaos que usa CURL para hacer la petición HTTP; en caso de que no conozcáis esta librería os recomiendo que le echéis un vistazo porque creo que es realmente una de las mejores librerías cliente de HTTP, HTTPs y similares que he visto. Tanto para PHP como para C, C++, Python y muchos otros lenguajes.

Service launcher

El único fichero que nos falta por explicar es bien simple, es el que va a /etc/rc.d/dd_service y que se encarga de lanzar el shell script que itera infinitamente vigilando si la IP ha cambiado. En este fichero no he usado las librerías internas de pfSense para programarlo porque estas no soportan lanzar demonios que sean 'shell scripts'. Así pues, me he hecho una implementación muy básica de las funcionalidades que hacen falta para poder lanzar, parar y reiniciar el demonio:

#!/bin/sh

start()
{
        /usr/local/sbin/dd_adv.sh > /dev/null 2>&1 &
}

stop()
{
        PID=`ps ax | grep "/bin/sh /usr/local/sbin/dd_adv.sh" | grep -v grep | cut -c 1-7`
        kill -9 $PID
}

# main

        case $1 in

        start)
                start
                return 0
                ;;
        stop)
                stop
                return 0
                ;;
        restart)
                stop
                start
                return 0
                ;;
        *)
                echo "usage: $0 <start|stop|restart>"
                return 1
                ;;
        esac