$ sudo equery belongs somefile
  File "/usr/bin/equery", line 271
    print pp.path(" /" + c[0])
           ^
SyntaxError: invalid syntax

Tras darle unas vueltas y no encontrar gran cosa en Internet Google , acabé pensando que podía tener que ver con el intérprete de python instalado. No estoy seguro de cómo llegué a esa conclusión, pero supongo que ayudaron el hecho de ver que equery está escrito en python, que mi sistema tenía instalados varios intérpretes (concretamente los más actuales de la versión 2 y 3 del mismo), y que otra máquina con Gentoo usaba otro intérprete y no sufría el problema.

Para resolverlo, lo primero es buscar pistas. Al trabajar con varias versiones, lo normal es que el ejecutable sea un enlace a la versión elegida. Así que fue cuestión de ver a dónde apuntaba dicho enlace y buscar el paquete involucrado.

$ ls -l /usr/bin/python
lrwxrwxrwx 1 root root 14 jul 14 12:21 /usr/bin/python -> python-wrapper
$ equery belongs /usr/bin/python-wrapper
[ Searching for file(s) /usr/bin/python-wrapper in *... ]
app-admin/eselect-python-20100321 (/usr/bin/python-wrapper)
$ equery files app-admin/eselect-python
[ Searching for packages matching app-admin/eselect-python... ]
* Contents of app-admin/eselect-python-20100321:
/etc/env.d/python/.keep_app-admin_eselect-python-0
/usr/bin/python-wrapper
/usr/share/eselect/modules/python.eselect

Parece que eselect es la herramienta que usa portage para decidir qué versión se usa cuando un paquete tiene varias instaladas. Por lo que se ve arriba, cada paquete instala sus propios módulos para informar a eselect de qué versiones hay disponibles, etc. A partir de aquí, jugando un poco con el mandato eselect, encontrar la forma de cambiar la versión no es difícil:

$ eselect
Usage: eselect   
...
$ eselect python
Usage: eselect python  
...
$ eselect python list
Available Python interpreters:
  [1]   python2.6
  [2]   python3.1 *
$ sudo eselect python set python2.6

Y, efectivamente, eso resuelve el problema y equery vuelve a funcionar .

La opción es -o, y acepta como argumentos una gran cantidad de posibilidades, que normalmente se encuentran descritas en la página del manual como standard format specifiers (o directamente no se encuentran ).

Un ejemplo de cómo lucen normalmente las órdenes de tipo ps que suelo lanzar en mis terminales:

$ ps fax -o user,uid,pid,ppid,pgrp,%cpu,%mem,rss,vsize,size,tname,etime,start_time,args
USER       UID   PID  PPID  PGRP %CPU %MEM   RSS    VSZ    SZ TTY          ELAPSED START COMMAND
root         0  3434     1  3434  0.0  0.1   552   5404   464 ?        12-22:14:08 Feb23 /usr/sbin/sshd
root         0 14466  3434 14466  0.0  0.5  2572   8124   512 ?              36:04 12:13  \_ sshd: deigote [priv]
deigote   1000 14469 14466 14466  0.0  0.2  1440   8280   668 ?              36:01 12:13      \_ sshd: deigote@pts/2
deigote   1000 14470 14469 14470  0.0  0.6  3344   6548  2172 pts/2          36:01 12:13          \_ -bash
root         0 16310 14470 16310  0.1  0.2  1196   4292   472 pts/2          00:06 12:49              \_ su -
root         0 16311 16310 16311  0.0  0.3  1688   4740   364 pts/2          00:03 12:49                  \_ -su
root         0 16315 16311 16315  0.0  0.2   992   4148   580 pts/2          00:00 12:50                      \_ ps fax -o user,uid,pid,ppid,pgrp,%cpu,%mem,rss,vsize,size,tname,etime,start_time,args

Y, de hecho, un par de alias que suelo tener siempre definidos, entre otros, son:

alias ps='ps fax -o user,uid,pid,ppid,pgrp,%cpu,%mem,rss,vsize,size,tname,etime,start_time,args'
alias psg='ps | head -n 1 && ps | grep'

