emerge world

Monitorización de procesos: pgrep, pkill y psg

2007-12-29T20:25:00.000+01:00

Muchas veces os habréis encontrado con que queréis matar una aplicación que no responde y al hacer un ps veis que hay varios procesos que pertenecen a la misma aplicación, entonces no que más remedio que matar los procesos uno a uno. Bueno, eso era así antes de conocer pgrep y pkill. pgrep es una herramienta que dado un nombre de proceso muestra por pantalla los pid's de todos los procesos con ese nombre y pkill es su complemento que en lugar de mostrar los procesos los mata directamente.

Ejecutaremos unas cuantas veces yes redirigiendo su salida a /dev/null y poniendo el proceso en background para tener algo con lo que trabajar:


jgr@seiya ~ $ yes &> /dev/null & yes &> /dev/null & yes &> /dev/null &
[1] 3670
[2] 3671
[3] 3672

Si hacemos ahora un ps de los de toda la vida veremos esto (la última línea es el propio grep):


jgr@seiya ~ $ ps aux | grep yes
jgr       3670 42.8  0.0   4164   584 pts/2    R    20:12   0:19 yes
jgr       3671 41.4  0.0   4164   584 pts/2    R    20:12   0:19 yes
jgr       3672 42.8  0.0   4164   584 pts/2    R    20:12   0:19 yes
jgr       4244  0.0  0.0   6368   808 pts/2    S+   20:13   0:00 grep --colour=auto yes

Ahora con pgrep veremos sólo los pid's de los procesos:


jgr@seiya ~ $ pgrep yes
3670
3671
3672

Y con pkill los matamos y con pgrep comprobaremos que estén realmente muertos:


jgr@seiya ~ $ pgrep yes
[1]   Terminado               yes >&/dev/null
[2]-  Terminado               yes >&/dev/null
[3]+  Terminado               yes >&/dev/null

pgrep y pkill tienen algunas opciones interesantes como por ejemplo -l para mostrar el nombre de los procesos (sólo pgrep) o -u/-U para mostrar o matar sólo los procesos del usuario especificado y alguna más que podéis ver en el man de pgrep.

Bueno y ya que estamos con ps os enseñaré un alias que suelo usar en el .bashrc para hacer más cómodo el uso de ps:


export GREP_COLOR="1;32" #verde claro
alias grep='grep --colour=auto'
alias psg="ps aux | grep -v grep | grep"

Básicamente lo que hacen estos alias es colorear las concordancias del grep y eliminar la última línea de la salida del ps que corresponde al propio grep. Aquí podéis ver un ejemplo otra vez con el proceso yes del ejemplo anterior:

Ver páginas de man con vim

2007-12-14T19:17:00.000+01:00

Un sencillo truco para usar vim como paginador de man en dos pasos:

1.- Añadid a vuestro .bashrc


export MANPAGER="col -b | view -c 'set ft=man nomod nolist' -"

2.- Recargad las variables de entorno para poder usarlo en la shell actual:


source ~/.bashrc

Ya está ya podéis usar vi para ver páginas de man ;)

Ésta es la página de dónde he sacado el truco:
Tip #167: Using vim as a man-page viewer under Unix

logs de colores

2007-08-09T13:28:00.000+02:00

Últimamente andaba buscando la forma de colorear la salida de tail para poder leer más fácilmente los logs de mis máquinas. Ayer encontré esta página de"trucos sucios y rápidos" la solución. Para usar el script, copiarlo a algún lugar del PATH de vuestra máquina (p.e. /usr/local/bin) dadle permiso de ejecución y ejecutrarlo de la siguiente manera:


tail -f /var/log/messages | colorlog.pl

Enseguida notaréis la diferencia ;)


#!/usr/bin/perl
 
