Mostrando entradas con la etiqueta GNU Linux. Mostrar todas las entradas
Mostrando entradas con la etiqueta GNU Linux. Mostrar todas las entradas

martes, 9 de agosto de 2016

Primer prototipo LoadBalancer con IPtables

El siguiente script en bash es el primer prototipo de LoadBalancer para un servicio TCP en dos o mas servidores simultaneamente utilizando iptables.
#!/bin/bash
local_ip="10.10.50.81"

ip1="10.10.96.50"
ip2="10.10.50.106"
tcp_port="80"


#Se valida que los servicios esten disponibles
nmap $ip1 -p $tcp_port | grep -i open >> /dev/null
service1=$?
nmap $ip2 -p $tcp_port | grep -i open >> /dev/null
service2=$?
let status=$service1+$service2
echo "Valor: $status"
let remakerules=10

while [ 0 -eq 0 ]; do

        if [ "$remakerules" != "$status" ]; then
                # You need these system settings.
                echo 1 > /proc/sys/net/ipv4/ip_forward
                for f in /proc/sys/net/ipv4/conf/*/rp_filter ; do echo 1 > $f ; done

                # Clear iptables/netfilter settings.
                iptables -F
                iptables -X
                iptables -t nat -F
                iptables -t nat -X
                iptables -t filter -F
                iptables -t filter -X
                iptables -t mangle -F
                iptables -t mangle -X


                iptables -P INPUT ACCEPT
                iptables -P OUTPUT ACCEPT
                iptables -P FORWARD ACCEPT
                iptables -t nat -P PREROUTING ACCEPT
                iptables -t nat -P POSTROUTING ACCEPT

                if [ "$service1" == "0" -a "$service2" == "0" ]; then
                        #Los dos servicios estan disponibles
                        iptables -t nat -A PREROUTING -p tcp -d $local_ip --dport $tcp_port -m state --state NEW -m statistic --mode random --probability .5 -j DNAT --to $ip1:$tcp_port
                        iptables -t nat -A PREROUTING -p tcp -d $local_ip --dport $tcp_port -m state --state NEW -m statistic --mode random --probability .5 -j DNAT --to $ip2:$tcp_port
                else
                        if [ "$service2" == "0" ]; then
                                #Unicamente el servicio2 esta arriba
                                iptables -t nat -A PREROUTING -p tcp -d $local_ip --dport $tcp_port -m state --state NEW -m statistic --mode nth --every 1 --packet 0 -j DNAT --to $ip2:$tcp_port
                        else
                                if [ "$service1" == "0" ]; then
                                        #Unicamente el servicio1 esta arriba
                                        iptables -t nat -A PREROUTING -p tcp -d $local_ip --dport $tcp_port -m state --state NEW -m statistic --mode nth --every 1 --packet 0 -j DNAT --to $ip1:$tcp_port
                                else
                                        echo "CRITICAL: Los dos Servicios estan abajo"
                                fi
                        fi
                fi


                iptables -A INPUT -j ACCEPT
                iptables -A OUTPUT -j ACCEPT
                iptables -A FORWARD -j ACCEPT
                iptables -A INPUT -j LOG --log-prefix "iptables: " --log-level 4
                iptables -A OUTPUT -j LOG --log-prefix "iptables: " --log-level 4
                iptables -A FORWARD -j LOG --log-prefix "iptables: " --log-level 4

                iptables -t nat -A POSTROUTING  -j MASQUERADE
                echo "Cambio de reglas..."
        fi

        #sleep 1200
        sleep 1

        #Se valida que los servicios esten disponibles
        nmap $ip1 -p $tcp_port | grep -i open >> /dev/null
        service1=$?
        nmap $ip2 -p $tcp_port | grep -i open >> /dev/null
        service2=$?
        let remakerules=$status
        let status=$service1+$service2
        echo "Valor: $status"

done

miércoles, 30 de mayo de 2012

Enviar y recibir correo desde nuestro GNU Shell con fetchmail y ssmtp

En este ultimo par de días, me ha tocado realizar algunas pruebas de correo electrónico, por lo que creo que tengo un poco de información agrupada aquí que les puede servir para manejar básicamente un correo electrónico desde nuestro shell (en mi caso mis pruebas son con bash).

Para enviar correo electrónico usamos el protocolo smtp, por lo tanto requerimos un servidor que ofrezca este servicio. Por otro lado, en cuanto a la recepción de correo nos apoyamos de los servidores pop. Conocer un poco mas de estos detalles es importante a la hora de comenzar nuestro trabajo de configurar un cliente de correo cualquiera que este sea. En nuestra practica vamos a configurar una cuenta de Gmal. A continuación les dejo un muy breve listado con algunos servidores.


Propietario Servidor Protocolo Cifrado Puerto
Gmail imap.googlemail.com imap ssl 993
Gmail pop.googlemail.com pop3 ssl 995
Gmail smtp.googlemail.com smtp ssl 465
Yahoo imap.mail.yahoo.com imap ssl 993
Yahoo pop.mail.yahoo.com pop3 ssl 995
Yahoo smtp.mail.yahoo.com smtp ssl 465
Hotmail pop3.live.com pop3 ssl/tls 995
Hotmail smtp.live.com smtp starttls 587


1. Enviar correo
En el envió de correo vamos ocupar instalar un agente de envió: ssmtp. Es un paquete muy básico y simple: ssmtp. Primero hacemos la instalación y luego modificamos su archivo de configuración.

user@localhost:~$ sudo apt-get install ssmtp
user@localhost:~$ sudo vim /etc/ssmtp/ssmtp.conf


En la configuración tenemos que especificar correo electrónico, contraseña para identificarnos, servidor smtp, tipo de cifrado, etc. A continuación les muestro parcialmente mi archivo ssmtp.conf.

root=martingmail@gmail.com
mailhub=smtp.gmail.com:587
AuthUser=martingmail
AuthPass=xxxxxxxxxx
UseSTARTTLS=YES
FromLineOverride=YES
rewriteDomain=
hostname=martingmail@gmail.com


Una vez configurado los datos de la cuenta, asociamos el correo con una cuenta local de nuestro sistema en el archivo /etc/ssmtp/revaliases, eso lo hacemos colocando la siguiente linea "martin:martingmail@gmail.com:smtp.gmail.com:587".

Si nuestra configuracion y atutentificacion es correcta ya podemos enviar correos con mail command.

#Envio de correo, con redaccion interactiva
mail -s "Mi primer correo" miamigo@sudominio.org
#Envio de correo con redaccion desde el mismo shell
echo "Hola" | mail -s "Mi primer correo" miamigo@sudominio.org
cat miarchivo.txt | mail -s "Mi primer correo" miamigo@sudominio.org
#Enviar correo con archivo adjunto
uuencode ~/mifoto.png mifoto.png | mail -s "Mi foto" milindaamiga@sudominio.org
#Enviar correo con archivo adjunto y texto
( cat declaraciondeamor.txt ; uuencode ~/mifoto.png mifoto.png ) | mail -s "Mi foto" milindaamiga@sudominio.org


Para el caso donde adjuntamos archivos el comando uuencode lo encontramos en el paquete sharutils, por lo que tendríamos que instalarlo también.

2. Recibir correo
Fetchmail es un programa que nos ayuda a traer los nuestros correos de un mail server remoto, por lo tanto es el que no va a traer los correos de nuestro buzón gmail. El siguiente paso es instalar fechtmail y configurar su archivo:

user@localhost:~$ sudo apt-get install fetchmail
user@localhost:~$ sudo vim ~/fetchmailrc


El siguiente es mi archivo de configuración parcial (¿Por que parciales?, por que no puedo mostrar mis datos personales)

#Cada 600 segundos actualizar
set daemon 600
set logfile fetchmail.log
poll pop.googlemail.com proto POP3
user "martingmail@gmail.com" pass "xxxxxxxxx" is "martin"
ssl
mda "/usr/bin/procmail -f %F -d %T"


Ya configurado esto, podemos leer los correos con el mail command, y hacer las operaciones básicas que este nos ofrece, principalmente la redacción y respuesta de correos. El uso de comandos internos del mail command, no lo voy a tratar aquí ya que es un tema muy extenso y no lo domino ampliamente, por lo que en ese aspecto les tocara investigar.

lunes, 7 de mayo de 2012

Construcción de Plugin Nagios/Centreon para HP Printer

Hace unas horas termine un script en bash para monitorear los consumibles de unas impresoras HP, la idea de agregarlas a centreon es para darnos conocer en buen momento cuando uno de los consumibles se están por terminar así como un histórico (usando las graficas) de cuanto se esta consumiendo. A posteriori, este script se tendría que poder usar en cualquier impresora HP con SNMP activado, los modelos de impresoras que tenemos son las siguientes:
  • HP LaserJet 4700 Color
  • HP LaserJet 4600 Color
  • HP LaserJet 4250
Requerimientos del script:
  • awk
  • snmpwalk
  • A nivel de red, acceso al segmento de las impresoras.
  • bash
  • etc.
#!/bin/bash
# Martin Barriga 2012

# Default options
COMMUNITY="public"
HOSTNAME="127.0.0.1"
CONSUMMABLE="black"
WARNING=20
CRITICAL=10
SNMPVERSION=2c
SHEETCOUNT="0"
sheetcount=""

#used MIBs
MAINMIB="mib-2.43.11.1.1.6.1"
SHEETMIB="enterprises.11.2.3.9.4.2.1.4.1.10.5.1.1"

# Plugin return codes
STATE_OK=0
STATE_WARNING=1
STATE_CRITICAL=2
STATE_UNKNOWN=3

# Option processing
function phelp {
  echo -e "Usage: $0 -H  -C  -v  -o  -w  -c   [ -l | -s ] | -h "
  echo -e "  -H IP Addres HP Printer"
  echo -e "  -C SNMP Community. Default 'public'"
  echo -e "  -v SNMP Version. Default '2c'"
  echo -e "  -o Color Tonner: black, cyan, magenta, yellow, transfer, fuser. Default 'black'"
  echo -e "  -w Warning Value. Default '80'"
  echo -e "  -c Critical Value. Default '90'"
  echo -e "  -l List consumible support."
  echo -e "  -s Print with sheet count available."
  echo -e "  -h Help, this message.\n"
}

function list {
        allinfo=`snmpwalk -c $COMMUNITY -v $SNMPVERSION $HOSTNAME $MAINMIB`;
        echo "$allinfo" | ( while read line; do
                echo $line | cut -d "\"" -f2;
        done )
}

function withsheetcount {
        index=`echo "$1" | cut -d "." -f8`;
        count=`snmpwalk -c $COMMUNITY -v $SNMPVERSION $HOSTNAME $SHEETMIB.$index | cut -d " " -f4`;
        sheetcount=", Sheet Available: $count";
}

while getopts H:C:v:o:w:c:slh OPT
do
  case $OPT in
    H) HOSTNAME="$OPTARG" ;;
    C) COMMUNITY="$OPTARG" ;;
    v) SNMPVERSION="$OPTARG" ;;
    o) CONSUMMABLE="$OPTARG" ;;
    w) WARNING=$OPTARG ;;
    c) CRITICAL=$OPTARG ;;
    s) SHEETCOUNT="1" ;;
    l)
       list
       exit $STATE_UNKNOWN
    ;;
    h)
       phelp
       exit $STATE_UNKNOWN
    ;;
    #V)
    #  print_version
    #  exit $STATE_UNKNOWN
    #  ;;
   esac
done

info=`snmpwalk -c $COMMUNITY -v $SNMPVERSION $HOSTNAME $MAINMIB | grep -i $CONSUMMABLE`
if [ "$info" != "" ]; then
        name=`echo "$info" | cut -d "\"" -f 2`;
        mib=`echo "$info" | cut -d " " -f 1 | cut -d ":" -f 3`;
        newmib=`echo "$info" | cut -d " " -f 1 | cut -d ":" -f 3 | awk -F. -v OFS=. '{$6=8}1'`;
        size=`snmpwalk -c $COMMUNITY -v $SNMPVERSION $HOSTNAME $newmib | cut -d " " -f4`;
        newmib=`echo "$info" | cut -d " " -f 1 | cut -d ":" -f 3 | awk -F. -v OFS=. '{$6=9}1'`;
        value=`snmpwalk -c $COMMUNITY -v $SNMPVERSION $HOSTNAME $newmib | cut -d " " -f4`;
        let porcent=($value*100)/$size;

        #If sheet count is required
        if [ "$SHEETCOUNT" = "1" ]; then
                withsheetcount $mib
        fi

        if [ "$porcent" -le "$CRITICAL" ]; then
                echo "$name: Status: $value/$size $porcent% available [ CRITICAL ] | size=$size used=$value";
                exit $STATE_CRITICAL;
        else
                if [ "$porcent" -le "$WARNING" ]; then
                        echo "$name: Status: $value/$size $porcent% available [ WARNING ] | size=$size used=$value";
                        exit $STATE_WARNING;
                else
                        echo "$name: Status: $value/$size $porcent% available [ OK ] | size=$size used=$value";
                        exit $STATE_OK;
                fi
        fi
else
        echo "No se encuentra consumible $CONSUMMABLE en $HOSTNAME [ UNKNOW ]"
        exit $STATE_UNKNOWN
fi

martes, 24 de abril de 2012

LPIC en México


Debo comentar que me encuentro en los pasos finales de alcanzar el nivel 1 de LPIC (Linux Professional Institute Certification). Para lograr la certificación LPIC-1, es necesrio la acreditacion de dos examenes 101 y 102.

Hace meses mis dudas eran ¿Cuanto cuesta? ¿Donde me certifico? ¿Cuanto se tardan los resultados en llegar?. Despues de enviar varios correos en algunas empresas de México e instituciones LPI fuera de México y basandonos en mi propia experiencia les dejo mis propias respuestas.

¿Cuanto cuesta?
El precio por cada examen es $160 dolares, en este momento es algo asi como $2,100 pesos. En algunas empresas de México me llegaron a cotizar en $3,500 + iva, no voy a decir nombres. El pago se realiza con tarjeta.

¿Donde me certifico?
Amablemente personas de LPI España recomendaron que todo aspirante debera registrarse en algunos de los dos centros de certificacion internacional VUE y Prometric, en ambos casos se requiere un registro previo en la pagina Oficial de LPI, para que se genere un LPI ID. En los centros de certificacion, el aspirante debera de buscar un lugar donde pueda aplicar el examen mas cercano a su region o donde el quiera.

¿Cuanto se tardan los resultados en llegar?
Las empresas de México me comentaron que los paquetes se tenia que enviar a Brasil y que los resultados eran de 2 a 3 meses. En la Universidad donde realize el examen, me lo aplicaron en linea, y los resultados fueron inmediatamente despues de mi ultimo clic en el boton de finalizar.

¿Recomendaciones?
Estudiar mucho.

martes, 27 de marzo de 2012

Exportando M$ Active Directory a MySQL

El siguiente script me ayudo para exportar las cuentas de Active Directoy a una base de datos en MySql. El problema y/o interés surgió debido a la implementación de otrs, una solución para la gestión de servicios IT y help desk, donde se pretendía centralizar las cuentas locales de Active Directory como clientes en el contexto de la aplicación (otrs).
Para la solución de este problema (pensando en la automatización) había que hacer dos cosas, llenar la tabla de clientes con los datos de cada cuenta en la base de datos y cambiar el tipo de autentificación usando ldap.

Requisitos:
  • awk
  • openLdap
  • mysql-client

Script: ldap2mysql.sh

#!/bin/bash
# Martin Edmundo 2012
# Orden del listado AD: sn, givename, userPrincipalName

#Inicialización de variables
dbUser="otrs";
dbPasswd="/Gvxsn1CFaj5Q";
dbName="otrs";
let _i=0;

searchBase="DC=PGJ,DC=MICH";
bindDistinguishedName="account@domain";
ldapPasswd="AcbjdaIQ6P/9g";
ldapHost="ldap://172.16.1.2";

apellido="";
nombre="";
user="";

#Leemos el arbol completo de usuarios
tree=`ldapsearch -x -z 0 -b $searchBase -D $bindDistinguishedName -w $ldapPasswd "(objectclass=user)" -H $ldapHost | egrep "userPrincipalName|givenName|sn\: "`

#Leemos el ultimo customer_id que se tiene en la BD, sobre ese se incrementaran los siguientes INSERT
let lastCustomer=`mysql -u $dbUser -p$dbPasswd --database=$dbName --execute="select max(customer_id) as a from customer_user" | awk 'BEGIN{FS="\n"; RS="\n\n";}{print $2}' `

echo "$tree" | (
while read linea;
do
te_conozco=`echo $linea | cut -c1-2`
if [ "$te_conozco" = "sn" ]; then
apellido=`echo $linea | cut -f2 -d" "`;
fi
if [ "$te_conozco" = "gi" ]; then
nombre=`echo $linea | cut -f2 -d" "`;
fi
if [ "$te_conozco" = "us" ]; then
user=`echo $linea | cut -f2 -d" "`;
if [ "$apellido" != "" -a "$nombre" != "" ]; then
let lastCustomer+=1;
uid=`echo $user | cut -f1 -d"@"`
daleDale=`mysql -u $dbUser -p$dbPasswd --database=$dbName --execute="select login from customer_user where login='$uid'" | awk 'BEGIN{FS="\n"; RS="\n\n";}{print $2}'`

#Si la cuenta no esta ya registra en DB, se hace el INSERT
if [ "$daleDale" == "" ]; then
let _i+=1;
sqlStm="INSERT INTO customer_user (login, email, customer_id, pw, title, first_name, last_name, valid_id, create_time, create_by, change_time, change_by) VALUES ('$uid', 'informaticapgjmich@gmail.com',$lastCustomer, '', 'Importado por openLdap', '$nombre', '$apellido', 1, '2012-03-23 20:00:00', 1, '2012-03-23 20:00:00', 1)";
#echo "$sqlStm"
mysql -u $dbUser -p$dbPasswd --database=$dbName --execute="$sqlStm";
echo "*** Importado ($_i): $uid"
fi

fi
apellido="";
nombre="";
fi
done
)

jueves, 31 de marzo de 2011

Sintesis: Exploring Linux Command-Line Tools

Brevemente solo quiero presentar una sintesis del primer capitulo de la Guía LPI Exploring Linux Command-Line Tools. Son algunos comandos para manupulación de archivos de texto.

cat:
-E final de linea con $
-n numero de linea (incluso lineas vacias)
-b numero de linea

join: combina dos archivos por algun campo en común.
join listing1.1.txt listing1.2.txt (defecto campo 1)
join -1 3 -2 2 people.txt numbers.txt (archivo 1 campo 3)

paste: combina dos archivos (linea a linea).
paste listing1.1.txt listing1.2.txt

expand: cambia los tabs a espacios en blanco

od: nuestra un archivo en formato octal
od listing1.2.txt

sort: Ordena listados.
-i Ignora si son mayusculas o munisculas.
-r Orden invertido
-k ¿por cual campo hacemos el ordenamiento?
sort -k 3 listing1.1.txt

split: Divide un archivo en dos o mas archivos. Se le pasa el prefix.
-b Los divide por tamaño en bytes
-l Por lineas
split -l 2 listing1.1.txt numbers

tac: concantena archivos pero con lineas en orden invertidos. Aplicando tac a cada archivo y despues concantena.

tr: Remplaza caracteres los del SET1 con el equivalente del SET2
-t Trunca el SET1 al SET2
-d Elimina los caracteres del SET1
[:alnum:] (all numbers and letters)
[:upper:] (all uppercase letters)
[:lower:] (all lowercase letters)
[:digit:] (all digits).
tr BCJ bc < listing1.1.txt

unexpand: Convierte los multiples espacios a tabs.

uniq: Elimina elementos duplicados de una lista.

fmt: Formato para archivos con lineas muy largas o irregulares.

nl: Enumerar las lineas.

pr: Formato para imprimir


head: Muestra el encabezado de archivos
head -n 10 file.txt

tail: Muestra la cola de un archivo.
tail -n 10 file.txt
tail -f file.txt

cut: Extrae porciones de texto de la su STDIN y lo manda a su STDOUT, por columnas

cat file1.txt | cut -c 2-
ifconfig eth0 | grep HW | cut -d " " -f 11

wc: Contador de palabras.
-l Lineas.
-w Palabras.
-c Bytes.
-m Caracteres.
-L Longitud de la linea mas larga.

domingo, 20 de marzo de 2011

Limitando los recursos de Tomcat.

Hace unos meses trabajando con OpenLaszlo 4.9 y Tomcat 5.0 en mi vieja notebook Compaq v2617la de 512Mb Ram, dramáticamente me estaba quedando sin memoria muy seguido, esto debido a los procesos que podemos ver en la siguiente expresión:
Mysqld + browser (iceweasel) + Apache + Laszlo = Frustración, tristeza y desesperación.

El proceso Tomcat que inicialmente era propiedad del root, causaba que al terminarse la Ram, comenzara a tener una gran demanda en el uso del SWAP al extremo de provocarme síntomas parecidos a los provocados en DoS, por el uso intensivo del disco. Las medidas que aplicamos fueron:
  • Aumentar la memoria Swap ( ver ).
  • Cambiar a un browser mas ligero (google-chrome).
  • Cambiar a un windowmanager mas ligero (Fluxbox).
  • Cambiar a un reproductor mp3 mas ligero (mpg123).
  • Limitar los umbrales de recursos disponibles de Tomcat ( ver ).
  • Crear el usuario "tomcat", limitarlo en el uso de consumo de memoria, y entregarle permisos sobre el servicio Tomcat.
Los umbrales para la configuración de recursos de tomcat los ajuste en uno de los scripts de inicio del mismo tomcat $CATALINA_HOME/bin/catalina.sh.
Cambiando el parámetro export JAVA_OPTS="-Xms128m -Xmx512m $JAVA_OPTS" por export JAVA_OPTS="-Xms128m -Xmx256m $JAVA_OPTS".

Para limitar los recursos del sistema usados por el usuario tomcat, en su archivo ~.bashrc colocarle ulimit -m 200000, para que solo tome 200mb como memoria maxima.

Estos ajustes los realize como ambiente de pruebas, mismos que hasta ahora me han ayudado a trabajar mas feliz.

domingo, 27 de febrero de 2011

Agregando mas SWAP en Volumen Logico

En últimos días el trabajo en mi viejo equipo portátil se ha vuelto un poco pesado por lo escaso de mi memoria Ram, para mi desgracia DDR (costosa y un poco mas difícil de conseguir).

Como alternativa de prueba, se me ocurrió aumentar tamaño de mi memoria swap. Vamos a ver como esta la situacion actual:

Tenemos 512Mb en Ram y 256Mb en Swap (Aun sigo reprochándome por que deje tan poco). Afortunadamente como medida preventiva cuando me instale este sistema deje un Volumen Lógico con algunos sistemas de archivos y espacio libre en el volumen.

Algoritmo:
1. Por cuestiones de seguridad en la integridad de datos, se recomienda desmontar todos los sistemas de archivos usados para realizar cambios en el volumen. Así que la recomendación es reiniciar, login como root, detener todos los servicios, desmontar sistemas de archivos en el volumen. Para esto nos podemos apoyar del comando lsof buscando procesos haciendo uso de directorios.

2. Crear el espacio que necesitamos adentro del volumen. En mi caso definimos un espacio de 512Mb en el volumen volgrp01:
Poseidon:~# lvcreate -L 512M volgrp01

3. Verificar el tamaño creado y el dispositivo asignado, solo mostraremos un resumen de la salida:
Poseidon:~# lvdisplay
...
--- Logical volume ---
LV Name /dev/volgrp01/lvol0
VG Name volgrp01
LV Write Access read/write
LV Size 512.00 MB

4. Crear y activar la nueva swap:
Poseidon:~# mkswap /dev/volgrp01/lvol0
Poseidon:~# swapon /dev/volgrp01/lvol0

5. Verificar que las estadísticas de la memoria en el sistema y confirmamos que tenemos (512+512+256)Mb.

lunes, 3 de enero de 2011

ulimit & limits.conf: Recursos del sistema

Primeramente quiero aprovechar este espacio para desear feliz año nuevo a mis escasos y desatendidos lectores ya que últimamente (varios meses atrás) que no he colocado nada por aquí. Para ponerme al día, tocaremos este sencillo pero importante tópico.

GNU/Linux nos provee varios mecanismos para administrar los recursos del sistema, como el paso de parámetros al kernel, memoria (scheduling priority), recursos físicos, etc. Los limites PAM ( pam_limits ), son limites de los recursos del sistema que son aplicados a los usuarios al iniciar sesión. Entre algunos de los recursos a los que les podemos aplicar este limite tenemos los siguientes:
  • Máximo numero de archivos abiertos.
  • Máximo tiempo en CPU.
  • Máximo numero de procesos.
  • Máximo numero de logins en el sistema.
  • Máxima prioridad permitida a un proceso.

El administrador deberá modificar el archivo /etc/security/limits.conf para administrar estos limites, mientras que los usuarios podrán jugar con el comando ulimit para mover sus valores dentro del rango permitido. El archivo de configuración se arma con registros de cuatro campos, de izquierda a derecha son los siguientes:

Campo 1 - Dominio: Se debe especificar el usuario o el grupo al que se aplicara el limite.
Campo 2 - Tipo: Hard o soft, el primero es el limite del cual el usuario no podrá pasar mientras que el segundo es el valor por defecto que tomara el usuario tras hacer login. El carácter "-", indica que se aplican los dos tipos simultáneamente con el mismo valor.
Campo 3 - Item: El recurso que se desea limitar (core, data, fsize, memlock, nofile, rss, stack, etc).
Campo 4 - Value: Valor que se va a asignar al recurso.

Dado el siguiente archivo de configuración, comentaremos algunas cosas


martin hard nofile 4096
martin - nproc 512


Tenemos dos ítem: nofile y nproc (numero máximo de archivos abiertos y máximo numero de procesos). Después de que el usuario martin inicia sesión podría consultar los valores que tiene asociados con los comandos ulimit -n y ulimit -u, además de ver la lista de ítems completos y sus valores con ulimit -a. En este caso los valores mostrados serian de la siguiente manera:

open files (-n) 1024
max user processes (-u) 512


El usuario puede crecer nofile hasta 4096, pero no mas de ese valor, sin embargo, nproc ya no puede crecer mas, si se intenta se conseguirá un mensaje "no se puede modificar el límite: Operación no permitida".

Finalmente en la figura, verificamos esta información para el máximo numero de procesos, tratando de colgar el sistema con una bomba fork, la cual funciona con recursividad tratando de llevar los procesos hasta que el sistema deje de responder, con aplicado este limite podemos evitar esto.

martes, 2 de noviembre de 2010

Liberación de recursos & | dispositivos ocupados en GNU/Linux

Tengo que reconocer que cuando comenze a dar mis primeros pasos en GNU/Linux y que tenia necesidad de liberar algun recurso me encontre con la siguiente leyenda:

En aquellos años penosamente tenia que reiniciar para liberar. Lo que en aquellos años no sabia es que con la ayuda del comando lsof, podemos apoyarnos para revisar archivos abiertos. Este comando nos muestra en columnas los siguientes campos relacionados a un proceso:
  • Comando.
  • Id del Proceso ( PID )
  • Usuario.
  • Nombre del nodo.
Aqui lo que nos puede resultar util es el nombre del nodo y el PID. Por ejemplo, supongamos que queremos liberar el lector optico para leer otro disco y a pesar de que cerramos nuestras aplicaciones no podemos desmontar. El cdrom estara asociado al nodo /dev/cdrom y montado en /media, nosotros podriamos hacer lo siguiente:

lsof | grep /media

El cual nos mostrara los procesos que estan haciendo uso de este recurso y asi podriamos matarlos con kill, para cada proceso y subproceso que se muestren. ¿y si son muchos? Podemos usar el nuevo juguete que me paso mi amigo Daniel Mtz.

for cadauno in ` lsof | grep /media | awk '{ print $1 }' `; kill $cadauno 2> /dev/null ; done

Con esto automatizamos para que cada proceso encontrado sea eliminado. Este comando y sus parámetros pueden hacer muchas cosas por nosotros, para concluir veamos algunos ejemplos:

#Archivos abiertos del PID 1
lsof -p 1

#Procesos que estan usado el puerto TCP 22 y UDP 53
lsof -i :22
lsof -i UDP:53

jueves, 12 de agosto de 2010

Catching process from devil with Bash

Cuando se tiene la necesidad de buscar procesos que consuman mucho recurso de computo como memoria o cpu, pero una limitante es lo poco practico de estar detras del comando top todo el tiempo, se nos obliga a pensar el automatizar esta busqueda y que asi nos de tiempo de salir a comer algo o dormir un poco.

En esta ocacion les presento un script que nos ayuda a buscar procesos que consumen mas de 50% de cpu y nos guarda en una bitacora la informacion de este procesos. Desde luego que se le pueden hacer mejoras pero las dejaremos al criterio del usuario. Espero les sea de utilidad.



#!/bin/bash
#Variable para solo encontrar un proceso
status=0

while [ $status -eq 0 ] ;
do
cont=`ps aux | awk '$3>50 { print }' | wc -l`
if [ $cont -gt 0 ]; then
ps aux | awk '$3>50 { print }' >> procesos.txt
date >> procesos.txt
#Podriamos ponerlo a 1 para solo encontrar 1 proceso
status=0
fi

echo scanning...
#esperamos 5 minutos para volver a buscar
sleep 300
done

martes, 22 de junio de 2010

Bash Scripting: Recursive Search inside text files

Anteriormente había tenido la necesidad de hacer búsquedas recursivas de alguna cadena, en todos los archivos de texto de un árbol de directorios. Un ejemplo típico es un parámetro o valor usado por algún aplicativo y que no recordamos claramente en que archivo de conflagración esta, en este contexto es donde personalmente he tenido la necesidad de una herramienta así.

Les quiero compartir un script que realiza precisamente este tipo de búsquedas, este script bien se puede adaptar para realizar operaciones sobre estos archivos, permisos, modificaciones, borrados, etc. Sin embargo eso ya queda de tarea de acuerdo a sus necesidades.


#!/bin/bash

if [ "$#" != "1" ]; then
echo "usage: finder ";
exit 1;
fi

#Se consigue un listado recursivo de los archivos en el directorio actual y subdirectorios
du -a * | awk 'BEGIN{"pwd" | getline LOCAL_PATH}{print LOCAL_PATH "/" $2}' | (
#Hacemos la lectura "filebyfile" o "linebyline"
while read line; do
#Solo buscamos en archivos de texto
file $line | grep text > /dev/null;
if [ "$?" -eq "0" ]; then
echo "*** Archivo de texto: $line";
cat $line | grep $1;
echo "";
fi
done
);
exit 0;

miércoles, 2 de junio de 2010

PackETH, Builder of RAW TCP/IP Packet

Hace algunos meses encontre en los repositorios de Ubuntu, una herramienta para la construcción de paquetes TCP/IP, el PackETH. Durante mis épocas de estudiante hacíamos pruebas personalizando paquetes con raw sockets en lenguaje C (¿que..., hay otro?). El desarrollo con raw sockets a pesar de fácil, puede ser en algún momento un poco confuso, sobre todo por los nombres de los elementos de las estructuras de datos usadas y su respectiva referencia y/o relación con el TCP/IP.
A modo de presentación de esta herramienta, se realizaron unas pruebas en una topología tan simple como la que muestra la figura anterior, una red local y un servidor de internet. En la computadora de la red local tenemos la dirección MAC 90:4C:E5:63:71:C9 y la dirección de red 192.168.1.100, los detalles pueden observar en la siguiente imagen.
Usando el PackETH, construimos un paquete ICMP, dirigido a un servidor de google. Haciendo un paréntesis, debemos saber que cuando un paquete cruza parcialmente la nube de internet y pasa por varios routers, en cada salto algunos campos se comportan de la siguiente manera:
  • MAC Origen: En cada salto cambia y es sustituida por el dispositivo que esta enviando o reenviando la trama, colocando su propia MAC Address.
  • MAC Destino: En cada salto cambia y es sustituida por el dispositivo que esta enviando o reenviando la trama, colocando la MAC Address del equipo que recibe la trama y que esta dentro de su segmento.
  • IP Origen: Solo llega a cambiar cuando salimos de alguna red local y el gateway hace un enmascaramiento, sustituyendo la IP origen que le llega por la que tiene el propio Gateway.
  • IP Destino: Nunca cambia!.
Conociendo la información anterior, seguimos con la instrucción del paquete, llenado los campos de la siguiente manera. Una vez terminado definimos la interfaz de salida, y damos clic a "Send". El paquete en ese momento es liberado en la ostil y lenta, red publica. Para verificar la entrega del paquete, podemos consultar algún sniffer, en este caso nos apoyamos de wireshark, donde podemos ver que el paquete se envía y recibe correctamente. Espero esta información puede ser de mucha ayuda para algunas personas.

martes, 18 de mayo de 2010

Un vistazo a Iptables con DMZ


Revisando el baúl de los recuerdos me encontré con algunos trabajos escolares, y me se me ocurrió que era buena idea comentar alguno de ellos. Definitivamente uno de mis favoritos es iptables, y en este ejemplo hacemos una implementación de esas reglas para una arquitectura con DMZ.

Les voy a compartir un script, que lo que hace es activar un firewall usando iptables y que a la vez tiene finalidad de ayudarnos a protegernos a nivel de capa de red y transporte. El único requerimiento es tener instalado awk, e iptables en linux.

#!/bin/bash
#Re-adaptado por:
#Martin Edmundo Barriga Orozco

#Revisamos la dependencia de AWK
awk --version > /dev/null
if [ "$?" != "0" ]; then
echo "Se requiere AWK para continuar"
exit 1
fi

echo "Preparando interfaces..."
echo 1 > /proc/sys/net/ipv4/ip_forward

#Interfaces de red que usamos para la red LAN, DMZ e Internet
if_lan="eth1"
if_dmz="eth2"
if_pub="eth0"

#Direcciones que tenemos en cada interface
ip_pub="10.27.46.145"
ip_lan="172.16.1.254"
ip_dmz="192.168.1.254"

#Direcciones IPs conocidas.
web_server="192.168.1.1"
mail_server="192.168.1.3"
dhcp_server="192.168.1.129"
dns_server="192.168.1.2"

id_lan="172.16.0.0/16"
id_dmz="192.168.1.0/24"

#Configuracion final con el usuario
read -p "Habilitar uso para DMZ [y/N]: " enable_dmz
if [ "$enable_dmz" = "y" ]; then
if [ -n "$if_dmz" ]; then
#call metodo_valida_interfaz
echo "invocamos al metodo de validacion de interfaz"
else
echo " Interfaces Disponibles:"
#Imprimimos el listado de interfaces
ifconfig -a | awk 'BEGIN{FS="[ ]+" ; RS=""} $1!~/lo/{print " " NR ") " $1}'
read -p " Nombre de la interfaz a usar: " if_dmz

#call metodo_valida_interfaz
#echo "invocamos al metodo de validacion de interfaz"

echo -n " >>IP: " ;
#Se imprime la direccion IP de la interfaz $if_dmz
ifconfig $if_dmz | grep 'inet:' | awk 'BEGIN{FS="[ ]+"} {print $3}' | awk 'BEGIN{FS=":"}{print $2}'
read -p " Desea conservar esta IP para esta interfaz [y/N]: " tmp_ans
if [ "$tmp_ans" != "y" ]; then
read -p " Nueva IP: " ip_dmz
ifconfig $if_dmz $ip_dmz
fi
fi
fi

read -p "Habilitar el modo paranoico [y/N]: " enable_paranoico_mode


echo "Aplicando reglas del firewall..."


#Borrado de las reglas aplicadas actualmente (flush)
iptables -F #flush todas las cadenas
iptables -t nat -F
iptables -X #Borra cadenas definidas por el usuario
iptables -Z

#Activamos bitacora de reenvio
iptables -t nat -A PREROUTING -j LOG
iptables -t nat -A POSTROUTING -j LOG

#Politicas por defecto (INPUT OUTPUT FORWARD)
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT

#REDIRECCIONAMIENTO A SERVIDOR WEB EN DMZ DESDE LA LAN Y RED PUBLICA
iptables -t nat -A PREROUTING -i $if_lan -s $id_lan -d $ip_lan -p tcp --dport 80 -j DNAT --to 192.168.1.1:80
iptables -t nat -A PREROUTING -i $if_pub -d $ip_pub -p tcp --dport 80 -j DNAT --to 192.168.1.1:80
#iptables -t nat -A PREROUTING -i $if_lan -s 0.0.0.0 -d 255.255.255.255 -p udp --dport 67 -j DNAT --to 192.168.1.129:67

#ABRIENDO PUERTOS PARA INPUT, OUTPUT, FORWARD: TRABAJO SUCIO PERO HAY QUE HACERLO!

#Aceptamos peticiones de ICMP para la LAN.
iptables -A INPUT -i $if_lan -s $id_lan -d $ip_lan -p icmp -j ACCEPT
iptables -A OUTPUT -o $if_lan -s $ip_lan -d $id_lan -p icmp -j ACCEPT

if [ "$enable_dmz" = "y" ]; then
#Aceptamos peticiones e ICMP para la DMZ.
iptables -A INPUT -i $if_dmz -s $id_dmz -d $ip_dmz -p icmp -j ACCEPT
iptables -A OUTPUT -o $if_dmz -s $ip_dmz -d $id_dmz -p icmp -j ACCEPT
fi

#Aceptamos peticiones ICMP desde la red publica.
iptables -A INPUT -i $if_pub -s 0/0 -p icmp --icmp-type 8 -j ACCEPT
iptables -A OUTPUT -o $if_pub -d 0/0 -p icmp --icmp-type 0 -j ACCEPT

#Aceptamos el flujo para el DNS para la LAN. REVISAR
iptables -A INPUT -i $if_lan -p udp --dport 67 -j ACCEPT
iptables -A OUTPUT -o $if_lan -p udp --sport 67 -j ACCEPT

if [ "$enable_paranoico_mode" != "y" ]; then
#Aceptamos navegar en la web. (Opcional)
iptables -A INPUT -i $if_pub -p tcp --sport 80 -j ACCEPT
iptables -A OUTPUT -o $if_pub -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -i $if_pub -p tcp --sport 443 -j ACCEPT
iptables -A OUTPUT -o $if_pub -p tcp --dport 443 -j ACCEPT

#Aceptamos las peticiones de MSNP, tenemos tolerancia. xD (Opcional)
iptables -A INPUT -i $if_pub -p tcp --sport 1863 -j ACCEPT
iptables -A OUTPUT -o $if_pub -p tcp --dport 1863 -j ACCEPT
fi

#Aceptamos el flujo de DNS para la red publica. REVISAR
iptables -A INPUT -i $if_pub -p udp --sport 53 -j ACCEPT
iptables -A OUTPUT -o $if_pub -p udp --dport 53 -j ACCEPT

if [ "$enable_dmz" = "y" ]; then
#Permitimos el flujo de de comununicacion entre el WEB server de la DMZ y los clientes de la LAN
#Evitamos rafagas de paquetes syn.
iptables -A FORWARD -i $if_lan -o $if_dmz -s $id_lan -d $web_server -p tcp --dport 80 -m limit --limit 3/minute --limit-burst 3 state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i $if_dmz -o $if_lan -s $web_server -d $id_lan -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT

#Permitimos el flujo de de comununicacion entre el DNS server de la DMZ y los clientes de la LAN
iptables -A FORWARD -i $if_lan -o $if_dmz -s $id_lan -d $dns_server -p udp --dport 53 -j ACCEPT
iptables -A FORWARD -i $if_dmz -o $if_lan -s $dns_server -d $id_lan -p udp --sport 53 -j ACCEPT

#Permitimos el flujo de de comununicacion entre el MAIL server de la DMZ y los clientes de la LAN
iptables -A FORWARD -i $if_lan -o $if_dmz -s $id_lan -d $mail_server -p tcp --dport 25 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i $if_dmz -o $if_lan -s $mail_server -d $id_lan -p tcp --sport 25 -m state --state ESTABLISHED -j ACCEPT

#Permitimos el flujo de de comununicacion entre el MAIL server de la DMZ y los clientes de la LAN
iptables -A FORWARD -i $if_lan -o $if_dmz -s $id_lan -d $mail_server -p tcp --dport 110 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i $if_dmz -o $if_lan -s $mail_server -d $id_lan -p tcp --sport 110 -m state --state ESTABLISHED -j ACCEPT

#Permitimos el flujo de de comununicacion entre el MAIL server de la DMZ y los clientes de la LAN
iptables -A FORWARD -i $if_lan -o $if_dmz -s $id_lan -d $mail_server -p tcp --dport 143 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i $if_dmz -o $if_lan -s $mail_server -d $id_lan -p tcp --sport 143 -m state --state ESTABLISHED -j ACCEPT

#Permitimos el flujo de ICMP hacia el servidor web
iptables -A FORWARD -i $if_lan -o $if_dmz -s $id_lan -d $web_server -p icmp -j ACCEPT
iptables -A FORWARD -i $if_dmz -o $if_lan -s $web_server -d $id_lan -p icmp -j ACCEPT

#Permitimos a nuestro servidor DNS, solicitar direcciones al DNS del ITMorelia
iptables -A FORWARD -i $if_dmz -o $if_pub -s $dns_server -d 200.33.171.1 -p udp --dport 53 -j ACCEPT
iptables -A FORWARD -i $if_pub -o $if_dmz -s 200.33.171.1 -d $dns_server -p udp --sport 53 -j ACCEPT

#iptables -A FORWARD -i $if_dmz -o $if_pub -p udp --dport 53 -j ACCEPT
#iptables -A FORWARD -i $if_pub -o $if_dmz -p udp --sport 53 -j ACCEPT

#Permitimos a nuestro servidor DNS, solicitar direcciones al DNS del ITMorelia
iptables -A FORWARD -i $if_dmz -o $if_pub -s $dns_server -d 200.33.171.8 -p udp --dport 53 -j ACCEPT
iptables -A FORWARD -i $if_pub -o $if_dmz -s 200.33.171.8 -d $dns_server -p udp --sport 53 -j ACCEPT

#Permitimos exponer nuestro webserver a la red publica.
iptables -A FORWARD -i $if_pub -o $if_dmz -d $web_server -p tcp --dport 80 -m limit --limit 5/minute --limit-burst 5 -j ACCEPT
iptables -A FORWARD -i $if_dmz -o $if_pub -s $web_server -p tcp --sport 80 -j ACCEPT
else
#Sino hay DMZ permitimos a los clientes LAN consultar DNS externos
iptables -A FORWARD -i $if_lan -o $if_pub -s $id_lan -p udp --dport 53 -j ACCEPT
iptables -A FORWARD -i $if_pub -o $if_lan -d $id_lan -p udp --sport 53 -j ACCEPT
fi

#Permitimos a las personas de la LAN, navegar en la web.
iptables -A FORWARD -i $if_lan -o $if_pub -s $id_lan -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i $if_pub -o $if_lan -d $id_lan -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT
iptables -A FORWARD -i $if_lan -o $if_pub -s 172.16.1.21 -p tcp --dport 443 -j ACCEPT ##1863 :1503 3389
iptables -A FORWARD -i $if_pub -o $if_lan -d 172.16.1.21 -p tcp --sport 443 -j ACCEPT

#Permitimos el uso del MSNP en la computadora del SysAdmin dentro de la LAN
iptables -A FORWARD -i $if_lan -o $if_pub -s 172.16.1.21 -p tcp --dport 1863 -j ACCEPT ##1863 :1503 3389
iptables -A FORWARD -i $if_pub -o $if_lan -d 172.16.1.21 -p tcp --sport 1863 -j ACCEPT
iptables -A FORWARD -i $if_lan -o $if_pub -s 172.16.1.21 -p udp --dport 1863 -j ACCEPT
iptables -A FORWARD -i $if_pub -o $if_lan -d 172.16.1.21 -p udp --sport 1863 -j ACCEPT

#ENMASCARAMIENTO DE LA RED Y LA DMZ
iptables -t nat -A POSTROUTING -o $if_pub -s $id_lan -j MASQUERADE
if [ "$enable_dmz" = "y" ]; then
iptables -t nat -A POSTROUTING -o $if_pub -s $dns_server -p udp --dport 53 -j MASQUERADE
iptables -t nat -A POSTROUTING -o $if_pub -s $id_dmz -j MASQUERADE
iptables -t nat -A POSTROUTING -o $if_dmz -s $id_lan -d $web_server -p tcp --dport 80 -j SNAT --to-source $ip_dmz
iptables -t nat -A POSTROUTING -o $if_dmz -s ! $id_lan -d $web_server -p tcp --dport 80 -j SNAT --to-source $ip_dmz
#iptables -t nat -A POSTROUTING -o $if_dmz -s 0.0.0.0 -d $dhcp_server -p udp --dport 67 -j SNAT --to-source $ip_dmz
fi

echo "Reglas aplicadas correctamente :)"

sábado, 19 de diciembre de 2009

Installing glibc2.4, but faill :(

Hace unas semanas me vi en la necesidad de actualizar mi viejo flashplayer plugin de la version 8 a la 10, ya que no podia ver las video conferencias de mis amigos en servicios como ustream, videos en facebook, etc.

En principio ese era el problema, siguiendo el procedimiento coloque el libflashplayer.so en el directorio de plugins del browser, al tratar de cargar los videos podemos ver un mensaje de error, donde los requerimientos de libflashplayer son glibc2.4. En mi lap con Debian etch la es glibc2.3.6. Tambien estamos corriendo Linux 2.6.23.1.

De el problema de actualizar flashplayer, tendríamos que pasar entonces a actualizar glibc, que es una libreria base del sistema. A pesar de contar con glibc mas nuevos en la web del proyecto, se descargo la 2.4. No me pregunten por que..., solo lo hice así. A continuación escribo el procedimiento que seguí para conseguir mas problemas.

Descargar el archivo de glibc2.4 y desempaquetarlo dentro de
/usr/gnu/glibc-2.4

La recomendación de los desarrolladores es crear un directorio donde construiremos el paquete, de esta manera solo borramos el directorio de construcción y listo, podemos repetir los pasos.
/usr/gnu/glibc-build

Entrar en este segundo directorio y configurarlo, para eso corriendo el script, en esta parte cambiamos el prefix, ya que con el que tiene por defecto se presentaron problemas. Así que ejecutamos la siguiente linea:
../glibc-2.4/configure --prefix=/usr

Para la compilacion se requiere el awk de gnu, gawk, y sobre todo las herramientas de compilación como make y gcc. Para eso ejecutar:
../glibc-2.4/make && ../glibc-2.4/make check

Hasta aquí todo en orden la compilación, solo falta la instalación de esta nueva biblioteca, esa instalación es el "paso de la muerte", y debería hacerse en supervision de un adulto :)

Siguiendo las recomendaciones debemos iniciar en modo monouser, para evitar el rompimiento de algunas bibliotecas (LOL), y una vez ahí instalar con la siguiente linea:
env LANGUAGE=C LC_ALL=C make install

En ese momento el sistema se pone a instalar, pero en mi caso, después de un rato de felicidad viendo que todo iva en orden, se detiene en el siguiente mensaje

GLIBC_PRIVATE not defined
Kernel Panic - not syncing: Attempted to kill init!

WTF! seguramente no son buenas noticias por que después de eso, ningún comando funciona, reiniciar tampoco sirve de mucho, por que el Kernel panic persiste. Al momento de escribir este post lo hago desde mi debian, logre arreglarlo siguiendo el siguiente [ tip ], al parecer es un bug de glib. Por los problemas que tengo en mi sistema, flashplayer, espacio insuficiente, problemas de montaje con ntfs. Por estas razones y por que viene un ano nuevo, comenzaremos con un distro nuevo... Lenny :)

martes, 17 de noviembre de 2009

Enviando mensajes SMS desde la consola

Hace algunos días he tenido la necesidad de enviar mensajes SMS desde mi compu, esto para que sea ella misma la que de manera automatizada la que me mande el mensaje cuando yo ande en la calle paseando, trabajando o en algún antro pasando la noche, todo esto cuando mi computadora se entere de algún suceso emergente y anómalo que ha ocurrido, en mi caso eran notificaciones de Nagios.

Para esto ocupamos 3 cosas, eeemmmm mejor 4,
1. Un celular preferentemente listado [ aquí ]
2. Una compu, con soporte para USB, IRA, o algún medio de comunicación con el cel
3. Software Gnokii
4. Actitud positiva y ganas de aprender. :)

Gnokii es un sofware que nos sirve para tener una muy amplia comunicación con el celular: llamadas, agenda de contactos, mensajes, etc. Lo descargamos e instalamos, cuanta con interfaces de linea de comando y gráfico.

En mi caso, tengo un celular modelo Sony Ericsson K790 (el cual me patrocino mi papá), y lo conecte por medio del USB, y me dio como resultado los siguientes archivos:
/dev/ACM0
/dev/ACM1

Como podemos ver en este caso era necesario tener soporte para ACM en el kernel (mm ¿ya dije que instale en Debian etch con 2.6.23.1?? ). Leyendo un poco la documentación, me he creado un archivo en archivo de configuración local en mi home:
$HOME/.gnokiirc

El cual básicamente en sus lineas mas importantes me quedo así:
[ global ]
port=/dev/ACM0
mode=AT
connection=serial

Finalmente el envio de mensajes podemos hacerlo con una linea como la que sigue:
$echo Hola como estan, envio desde gnokii | gnokii --sendsms xxxxxxxxxx

donde:
xxxxxxxxxx, es el numero de teléfono

Una observación importante es notar que echo no tiene la doble comilla, me dio problemas.

lunes, 20 de julio de 2009

Vim's scripting language

Hace unos dias leyendo las noticias de cofradia me encontre con información sobre vim scripting, como algunos de uds tal vez imaginen, puedo decir que Vim es mi edito de textos favoritos por que es muy rapido, y sobre todo por el espacio en disco.

La idea de hacer a mi vim un poco mas robusto o simplemente conocerlo mas, me entusiasmo y me puse a leer el articulo. El lenguaje de scripts de vim, segun el articulo es un lenguaje con muchas caracteristicas como variables, espresiones, control de flujo, estructuras de datos, funciones, IO file, excepciones, debugger, entre muchas cosas.

Como comenzar, pues bien rapidamente ocupamos los paquetes vim y vim-scripts, desde luego que la documentacion que en caso de tenerla podemos consultarla de la siguiente manera.
:help vim-script-intro

Como mandar a ejecucion nuestras pruebas
:source /full/path/to/the/scriptfile.vim

El resto es comenzar a adentrarnos en este lenguaje.