find directorio_raiz -type f -exec sh -c 'basename $0 | sed "s/.*\.//"' {} \; | sort | uniq

El truco viene del archipoderoso sed, que permite obtener las extensión de un fichero mediante la orden sed “s/.*\.//”, y funciona que yo sepa, para cualquier Unix con una shell compatible con sh y find, basename y sed instalados.

1. ¿Qué es Liferay?
2. Instalación básica
3. Usando Liferay con MySQL
4. Usando Liferay con Apache
5. Usuario por defecto y un par de ajustes más

¿Qué es Liferay?

Liferay es un gestor de portales web con una gran funcionalidad integrada (gestión de comunidades y usuarios, CMS, wiki, blogs, y mucho más), y a su vez es un contenedor de portlets, lo que le permite ser extendido de manera bastante rápida y flexible (siguiendo la especificación JSR 286: Portlet Specification 2.0). Además, cuenta con una versión Community cuyo uso es gratuito y cuyo código es libre.

Instalación básica

Descargamos la última versión Community con el usuario que arrancará Liferay (en mi caso www-data) en el sitio que queramos (yo he escogido /opt/websites/liferay.deigote.com como directorio base de la instalación):

$ su - www-data
$ cd /opt/websites/
$ wget 'http://sourceforge.net/projects/lportal/files/Liferay%20Portal/liferay-portal-tomcat-6.0-5.2.3.zip'
$ unzip liferay-portal-tomcat-6.0-5.2.3.zip
$ mv liferay-portal-5.2.3/ liferay.deigote.com

Si ahora arrancamos Liferay, podremos ver cómo nos informa en los log de que se usará una base de datos para testing (Hipersonic), y si navegamos por la web, podremos ver una serie de portlets a modo de demo:

$ /opt/websites/liferay.deigote.com/tomcat-6.0.18/bin/startup.sh
$ tail -f logs/catalina.out &
$ firefox http://localhost:8080

Este entorno de demo está bien para cacharrear un poco y ver cómo la gente de Liferay quiere vendernos sus capacidades para hacer un clon de Facebook (vienen instanciados portlets de chat, de muro, de añadir usuarios como amigo, de actividad reciente…), pero los datos no persisten, por lo que no podréis pasar de ahí. Además, Liferay viene por defecto con usa serie de portlets (en forma de plugins) preparados para hacer la demostración antes mencionada. Yo normalmente borro dichos portlets antes de continuar (de hecho, en mi caso borro todos los plugins excepto el de web-form-portlet, que es el único que encuentro útil):

$ rm -rf `ls /opt/websites/liferay.deigote.com/tomcat-6.0.18/webapps | grep -v ROOT | grep -v web-form-portlet`

Para la persistencia de los datos, tenemos que conectar Liferay con un viejo conocido .

Usando Liferay con MySQL

Para conectar Liferay con MySQL existen varias formas. De momento anotaré aquí la más sencilla (aunque para mi gusto un poco “fea”), puesto que no recuerdo exactamente cómo es la otra . Liferay incluye en su core un fichero de propiedades (portal.properties) que configuran prácticamente todos los componentes del portal, base de datos incluida. Ese fichero puede ser extendido mediante el fichero portal-ext.properties, que por defecto no existe. Así que escribimos en él la configuración de la base de datos:

$ echo "# Database connection
jdbc.default.driverClassName=com.mysql.jdbc.Driver
jdbc.default.url=jdbc:mysql://localhost/liferay_database?useUnicode=true&characterEncoding=UTF-8&useFastDateParsing=false
jdbc.default.username=mysql-user
jdbc.default.password=mysql-password" > /opt/websites/liferay.deigote.com/tomcat-6.0.18/webapps/ROOT/WEB-INF/classes/portal-ext.properties

A continuación nos conectamos al servidor de mysql (en mi caso, localhost) y creamos la base de datos y un usuario con permisos para la misma:

$ mysql -h localhost -u root -p
$ create database liferay_database
$ grant all privileges on liferay_database.* to "mysql-user"@"localhost" identified by "mysql-password";