$black    = "\033[30m";
$red      = "\033[31m";
$green    = "\033[32m";
$yellow   = "\033[33m";
$blue     = "\033[34m";
$magenta  = "\033[35m";
$purple   = "\033[35m";
$cyan     = "\033[36m";
$white    = "\033[37m";
$darkgray = "\033[30m";
@word_good=("starting\n", "Freeing", "Detected", "starting.", "accepted.\n", "authenticated.\n", "Ready", "active", "reloading", "saved;", "restarting", "ONLINE\n");
@word_warn=("dangling", "closed.\n", "Assuming", "root", "root\n", "exiting\n", "missing", "Ignored", "adminalert:", "deleting", "OFFLINE\n");
@word_bad=("bad");
@word_note=("LOGIN", "DHCP_OFFER", "optimized", "reset:", "unloaded", "disconnected", "connect", "Successful", "registered\n");
@line_good=("up", "DHCP_ACK", "Cleaned", "Initializing", "Starting", "success", "successfully", "alive", "found", "ONLINE\n");
@line_warn=("warning:", "WARNING:", "invalid", "obsolete", "bad", "Password", "detected", "timeout", "timeout:", "attackalert:", "wrong", "Lame", "FAILED", "failing", "unknown", "obsolete", "stopped.\n", "terminating.", "disabled\n", "disabled", "Lost");
@line_bad=("DENY", "lost", "shutting", "dead", "DHCP_NAK", "failure;", "Unable", "inactive", "terminating", "refused", "rejected", "down", "OFFLINE\n", "error\n", "ERROR\n", "ERROR:", "error", "ERROR", "error:", "failed:");
@daemons=("named");
$col_good = $green;
$col_warn = $yellow;
$col_bad = $red;
$col_note = $purple;
$col_norm =  "\033[00m";
$col_background = "\033[07m";
$col_brighten =  "\033[01m";
$col_underline =  "\033[04m";
$col_blink =   "\033[05m";
$col_default = "$col_norm$white";
print "$col_norm$cyan";
$datespace=0;
mainloop: while (<>)
{
 $thisline = $_;
 $timestamp = substr($_,0,15);
 s/................//;
 @rec = split (/ /, $_);
 $output="$col_brighten$cyan$timestamp"; 
 $output.=" $col_brighten$blue$rec[0]"; 
 if ($rec[1] eq "last")
 {
  $output.="$col_norm$green last message repeated ";
  $output.="$col_brighten$rec[4]$col_norm$green times\n";
  print "$output$col_default";
  next mainloop;
 }
 if ($rec[1] =~ /\[(\d+)\]\:/)
 {
  my($pid) = $1;
  $rec[1]=~s/\[$1\]\:// ;
  $output .= "$col_norm$green $rec[1]" .
             "$col_brighten$green\[";
  $output .= "$col_brighten$white$pid" .
             "$col_brighten$green\]: ";
 }
 else {
  $output .= "$col_norm$green $rec[1] ";
 }
 $restcolor="$col_norm$cyan";
 $restoftheline="";
 for ($therest=(2); $therest<=$#rec; $therest++)
 { $highlight=0;
  for ($i=0; $i<=$#word_good; $i++)
  { if ($word_good[$i] eq $rec[$therest])
   { $restoftheline.="$col_brighten$col_good"; $highlight=1; }
  }
  for ($i=0; $i<=$#word_warn; $i++)
  { if ($word_warn[$i] eq $rec[$therest])
   { $restoftheline.="$col_brighten$col_warn"; $highlight=1; } 
  }
  for ($i=0; $i<=$#word_bad; $i++)
  { if ($word_bad[$i] eq $rec[$therest])
   { $restoftheline.="$col_brighten$col_bad"; $highlight=1; } 
  }
  for ($i=0; $i<=$#word_note; $i++) 
  { if ($word_note[$i] eq $rec[$therest])
   { $restoftheline.="$col_brighten$col_note"; $highlight=1; } 
  }
  for ($i=0; $i<=$#line_good; $i++)
  { if ($line_good[$i] eq $rec[$therest])
   { $restcolor="$col_norm$col_good";
     $restoftheline.="$col_brighten$col_good"; $highlight=1; }
  }
  for ($i=0; $i<=$#line_warn; $i++)
  { if ($line_warn[$i] eq $rec[$therest])
   { $restcolor="$col_norm$col_warn";
     $restoftheline.="$col_brighten$col_warn"; $highlight=1; }
  }
  for ($i=0; $i<=$#line_bad; $i++)
  { if ($line_bad[$i] eq $rec[$therest])
   { $restcolor="$col_norm$col_bad";
     $restoftheline.="$col_brighten$col_bad"; $highlight=1; }
  }
  $restoftheline.="$rec[$therest] ";
  if ($highlight == 1)
  { $restoftheline.=$restcolor; }
 }
 $output.="$restcolor$restoftheline";
 print "$output$col_default\033[1G";
}
exit(0);

Reasaltado de sintaxis en archivos sin extensión

2007-08-04T17:34:00.000+02:00

Muchas veces os habréis encontrado archivos sin extensión pero que son archivos fuente de algún tipo (scripts de perl, archivos de configuración xml, etc) y que al editarlos con vim aparecen sin resaltado de sintaxis. Esto se soluciona fácilmente con la siguiente orden (en el modo de órdenes de vim):


set filetype=tipo_de_archivo

Por ejemplo para un archivo xml:


set filetype=xml

Usando sysctl para optimizar la pila TCP/IP

2007-07-20T18:47:00.000+02:00

sysctl es una herramienta que nos permite modificar el comportamiento del kernel en vivo. Esto significa que las modificaciones que hagamos se aplican instantaneamente sin tener que reiniciar la máquina. Además si añadimos los cambios que vayamos a hacer al archivo /etc/sysctl.conf estos cambios se aplicarán cada vez que se arranque la máquina. sysctl realiza estos cambios a través del sistema de archivos virtual /proc que permite la comunicación directa con el kernel.

El uso de sysctl es muy sencillo. Para listar las variables que podemos modificar basta con ejecutar:


# sysctl -a
sunrpc.max_resvport = 1023
sunrpc.min_resvport = 665
sunrpc.tcp_slot_table_entries = 16
sunrpc.udp_slot_table_entries = 16
sunrpc.nlm_debug = 0
sunrpc.nfsd_debug = 0
sunrpc.nfs_debug = 0
sunrpc.rpc_debug = 0
...
# He recortado la salida porque es bastante extensa

Como podéis el esquema es "nombre de la variable" = "valor". Muchas de estas variables son boleanas un 0 significa que están deshabilitadas y un 1 que están habilitadas. Si conocemos el nombre de la variable que queremos modificar bastará filtrar la salida de la orden anterior con grep para conocer su valor, p.e:


sysctl -a | grep 'ipv4.ip_forward'
net.ipv4.ip_forward = 1

Para que nuestros cambios sean permanentes y además queden documentados lo mejor es editar el archivo /etc/sysctl.conf. A continuación os pego un ejemplo:


# Hablitar reenvío de paquetes (modo router)
net.ipv4.ip_forward = 1

# Habilitar IP dinámica
net.ipv4.ip_dynaddr = 1

# Deshabilitar ECN (señalizador de congestión en la línea)
net.ipv4.tcp_ecn = 0

# Habilitar verificación del origen de la ruta (ayuda a 
# a prevenir el IP Spoofing)
net.ipv4.conf.default.rp_filter = 1
net.ipv4.conf.all.rp_filter = 1

# Habilitar SYN cookies (protege contra un ataque de desbordamiento
# de paquetes SYN http://cr.yp.to/syncookies.html
net.ipv4.tcp_syncookies = 1

# Deshabilitar enrutamiento de origen (el enrutamiento de origen
# se considera peligroso)
net.ipv4.conf.all.accept_source_route = 0
net.ipv4.conf.default.accept_source_route = 0

# Deshabilitar paquetes de redireccionamiento icmp
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.secure_redirects = 0
net.ipv4.conf.default.secure_redirects = 0

# Ignorar broadcasts icmp
net.ipv4.icmp_echo_ignore_broadcasts = 1

# No loguear paquetes icmp defectuosos
net.ipv4.icmp_ignore_bogus_error_responses = 1

# Desactivar marcas de tiempo. Con conexiones menores de 10mbps 
# son innecesarias
net.ipv4.tcp_timestamps = 0

# Reducir el tiempo tcp_fin_timeout. Reduce el tiempo que 
# permanece el socket abierto al cerrar una conexión.
net.ipv4.tcp_fin_timeout = 25

# Reducir tiempo entre keepalives. Cada cuanto tiempo se deben
# mandar paquetes para mantener abierta una conexión viva pero
# que no está siendo usada.
net.ipv4.tcp_keepalive_time = 1200

# Aumentar el búfer para los paquetes SYN
net.ipv4.tcp_max_syn_backlog = 1024

# Reducir los reintentos de conexión
net.ipv4.tcp_synack_retries = 2
net.ipv4.tcp_syn_retries = 3

Una vez editado el archivo aplicamos los cambios:


# sysctl -p /etc/sysctl.conf
net.ipv4.ip_forward = 1
net.ipv4.ip_dynaddr = 1
net.ipv4.tcp_ecn = 0
net.ipv4.conf.default.rp_filter = 1
net.ipv4.conf.all.rp_filter = 1
net.ipv4.tcp_syncookies = 1
net.ipv4.conf.all.accept_source_route = 0
net.ipv4.conf.default.accept_source_route = 0
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.secure_redirects = 0
net.ipv4.conf.default.secure_redirects = 0
net.ipv4.icmp_echo_ignore_broadcasts = 1
net.ipv4.icmp_ignore_bogus_error_responses = 1
net.ipv4.tcp_timestamps = 0
net.ipv4.tcp_fin_timeout = 25
net.ipv4.tcp_keepalive_time = 1200
net.ipv4.tcp_max_syn_backlog = 1024
net.ipv4.tcp_synack_retries = 2
net.ipv4.tcp_syn_retries = 3

La salida nos muestra los cambios aplicados. Podéis encontrar el significado y lo valores que puede tomar cada variable en este tutorial.

Cómo listar los puertos abiertos de una máquina

2007-07-18T18:36:00.000+02:00

VeRTiTo de A SYSAD BLOG - LINUX y yo hemos llegado a un acuerdo de colaboración por el cual yo traduciré algunos de los posts de su blog que me parezcan interesantes y él hará lo mismo con los míos. Así que empezaré con este pequeño howto del blog de VeRTiTo: list out opened host ports howto.

Los puertos abiertos son normalmente la manera no-física más directa de forzar la entrada remotamente.

Aquí encontraréis varias herramientas y formas para listar los puertos abiertos de vuestras máquinas Linux.

Veamos la primera forma de listar los puertos abiertos y usados:


# netstat -panut | grep LISTEN

Hemos usado la orden grep para filtrar los puertos que escuchan (LISTEN) de la salida de netstat. O también:


# netstat -ntl

Echad un vistazo al resultado de ejecutar la orden anterior:


tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 6536/sshd
tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN 1819/named
tcp 0 0 127.0.0.1:953 0.0.0.0:* LISTEN 1819/named

Tomando como referencia la primera línea esto es lo que significa cada cosa:


0.0.0.0:* = básicamente significa que el puerto está abierto para todas las IP's de la máquina
tcp = es el protocolo usado por el daemon para establecer la comunicación
22 = es el puerto en el que escucha el daemon
sshd = el daemon/servicio que escucha en este puerto

Podéis obtener mas o menos la misma información con la siguiente orden:


# ss -a | grep LISTEN

Cómo listar los puertos abiertos de una máquina

Ahora usaremos un escáner de puertos más potente sobre la IP de nuestro localhost:


# nmap -P0 localhost
Starting Nmap 4.20 ( http://insecure.org ) at 2007-07-17 22:29 WAT
Interesting ports on yourhost.domain.com (127.0.0.1):
Not shown: 1693 closed ports
PORT STATE SERVICE
22/tcp open ssh
53/tcp open domain
778/tcp open unknown
953/tcp open rndc

Nmap finished: 1 IP address (1 host up) scanned in 0.082 seconds

A menudo se dice que nmap es como una navaja suiza para probar posibles puertos abiertos, eso me recuerda también a netcat, pero no vamos a tratar ese tipo de hacking en este blog ;) Vamos a ver algunas opciones más de nmap:


# man nmap

Ejecutad:


# nmap -v localhost

¿Pero cómo podemos comprobar que un puerto está realmente abierto? Eso es fácil de comprobar con una de las más famosas herramientas usadas con Linux y routers:


# telnet localhost 22

Haced telnet al puerto 22 de vuestro localhost para ver si el puerto está realmente abierto.

Si el puerto está realmente abierto conectaréis con el daemon que escuche ese servicio que estará esperando vuestras ordenes. Apretad ctrl+J, intro y salid. ¡No os habéis conectado para hacer nada malo!

Ahora, ya podéis listar los puertos abiertos y desarrollar herramientas más fiables y conseguir más información sobre vuestras máquinas y sus puertos usando estas ordenes de Linux.

Recordad que las ordenes de Linux que hemos usado tienen más opciones que las que hemos visto aquí.

¡Qué tengáis un buen día!

Go To The English Version

check_mcpu (II)

2007-07-17T22:37:00.000+02:00

Nueva versión de este plugin de Nagios para comprobar el uso de CPU en máquinas multiprocesador o de un sólo procesador. Le he añadido la opción -u para que en lugar de comprobar la CPU libre (modo predeterminado) compruebe la CPU usada. Esto será de ayuda para la gente como yo a la que le cueste restar ;)

En el modo predeterminado (modo CPU libre) si quieres saber cuanta CPU está usando la máquina tienes que restar de 100 la CPU usada, lo cual no me parece muy intuitivo, pero la mayoría de programas que he visto para monitorizar CPU's muestran la cantidad de CPU libre. Bueno, ahora al menos en este plugin ya podéis escoger como ver el uso de vuestras CPU's ;)


Este plugin comprueba la cantidad de CPU usada o libre (la opción predeterminada es libre) para múltiples procesadores. Todos los argumentos son opcionales

Uso: check_mcpu [-w | --warning]  [-c | --critical]  [-r | --reports]  [-i | --interval] 
       check_mcpu -u | --used [-w | --warning]  [-c | --critical]  [-r | --reports]  [-i | --interval] 
       check_mcpu -h | --help

-c | --critical
  Termina con estado CRITICAL si la cantidad de CPU libre es inferior al valor en tanto por ciento.
 En modo CPU usada termina con CRITICAL si la cantidad de CPU usada es superior al valor en tanto por ciento.
  Valor predeterminado: 10
  Valor predeterminado en modo CPU usada: 90

-w | --warning
 Termina con estado WARNING si la cantidad de CPU libre es inferior al valor en tanto por ciento.
 En modo CPU usada termina con WARNING si la cantidad de CPU usada es superior al valor en tanto por ciento.
  Valor predeterminado: 10
  Valor predeterminado en modo CPU usada: 90

-i | --interval
 Tiempo en segundos entre pasadas de mpstat.
 Valor predetermindado 1

-r | --reports
 Número de pasadas por intervalo de segundos de mpstat.
 Valor predetermindado 1

-u | --used
 Comprueba la cantidad de CPU usada en vez de la CPU libre.


-h | --help
  Muestra esta ayuda.

Este plugin depende del paquete sysstat:
http://perso.orange.fr/sebastien.godard/index.html

Como siempre os podéis bajar el plugin de Nagios Exchange: check_mcpu

Localiza el país de una IP desde la cónsola

2007-07-16T17:26:00.000+02:00

Esta mañana leyendo el blog de Vertito he visto que hablaba sobre geoip de la empresa MaxMind. geoiplookup es una utilidad de línea de comandos incluida en el paquete geoip que nos permite conocer el país de origen de cualquier dirección IP o hostname. Su uso es muy sencillo, p.e:


$ geoiplookup 64.233.183.103
GeoIP Country Edition: US, United States

La versión de la base de datos que viene con la última versión estable para gentoo (1.4.0-r1) es de agosto del año pasado. No es la base de datos comercial que puedes comprar en la página de MaxMind que se llama GeoIP Country sino su hermana pequeña y gratuita GeoLite Country. También hay versiones que afinan más la procedencia hasta la ciudad o región pero éstas son de pago.

Para saber que base de datos usa geoip:


$ geoiplookup -v
GEO-106FREE 20060801 Build 1 Copyright (c) 2006 MaxMind LLC All Rights Reserved

Esta utilidad está sobretodo orientada a webmasters y ya está integrada en algunas herramientas de estadísticas web como awstats. Pero siempre es curioso tenerla a mano para nuestras pequeñas investigaciones sobre la red ;)

check_openvpn_pl

2007-07-15T18:36:00.000+02:00

Este plugin de Nagios comprueba el estado de los clientes conectados a un servidor OpenVPN mediante la interfaz de gestión del mismo. Para habilitar la interfaz de gestión en el servidor tenéis que incluir una línea como la siguiente en su archivo de configuración:


management IP port [pw-file]

Actualmente se accede a la interfaz de gestión mediante telnet sin ningún tipo de seguridad adicional por lo que se recomienda configurar la interfaz de gestión para que use la dirección local del túnel vpn o el localhost (127.0.0.1). Podéis encontrar más información sobre la interfaz de gestión aquí.

Las opciones -H (IP o hostname del servidor) y -p (puerto del servidor) son obligatorias siempre. Si el plugin puede conectarse con la interfaz de gestión mostrará el nombre común (tal como se especifica en el certificado de cliente) de los clientes conectados. Si no, terminará con estado crítico. La opción -i muestra las IP remota del cliente en vez de su nombre y la opción -n muestra el número de clientes conectados.

Se puede comprobar que un cliente en concreto esté conectado usando una de estas dos opciones -C (nombre común) o -r (IP remota). Si se usan estas opciones, también se debe especificar el estado de salida que devolverá el plugin si no encuentra el cliente mediante las opciones -w (warning) -c (critical).

Ejemplos de uso:


# Uso básico: devuelve los nombres de los clientes conectados la opción -t (timeout) es opcional el valor predeterminado es 10
check_openvpn -H 192.168.10.1 -p 1195 -P mipassword -t 5
OpenVPN OK: cliente1 cliente2

# Devuelve las IP's remotas de los clientes en vez de los nombres
check_openvpn -H 192.168.10.1 -p 1195 -P mipassword -i
OpenVPN OK: 192.168.0.5 192.168.0.15

# Devuelve el número de clientes conectados.
check_openvpn -H 192.168.10.1 -p 1195 -P mipassword -n
OpenVPN OK: 2 connected clients.

# Comprueba si cliente1 está conectado y si no devuelve warning
check_openvpn -H 192.168.10.1 -p 1195 -P mipassword -C cliente1 -w
OpenVPN OK: cliente1 cliente2

# Comprueba si la máquina con IP 192.168.0.15 está conectada y si no devuelve critical
check_openvpn -H 192.168.10.1 -p 1195 -P mipassword -r 192.168.0.15 -c
OpenVPN OK: 192.168.0.5 192.168.0.15

Os podéis bajar el plugin de Nagios Exchange: check_openvpn_pl

pinfo: otra forma de consultar info

2007-07-12T19:03:00.000+02:00

Si sois como yo seguro que odiáis las páginas de info, ya sabéis, el formato de documentación del proyecto gnu. A mí, siempre me ha parecido muy engorrosa la navegación a través de estas páginas y siempre terminaba consultado las man (si es que las había) aunque no fuesen tan completas. Pues bien,con pinfo se acabo el sufrimiento.

pinfo ofrece coloración de enlaces y navegación entre enlaces mediante los cursores semejante a lynx lo cual hace la navegación muy intuitiva. Esta es la página info de grub vista con info:

Y aquí la misma página vista con pinfo, en esta segunda toma los enlces están coloreados de azul y así es más fácil distinguirlos:

Si queréis olvidaros definitivamente del "horrible" info añadid a vuestro .bashrc (sin comillas) "alias info=pinfo" así cada vez que ejecutéis info, realmente estaréis ejecutando pinfo.

Auditoría de vulnerabilidades en Gentoo

2007-07-09T19:54:00.000+02:00

glsa significa Gentoo Linux Security Advisory que podríamos traducir por Asesor de Seguridad de Gentoo Linux. Es un sistema para informar de vulnerabilidades en los paquetes instalados en sistemas Gentoo/Linux. A continuación os mostraré como montar un sistema que audite diariamente nuestra máquina y nos envié un mail a una cuenta de gmail con el resultado de la auditoría.

Esto yo lo tengo montado en una máquina que hace de router para mi red. Este ejemplo es aplicable en el caso de que no dispongamos de un servidor de correo propio. Si tuvieramos servidor de correo podríamos enviar los resultados de la auditoría directamente a través de glsa-check.

Para poder enviar mails a gmail tendréis que instalar el paquete sendEmail. También debéis instalar el paquete gentoolkit que es el que contiene la herramienta glsa-check. A continuación crearemos un script para enviar los mails, lo podemos llamar por ejemplo /usr/local/bin/smail.sh


#!/bin/sh

SE=/usr/bin/sendEmail
TOMAIL=my@gmail.com  # la cuenta desde la que enviamos el mail
MAIL=myother@gmail.com  # la cuenta en la que lo recibiremos
MAILSERVER=smtp.gmail.com:587
MAILUSER=myuser # el usuario de la cuenta desde que enviamos el mail
PASSFILE=/root/.mypass # archivo que contiene el password de la cuenta desde la que enviamos el mail (chmod 400) 


while getopts s:a:m: OPTIONS; do
  case "$OPTIONS" in
    s) SUBJECT=$OPTARG;;
    a) ATTACHMENT=$OPTARG;;
    m) MESSAGE=$OPTARG;;
  esac
done

if [ ! -z "$MESSAGE" ]; then
  $SE -t $TOMAIL -f $MAIL -s $MAILSERVER -xu $MAILUSER -xp $(cat $PASSFILE) -o tls=yes -u "$SUBJECT" -m "$MESSAGE"
else
  $SE -t $TOMAIL -f $MAIL -s $MAILSERVER -xu $MAILUSER -xp $(cat $PASSFILE) -o tls=yes -u "$SUBJECT" -o message-file="$ATTACHMENT"
fi

# die gracefully
exit 0

Añadimos la siquiente línea a /etc/crontab para ejecutar glsa-check cada noche a las 00:15h y que nos envíe el mail:


15  0 * * * root /usr/bin/glsa-check -t all &> /var/log/glsa && /usr/local/bin/smail.sh -s "glsa" -a /var/log/glsa

Enlaces:
Sitio de glsa
glsa feed

Vim Plugin: template file loader

2007-07-05T23:05:00.000+02:00

Éste plugin nos permite cargar una plantilla en un archivo al empezar a editarlo con vim. Por ejemplo, siempre que empiezas a escribir un nuevo script de perl (o de cualquier otra cosa) tienes que escribir las mismas cosas, el interprete (shebang!), los módulos que vas a usar, información de la licencia (si usas) etc. ¿No sería maravilloso tener una plantilla con todo eso que se repite siempre y no tener que escribirlo una y otra vez? Pues eso es precisamente lo que hace "template file loader" para ti ;)

Por cada nuevo archivo que edites este plugin busca si tienes una plantilla que concuerde con la extensión del archivo. Las plantillas son unos archivos llamados skel.* (donde * es la extensión que debe coincidir) que se guardan en el directorio $HOME/.vim/templates.

La instalación es muy sencilla, sólo tienes que descomprimir el tar.gz y mover los directorios plugin y templates a tu directorio $HOME/.vim/

Os podéis bajar el plugin desde aquí: template file loader

Aquí os dejo mi plantilla para los scripts de perl, skel.pl:


#!/usr/bin/perl -w

#######################################################################
#
# Copyright (c) 2007 Jaime Gascon Romero 
#
# License Information:
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .
#
# $Id:$
# $Revision:$
# #####################################################################

use diagnostics;
use strict;

# vim:sts=2:sw=2:ts=2:et

check_mcpu

2007-07-04T18:40:00.000+02:00

Éste es un plugin de nagios para comprobar el uso de las cpus de una máquina. Sirve tanto para máquinas con un sólo procesador como para máquinas con múltiples procesadores. Comprueba individualmente cada cpu y devuelve 'critical' o 'warning' si el tanto por ciento de cpu libre es menor que el de los valores que le pasemos. El plugin usa la herramienta mpstat que viene en el paquete sysstat.

Todos los argumentos son opcionales así que lo podemos usar sin pasarle ningún argumento.Los valores predeterminados son: warning = 20, critical = 10, reports = 1, interval = 1. Para saber que significan los dos últimos valores podéis consultar la página man de mpstat, pero básicamente son las pasadas que realiza mpstat para determinar el uso de cpu (reports) y los segundos entre pasadas (interval).

Al estar escrito en perl usa alguna funciones del módulo utils.pm que viene con el paquete nagios-plugins. Aseguraos que el valor de 'use lib "/usr/nagios/libexec";' sea el correcto para vuestra máquina.

Si al ejecutar el plugin os responde lo siguiente: "Strange mpstat output: install mpstat without nls support.", tenéis dos opciones:

1.- Instalar sysstat sin soporte para nls (native language support).
2.- Cambiar "Average:" en la línea 81 por lo que veáis al ejecutar 'mpstat -P ALL 1 1'. Seguramente sera algo así como "Media: ".

Podéis bajaros el plugin desde Nagios Exchange: check_mcpu.

print "Hello world!\n";

2007-07-04T18:00:00.000+02:00

No he podido resistirme ;)

Una de las cosas que me impulsó a usar Linux, hace ya unos cuantos años , fue el contenido social de las propuestas de la Free Software Foundation, GNU y toda la comunidad del software libre en general. Siempre me ha parecido muy atractiva la idea de estos hackers de que el conocimiento tiene que ser libre y compartido universalmente.

Pues bien, después de tanto tiempo de usar software libre ya es hora de devolver, aunque sea poco, a esta comunidad. Desde aquí compartiré pequeñas guías, trucos y scripts para facilitar la vida a todos aquellos que usamos Linux.

#EOF