Si en este momento arrancamos Liferay de nuevo, deberíamos ver algunos mensajes haciendo mención a la base de datos utilizada (MySQL), y otros que indican que se están creando las tablas..

Usando Liferay con Apache

Para usar Apache como servidor web, creamos un host virtual y lo conectamos al servidor de aplicaciones de Liferay (en mi caso Tomcat) usando un módulo de proxy. Podemos usar el módulo proxy_http, que funcionaría con cualquier servidor de aplicaciones, o el módulo proxy_ajp, específico de Apache, y que presenta algunas ventajas sobre http, aunque yo no las recuerde . Dado que Tomcat soporta AJP, será el que usemos. Dado que yo uso Debian, necesito activar el módulo de proxy_ajp y crear un host virtual que use dicho módulo:

$ su -
# a2enmod proxy_ajp
# nano /etc/apache2/sites-available/liferay.deigote.com
# a2ensite liferay.deigote.com
# /etc/init.d/apache2 restart
# exit

El contenido del fichero /etc/apache2/sites-available/liferay.deigote.com será el siguiente:

<VirtualHost *:80>
        ServerName liferay.deigote.com
        ServerAdmin webmaster@localhost
        ErrorLog /var/log/apache2/liferay.deigote.com_error.log
        LogLevel warn
        CustomLog /var/log/apache2/liferay.deigote.com_access.log combined
        # Proxy to Tomcat
        <Proxy *>
                Order deny,allow
                Allow from all
        </Proxy>
        ProxyPass / ajp://liferay.deigote.com:8009/
        ProxyPassReverse / ajp://liferay.deigote.com:8009/
</VirtualHost>

Antes de echar a andar con esta configuración, debemos añadir un par de líneas al fichero de propiedades de Liferay, ya que si no éste dará por hecho que estamos atacando al puerto 8080 (el puerto por defecto de Tomcat) y escribirá las URL’s con dicho puerto. Una vez realizado este paso, deberíamos poder acceder a Liferay a través del host virtual que hemos usado (siempre y cuando nuestro servidor DNS sepa resolver dicho host, claro):

$ /opt/websites/liferay.deigote.com/tomcat-6.0.18/bin/shutdown.sh
$ echo "
# Webserver configuration
web.server.http.port=80
web.server.https.port=443" >> /opt/websites/liferay.deigote.com/tomcat-6.0.18/webapps/ROOT/WEB-INF/classes/portal-ext.properties
$ /opt/websites/liferay.deigote.com/tomcat-6.0.18/bin/startup.sh
$ firefox http://liferay.deigote.com

Usuario por defecto y un par de ajustes más

Una vez estemos navegando por Liferay, podremos acceder usando el usuario test@liferay.com con la contraseña test, que es administrador de la comunidad por defecto (guest) Yo recomiendo un par de ajustes más:

• Cambiar la dirección de correo (y por tanto el login) y la contraseña del usuario administrador. Esto lo podéis hacer en el Panel de control, en el apartado de Usuarios.
• Modificar el host virtual de la comunidad por defecto (o la que vayáis a usar) para que coincida con el que estéis usando para acceder a través de Apache. Esto se puede hacer en el panel de control, en el apartado Communities – Guest – Manage pages – Settings – Virtual host, usando el campo Public virtual host. Esto permitirá que las URL’s del tipo http://virtual_host/web/nombre_de_la_comunidad/pagina pasen a ser http://virtual_host/pagina, lo cual es más cómodo. Por ejemplo, la URL de la página por defecto (home) en la comunidad por defecto (guest) en mi caso pasaría de http://liferay.deigote.com/web/guest/home a http://liferay.deigote.com/home

Una vez finalizados estos pasos, ya podemos empezar a trabajar con Liferay en un entorno de producción (a falta, por supuesto, de configuraciones y optimizaciones de Tomcat, Apache y MySQL que no vienen al caso ).

Paso 1: ¿cuánto tiempo?

Después de buscar (no, mucho, eso si ) por Google y no encontrar algo que se adaptase a mis mínimas necesidades, me he hecho un pequeño script de apagado de la máquina para mi maravilloso PC en el salón (que no de salón ) equipado con un GNU/Linux (en concreto una Debian, pero el script es multiversal dentro del mundo Linux y quizá Unix, depende de si el software zenity está en otras plataformas o no).

Paso 2: tú tranqui, que ya te aviso yo...

La idea es poder pedirle a la máquina que se apague dentro de equis minutos, con posilibidad de cancelarlo y cierto feedback visual de cuánto tiempo te queda. Posibles usos son por ejemplo imitar la función Sleep de algunas televisiones, o, cuando te vas de vacaciones y tienes algunas descargas tirando, o algún programa de TV que quieres que se grabe, pedirle que se apague en unos días para no consumir energía tontamente.

El script sólo requiere que esté instalado Zenity. El código fuente del mismo lo podéis ver a continuación:

#!/bin/bash
# Ask for time in minutes to sleep and ater that poweroff the computer
# needs - zenity
# Diego Toharia - deigote@deigote.com

# Messages
TITLE="Apagar el ordenador"
MINUTES_QUESTION="¿Dentro de cuántos minutos?"
WAIT_PRE="Esperando"
WAIT_POST="minutos"

minutes=`zenity --entry --title "$TITLE" --text "$MINUTES_QUESTION" 2>&1` || exit
seconds=`expr $minutes "*" 60`

if [ $seconds != "" ] ; then
	for i in `seq 1 $seconds` ; do
		percentage=`expr $i "*" 100`
		percentage=`expr $percentage "/" $seconds`
		echo $percentage
		sleep 1
	done | zenity --title="$TITLE" --text="$WAIT_PRE $minutes $WAIT_POST" --progress --auto-close --auto-kill
	poweroff
fi

También quiero pensar que, si alguna vez cambio algo, podréis encontrar una versión actualizada en el enlace Programmed shutdown script pero no garantizo que cumpla mis propósitos .

Programmed shutdown: laucher

Para invocarlo, basta guardarlo en un directorio que esté en el path (yo suelo usar para estos scripts $HOME/bin) y darle permisos de ejecución. Recordar que debéis tener permisos para ejecutar el mandato poweoff. En mi caso, tengo en la barra inferior un lanzador precedido del mandato gksudo, de tal manera que el script se lanza con los permisos necesarios, pidiéndome la contraseña en caso necesario.

awk es un mandato que sirve para procesar líneas de texto (separadas, naturalmente, por un salto de línea). awk cuenta con un pequeño y sencillo lenguaje de programación que es interpretado (no necesita ser compilado), y resulta tremendamente útil cuando queremos extraer información de extensos campos de texto (y, posiblemente, manipularla).

El funcionamiento del madato awk es muy sencillo: basicamente tenemos dos posiblidades:

$ awk -f fuente.awk fichero_entrada.txt
$ awk 'fragmento de código fuente' fichero_entrada.txt

En la primera de ellas, el código fuente está en un fichero (recomendado para usos que vayan a repetirse con el tiempo y con códigos fuentes largos) mientras que el segundo ofrece la ventaja de poder poner el código fuente como un argumento más. Esto es muy útil para el uso de awk en scripts o similares, en los que el uso de ficheros puede ser un engorro. También cabe la posibilidad de omitir el fichero de entrada, en cuyo caso awk leerá de la entrada estándar.

Respecto al lenguaje awk, tiene una estructura similar a lo siguiente:

BEGIN { acción }
/patrón/ { acción }
END { acción }

La forma de funcionamiento la siguiente:

1. Nada más comenzar la ejecución, se evaluará la acción marcada entre llaves precedida por la palabra reservada BEGIN.
2. Por cada campo de texto (recordemos, por defecto líneas) awk evaluará si se ajusta al patrón (una expresión regular), y de ser así, ejecutará la acción marcada entre llaves que sigue a dicho patrón. Por cada líneas se evaluarán todos los patrones a menos que en una de las acciones ejecutadas se encuentre la orden next, en cuyo caso se comenzará desde el principio con la siguiente línea.
3. Finalmente, se procesará la acción marcada entre llaves precedida por la palabra reservada END.

Respecto a los patrones de awk, son, como ya he dicho, expresiones regulares. No voy a explicar aquí todas las posiblidades porque no acabaría nunca (y con la ayuda de la Wikipedia os debería bastar), basten un par de ejemplos:

• /[afP]MEMOLO[1-3]z/ casará con cualquier línea que contenga las letras a, f o P seguidas de la cadena MEMOLO seguidas de un dígito comprendido del 1 al 3 y seguida por la letra z.
• /[afP](MEMOLO)+([1-3])*z/ casará con cualquier línea que contenga las letras a, f o P seguidas de la cadena MEMOLO una o varias veces seguidas de un dígito comprendido del 1 al 3 que puede aparecer ninguna, una, o varias veces y seguida por la letra z.

Esta es la parte más complicada de awk (ya sabeis lo que se dice de las expresiones regulares).

En cuanto a las acciones, cualquiera que haya programado en C no tendrá mucho problema, ya que es similar. Como características cabría destacar:

• El acceso a las línea actual se hace mediante unas variables especiales. En concreto $0 referencia a toda la línea mientras que $1, $2, etcétera, referencian a los campos de dicha línea. El separador de campos por defecto es un espacio o un tabulador, pudiéndose modificar en la acción de BEGIN con la variable FS (otra expresión regular, por cierto).
• No es necesario declarar ni tipar las variables, cuyo formato es el mismo que en C (su expresión regular, para que vayais practicando, es algo parecido a [a-Z]([a-Z] | [1-9] | _ )*).
• Están permitidas todas las estructuras clásicas de programación en un formato estilo C (bucles, expresiones condicionales, operadores, etcétera).
• Para imprimir resultados, existen dos posiblidades. La primera, print, es la más cómoda, puesto que no es necesario usar paréntesis para sus argumentos y cuenta con concatenación automática de los mismos (algo parecido al mandato echo de la terminal. Por ejemplo, print “la línea ” $0 “tiene ” NF ” palabras” imprimirá la frase que precede a print sustituyedo $0 por la línea actual y NF (otra variable especial) por el número de campos de la misma. Como segunda posibilidad, tenemos printf, que ofrece mayor control (es idéntico al del lenguaje C).

¿Y qué pasa con los los jugosos ejemplos? Pues he recopilado alguno que otro según me ha ido surgiendo la necesidad de usarlo estos días.

• Por ejemplo, el otro día necesitaba obtener del fichero de log de Tomcat las líneas que contuviesen o bien “SOAP21″ o bien ” – 2 “. Esto sería sencillo de hacer con dos grep, pero yo necesitaba que esas líneas mantuviesen el orden en el que habían aparecido en el fichero, y hacer eso con un grep requiere de una expresión regular bastante más compleja de lo que en realidad es necesario. Además, quería saber en qué número de línea del fichero estaba cada línea buscada. Con awk, fue tan sencillo como esto:
  cat tomcat.log | awk '/SOAP21/{print NR " - " $0} / - 2/{print NR " - "$0}'
• También necesité, en el mismo fichero, verificar que se cumpliese una secuencia, y concretamente, me valía saber que, dentro del conjunto de líneas que contenían “SOAP21″, las múltiplo de 5 eran idénticas, ya que de esta manera sabía que se habían cumplido todos los pasos. Por lo tanto, necesitaba sacar las líneas que tuviesen “SOAP21″, y dentro de éstas, sólo las que su número de línea fuese múltiplo de 5. Nuevamente, awk te lo pone fácil:
  cat tomcat.log | awk 'BEGIN { nl = 1 } /SOAP21/ { if (nl % 5 == 0) print ; nl++}'
• En plan más “complicado” (teniendo en cuenta que lo de antes era trivial), hice una pequeña línea para sacar la nota media a partir del archivo html que te devuelve la UPM cuando consultas tu expendiente usando la modalidad “Último estado de cada asignatura” (aunque falla cuando tienes alguna matrícula, pero bueno, eso no es lo importante ahora). El código es el siguiente:
  cat consulta.upm.html | grep "
/<\/table>/ { d = 0 } { if (d > 0) { if (c == 10) { print ; c = 0 } else c++ } }' | grep
'>\([1-9][0-9]\|[1-9]\|[1-9]\,[0-9]\{1\}\|[1-9]\,[0-9]\{2\}\)<' | cut -d 1 -f2 -d'>' | cut
-f1 -d'<' | awk 'BEGIN { t=0.0;n=0; } {print ; t=t+$1 ; n++} END { print "Total " t "
Asignaturas " n " Media " t/n}'
  Como veis, el primer fragmento de awk hace una selección de líneas, imprimiendo sólo las filas de las tablas que sean múltiplo de 10 (son en las que se encuentran las notas) y que estén contenidas entre una línea que tenga la palabra Obs y el primer final de tabla en html. Una vez obtenidas estas líneas, uso grep para quedarme solo con las que tienen nota y cut para dejar sólo la nota, quitando el resto de elementos html. El segundo fragmento de awk se encarga de ir sumando las notas y el número de asignaturas para imprimir la media.

EDITO: iré añadiendo más fantabulosos ejemplos según me los vaya encontrado.

• Mi hermano el otro día me preguntó como resolvería un problema y le sugerí que usara awk. El problema consistía en que tenía ficheros (por cierto, de más de 80.000 líneas) con una estructura tal que
  frase1 1
frase2 5
...
fraseN M
  y quería sumar los números de cada frase. En el caso original tenía la ventaja de que las frases siempre iban en el mismo orden en todos los ficheros, pero la sencillez de awk hace que la solución (que corre a cargo de mi hermano, por cierto) valga para casos que no estén en orden (e incluso que aparezcan frases en algunos ficheros y en otros no). Además, se requería que fuese relativamente rápido, y awk cumplió con las expectativas (la solución previa eran pruebas con scripts más o menos a mano y los resultados se iban por encima de los 10 minutos, frente a los 2 minutos de la solución con awk). El único problema era juntar la salida de los ficheros, pero awk permite trabajar con varios ficheros de entrada de datos (si no, un poquito de bash scripting, for i in *.out ; do cat $i ; done, lo hubiese solucionado). Los ficheros tenían extensión .out, por lo que la solución final es:
  awk 'BEGIN { FS = " ";} { resultados[$1] += $2 } END { for(category in resultados) print category, resultados[category]; } *.out'
  Como veis es sencillo, limpio y eficaz ¡con awk, la suciedad se va en un bang! Aquí además podeis ver algunas cosas más de awk, como los bucles, los array (estilo PHP, sin declaración ni reserva de memoria ni inicialización de datos) y la variable especial FS, que sirve para especificar cómo separar los campos de una línea (aunque en este caso no haga falta porque por defecto es espacio o tabulador).

Y esto es todo por hoy. Huelga decir que en Internet encontrareis cientos de ejemplos y tutoriales, pero yo quería hacer una pequeña introducción con un par de ejemplos más prácticos que los que suelo encontrar (al menos, serían prácticos para mí ;-)). Espero que os sea de utilidad.

Technorati Tags: webcam quickcam messenger quickcam linux quickcam messenger linux

• Para empezar, algunas variables. El nombre del script, la localización del mandato iptables, el puerto que uso para el emule y los puertos que uso para el bittorrent. Poca cosa :):

  
  #!/bin/sh
  # An extended firewall script.
  # Diego Toharia
  
  # Some vars
  N=/etc/init.d/firewall
  IPTABLES=/sbin/iptables
  EMULE_PORT=6889
  BT_PORT=6881:6888
  

• Aquí esta la chicha de iptables. Las reglas, metidas dentro de una función. Como se puede ver hay poca cosa, y ni una sola acción de salto (-j, jump ). Así, por cada regla sólo se cuentan los paquetes que enlazan con la misma. Si quisíeramos filtrar alguna de ellas, añadimos -j DROP y listo :). Principalmente lo que hago es, primeramente, crear contadores de conexiones entrantes (es decir, el número de paquetes/bytes que generan las nuevas conexiones de clientes a programas con socket en estado LISTEN o en escucha), y luego añado varios contadores del tráfico generado tanto entrante como saliente por el emule, bittorrent, web, y globales (dentro y fuera de la LAN y en total). Como ya he comentado, no hay mucho más, ya que es una máquina detrás de un router y que no es router a su vez:

  
  # Rules definitions
  rules_def() {
      ############ CONNECTIONS COUNTERS ##################################
      # Count Emule connections
      $IPTABLES -A INPUT -m state --state NEW -p tcp --dport $EMULE_PORT
      # Count Bittorrent connections
      $IPTABLES -A INPUT -m state --state NEW -p tcp --dport $BT_PORT
      # Count Ssh connections
      $IPTABLES -A INPUT -m state --state NEW -p tcp --dport ssh
      # Count Http connections
      $IPTABLES -A INPUT -m state --state NEW -p tcp --dport http
      ############ TRAFIC COUNTERS #######################################
      # Count Emule input traffic
      $IPTABLES -A INPUT -m state --state ESTABLISHED,RELATED         -p tcp --dport $EMULE_PORT
      # Count Bittorrent input traffic
      $IPTABLES -A INPUT -m state --state ESTABLISHED,RELATED         -p tcp --dport $BT_PORT
      # Count Http traffic
      $IPTABLES -A INPUT  -p tcp --sport http
      $IPTABLES -A OUTPUT -p tcp --dport http
      # Count LAN traffic
      $IPTABLES -A INPUT -s 192.168.0.0/24
      $IPTABLES -A OUTPUT -d 192.168.0.0/24
      # Count inet traffic
      $IPTABLES -A INPUT -s ! 192.168.0.0/24
      $IPTABLES -A OUTPUT -d ! 192.168.0.0/24
      # Count all traffic
      $IPTABLES -A INPUT
      $IPTABLES -A OUTPUT
      ####################################################################
  }
  

• Aquí pongo una función que averigua cuál es la dirección IP con la que navegamos por Internet, y cuales son las direcciones IP configuradas en nuestra máquina. Para hacerla, he usado la información del siguiente enlace: http://blog.enrique.barbeito.org/. Lo he encontrado usando Google, como no. Muchas gracias a Enrique Barbeito y su blog.

  
  # IP finder
  ipfinder() {
          IP_PUB=`lynx -dump www.cualesmiip.net | grep Tu | awk '{print $5}'`
          IP_PRIVS=`ifconfig | grep "inet addr" | cut -f2 -d: | cut -f1 -d' '`
          export IP_PUB=$IP_PUB
          export IP_PRIV=$IP_PRIVS
          echo "Public IP"
          echo $IP_PUB
          echo "Private IPs"
          echo $IP_PRIVS
  }
  

• A continuación hago una función que, a partir de información guardada por el resto del script, calcula unas tasas de transferencia desde que se puso en marcha el script hasta que se paró (siempre que estas operaciones se hagan de forma correcta, es decir, arrancando y parando el script con las propias opciones del script). Esta funcionalidad, es, sin duda, la que más me gusta :P, todos los días consulto el trafico del dia anterior y me congratulo, jejeje:

  
  # Traffic rates
  traffic_rates() {
      START_TIME=`cat /var/run/firewall.start`
      FINISH_TIME=`cat /proc/uptime | awk '{print $1}' | cut -d'.' -f 1`
      UPTIME=`expr $FINISH_TIME - $START_TIME`
      INPUT_TRAFFIC=`sudo iptables -L INPUT -v -x | grep \!localnet | awk '{print $2}'`
      INPUT_RATE=`expr $INPUT_TRAFFIC / 1024 / $UPTIME`
      OUTPUT_TRAFFIC=`sudo iptables -L OUTPUT -v -x | grep \!localnet | awk '{print $2}'`
      OUTPUT_RATE=`expr $OUTPUT_TRAFFIC / 1024 / $UPTIME`
      echo "Input rate: $INPUT_RATE KB/s (`expr $INPUT_TRAFFIC / 1048576` MB)"
      echo "Output rate: $OUTPUT_RATE KB/s (`expr $OUTPUT_TRAFFIC / 1048576` MB)"
  }
  

• Por último, el “programa principal” del script. Está hecho a modo de script de los del init.d, para ser arrancado por el mismo (luego explicaré cómo hacerlo). Se encarga de coordinar lo anterior para, por cada start y stop, guardar en un log el accounting, la direccion IP , y las tasas de tráfico del intervalo de tiempo entre los mismos:

  
  case "$1" in
    start)
          cat /proc/uptime | awk '{print $1}' | cut -d'.' -f 1             > /var/run/firewall.start
          echo "Firewall: setting up iptables rules.."
          echo "###############################################"             > /var/run/firewall
          echo -n "Traffic from " >> /var/run/firewall
          date +%k:%M" of "%A' '%D >> /var/run/firewall
          rules_def
          ipfinder >> /var/run/ipfinder
          ;;
      stop)
          echo "Firewall: saving counters.."
          echo -n "To " >> /var/run/firewall
          date +%k:%M" of "%A' '%D >> /var/run/firewall
          echo "###############################################"             >> /var/run/firewall
          iptables -L -v >> /var/run/firewall
          echo "###############################################"             >> /var/run/firewall
          ipfinder >> /var/run/firewall
          echo "###############################################"             >> /var/run/firewall
          traffic_rates >> /var/run/firewall
          echo "###############################################"             >> /var/run/firewall
          mv /var/run/firewall /var/log/firewall/log.`date +%d_%m_%y_%H_%M`
          echo "Firewall: flushing iptables rules.."
          iptables -F
          iptables -X
          rm /var/run/ipfinder
          rm /var/run/firewall.start
          ;;
      reload|restart|force-reload)
          $N stop
          $N start
          ;;
    *)
          echo "Usage: $N {start|stop|restart|force-reload}" >&2
          exit 1
          ;;
  esac
  
  exit 0
  

Si poneis cada parte del código seguida, tendreis el script completo. Durante la ejecución del mismo podeis encontrar vuestra ip en el fichero /var/run/ipfinder, quedando los logs almacenados en el directorio /var/log/firewall que previamente debeis crear. Poniendo este fichero en /etc/init.d/ con el nombre firewall y ejecutando rcconf, o el mandato update_rec.d firewall defaults, lo tendreis todo funcionando, y podreis disponer de unas sencillas estadísticas para los que no queremos complicarnos la vida (para los que si quieran, a conjugar iptables con ntop, que me ha parecido potentisimo, y snort, que no lo he usado más que como sniffer pero es un potente detector de intrusos). Sigo buscando cómo hacer accounting del resto de máquinas, ya que aunque ponga la interfaz en modo promiscuo, iptables no procesa el tráfico que llega de otros PC’s . Mis posteriores descubrimientos, aquí, en próximas ediciones ;). No puedo terminar el artículo sin agradecer a Oskar Andreasson su magnifico trabajo con el tutorial de iptables, con el que yo me inicie y que es mi referencia para este tema.

Por supuesto, sólo para Linux.

#!/bin/bash
# any2mp3 - Recives an extension and convert any file with this extension
#           to mp3 using mplayer and lame.
# Requirements - mplayer, lame.
# Diego Toharia - deigote@gmail.com

# Verify parameter
if [[ $# -ne 1 ]]
then
  echo "Error: first parameter (file extension to convert) missing"
  echo "Usage: `basename $0` "
  exit 1
fi
ext=$1

# Remove spaces
for i in *.$ext; do
  mv "$i" `echo $i | tr ' ' '_'` ;
done

# To wav with mplayer, to mp3 with lame.
for i in *.$ext ; do
  name="`basename "$i" ."$ext" | tr '_' ' '`.mp3"
  echo $name
  mplayer $i -ao pcm:file=scratch.$$.wav && \  lame -h -V 7 scratch.$$.wav "$name" ;
done

# Remove scratch file
rm scratch.$$.wav

Por supuesto, sólo para Linux. ¿O que pensabais?