Acceso a dos equipos desde el mismo monitor, teclado y mouse

El titulo puede ser un poco confuso, pero la situación es la siguiente:

Tengo DOS cpus y solo un monitor, un teclado y un ratón. Para cambiar de cpu pues desconecto todo y lo cambio al otro cpu. Otra opción es solamente abrir una terminal ssh ya estoy trabajando en el otro equipo. Aunque esto es útil algunas veces, también me gustaría tener acceso al ambiente gráfico.

Esto también se puede lograr utilizando ssh -X, pero esto se hace solo por aplicación, y si por alguna razón se llega a cerrar, pierdes todo lo que tenias en el gráfico.

Estuve investigando de servidores Xvirtuales para poder transportar todo el ambiente gráfico, tipo como un screen pero gráfico, y di con xpra.

Pero bueno, ahora lo que quiero es cambiar de pantalla (crt+alt+f8) por ejemplo y tener el escritorio de la otra cpu, (crt+alt+f7) y el escritorio del actual cpu.

Para lograrlo, hay que iniciar otro servidor X en la maquina local:

xinit -- :1

y en el xterm que se inicia, una conexion ssh -CX

ssh -CX usuario@elhostremoto

y luego el manejador de sesiones, en mi caso xfce4-session, y listo.

xfce4-session

Ahora solo tengo que cambiar de pantalla y tengo los escritorios de los dos cpus disponibles.

;)

Redimensionando y rotando fotos desde la línea de comandos

Estamos renovando la pagina de la academia, y hay muchas fotos para publicar. El script tipo galeria donde se van mostrando mostrando las fotos ya está listo (utilizaron jquery y el easySlider).

Ahora solo falta homogenizar las fotos, que tengan el mismo tamaño y que no salgan giradas.

Para la orientación correcta podemos usar exiftran, esto si la camara almacenó la información de como se tomo la fotografía en los datos exif. En caso de no haberla almacenado, podemos utilizar algún software como eog para ver las fotos y girarlas de manera manual, al girarlas en este software, las fotos no se modifican, solo se modifica la etiqueta exif :)

exiftran -ai *

es la instrución que revisa todos los archivos de la carpeta, en este caso las fotos y si la orientación no es la adecuada las rota realmente y actualiza la etiqueta.

Como las fotos son de diferentes fuentes y diferentes cámaras, pues los tamaños varian mucho. Una vez rotadas las fotos necesitamos ajustar la altura de todas las fotos para que se vean continuas en el script. Para esto usaremos de imagemagick una utilidad que se llama mogrify.

mogrify -resize x400 *

esta instrucción fija la altura en todas fotos existentes en el directorio, y ahora si estan listas para ser usadas por el script.

La lista de fotos se genera en orden aleatorio, así que cada vez que visiten la página se vera diferente.

Como son muchas fotos, esta limitada a 25 por visita, así que si quieren ver más, refrequen la página :)

Otra situación con los archivos provenientes de diferentes camaras es que pueden repetirse los nombres de las fotos ya que todos están en la misma carpeta para que funcione el script. Así que para renombrarlos podemos utilizar el comando rename. En este caso tenemos carpetas que se llaman fotos01 hasta fotos09, y en lugar de buscar si hay nombres repetidos, modificamos los nombres de las fotos de todas las carpetas en una sola linea:

for a in $(seq 1 9); do cd fotos0$a ; rename "s//0$a/" *JPG; cd .. ; done

Recuperando fotografias de un disco duro

Esta entrada es sobre recuperación de archivos de un disco duro, lo especial es que lo que se intenta recuperar son especialmente fotografías.

Así que típico y como estarán pensando conectamos el disco y lanzamos el photorec para recuperar todo, el cuestión es que queremos las fotografías y el disco duro es de 400 Gigas. Así que configuramos el photorec para que solamente nos recupera archivos jpg, en este caso las fotografias fueron guardadas durante varios años directamente de la camara.

Aún así, terminamos con muchisimos archivos recuperados y en diferentes carpetas donde fueron guardados. (Fueron 61 carpetas, casi 20 Gigas y casi 22 mil archivos). Para clasificar esto a mano pues puede llevar bastante tiempo, aquí es donde entra lo interesante de conocer el formato.

Al ser archivos de fotografías digitales, la cámara agrega datos EXIF al archivo, estos datos van desde la cámara que tomo la fotografía, características como distancia enfoque, tiempo de exposición, incluso algunas cámaras incluyen latitud y longitud para georeferenciar las fotos. Pero lo más importante ahora es la fecha.

Así que sabiendo esto, con un programa en python que lea los datos exif de los archivos, podremos discriminar los archivos y seleccionar solamente los que tengan estos datos, y renombrarlos por la fecha, en caso de no tener la fecha o que por alguna razón las fechas coincidan, pues dejamos el nombre original con el que fueron recuperadas.

Y de esta manera recuperamos 16 mil fotos, de casi 10 años.

A continuación el programa en python:

import exif
import shutil


lista = open("fotos1.jpg.txt","r").read().split("\n")

listafotos=[]

for item in lista:
 print item
 try:
  data=exif.get_exif(item)
 except:
  data="NULL"
 
 if data!="NULL":

  try:
   fecha=data['DateTime']
  except:
   fecha=item.split("/")[2]
  if fecha[-1] == '\x00':
   fecha = fecha[:-1]
  if fecha not in listafotos:
   listafotos.append(fecha)
  else:
   fecha=fecha+"-"+item.split("/")[2]
  shutil.copy(item,"./Tusfotos/"+fecha)
 

y también la librería :

from PIL import Image
from PIL.ExifTags import TAGS

def get_exif(fn):
 ret={}
 i = Image.open(fn)
 info = i._getexif()
 for tag,value in info.items():
  decoded = TAGS.get(tag, tag)
  ret[decoded]=value
 return ret

Asegurar código PHP heredado.

Estoy revisando una aplicación en PHP, ya hace lo que debe hacer, ya está en español, tiene las modificaciones necesarias .... ahora falta asegurarla.

Creo que al menos 2 procesos básicos son los necesarios, protegerla de SQLi y de RFI. (inyección de código SQL e Inclusión de archivos remotos).

Para el primer punto, hay que "limpiar" las entradas que recibe la aplicación del usuario, considerando que los usuarios pueden ser hostiles.

se me ocurren 2 cosas addslashes y mysql_real_escape_string, las cuales escapan los caracteres ' " NULL y les antepone \ y puede servir para almacenar contraseñas del tipo ' or ''=''

Al parecer la más recomendada es mysql_rel_escape_string, solo que debes tener un enlace a la base de datos, porque el trabajo lo hace el mysql.

La verdad preferiría poder utilizar algún patron de diseño que me protegiera del SQLi, pero sería reescribir casi toda la aplicación. así que mejor utilizaré el escape.

vienen unas lines que podrían ser muy útiles y rápidas de implementar :

$_GET = array_map('mysql_real_escape_string', $_GET);
$_POST = array_map('mysql_real_escape_string', $_POST);
$_COOKIE = array_map('mysql_real_escape_string', $_COOKIE);
$_REQUEST = array_map('mysql_real_escape_string', $_REQUEST);

En esta presentación sobre SQLi también recomiendan utilizar procedimientos almacenados.

Otro punto muy IMPORTANTE de la presentación:

Filtra/valida las entradas escapa las salidas.

Para escapar las salidas, puedes utilizar htmlentities, a menos que permitas HTML almacenado o como parámetros, de otra forma, puedes evitar también ataques XSS.

Estas recomendaciones también se muestran acá. Donde es todo un lista de cotejación para ver si tu aplicación está asegurada.

Por último, no dejes sola la aplicación, revísala constantemente junto con sus logs. Tal vez alguién ya metió gol y tu todavía no sabes.

Usar el navegador de forma "Anónima"

El título puede ser algo confuso con lo que quiero compartir, pero intentaré comenzar a explicarlo con un ejemplo.

Estoy navegando, tengo varios sitios abiertos, algunos de los cuales te dan seguimiento como google por ejemplo, o bing. Y si tengo activa mi cuenta y abro otra pagina del buscador, sabe quien soy y que estoy buscando.

Los navegadores tienen una opción de navegar de incógnito, donde "se supone" no dejas rastro en la PC en la que estás. Pero aún cuando abres una ventana o pestaña en este modo, si ingresas al buscador, sigue leyendo tus preferencias, tus cookies etc. etc. Así que te sigue reconociendo.

Existe la teoría que te pueden identificar plenamente por las cadenas del navegador, cookies y esas cosas, así que buscando una forma de que esto no sea tan sencillo progongo lo siguiente (que es lo estoy usando actualmente):

Utilizar las opciones de chromium-browser específicamente para tratar de resolver la situación de una navegación un poco mas PRIVADA.

hugo@Atenea:~/Escritorio$ chromium-browser --user-data-dir=/tmp/otra --temp-profile --incognito --user-agent="Mozilla/5.0(iPad; U; iPhone OS 3_2; en-us) AppleWebKit/531.21.10 Mobile/7B314" http://www.google.com

--user-data-dir sirve para decirle donde se almacenará la información de usuario del navegador, de esta forma no lee las cookies que ya tengas, y puedes seguir con sesiones abiertas en otras ventanas del navegador.

--temp-profile para que sea perfil temporal

--incognito modo incognito o privado

--user-agent identifica al navegador, con la cadena de ejemplo simula ser un iPad.

Así navego de manera tradicional y de manera privada al mismo tiempo.

Conectar Java con bases de datos (derby y mysql)

Del libro de Deitel vienen varios ejemplos de como hacerlo (conectar java con mysql o con derby), pero en la práctica esto puede resultar no tan evidente.

Voy a basar esta entrada en el tema 25.10 del libr de Como programar en Java (7a. edición) de Deitel & Deitel.

En linux debemos tener instalados los siguientes paquetes: (esos son los que tengo en mi sistema)

sun-java6-bin
sun-java6-jdk
sun-java6-jre
sun-java6-javadb --> este nos instala el derby.
libmysql-java
mysql-server-5.1
mysql-server-core-5.1

Sin modificar nada de los codigos que vienen en el CDROM, puedes crear la base de datos con el comando "ij", todo compila muy bien, pero al ejecutarlo marca errores, de que no sabe nada del conector sql ..

java.sql.SQLException: No suitable driver found for jdbc:derby:LibretaDirecciones
at java.sql.DriverManager.getConnection(DriverManager.java:602)
at java.sql.DriverManager.getConnection(DriverManager.java:185)
at ConsultasPersona.(ConsultasPersona.java:29)
at MostrarLibretaDirecciones.(MostrarLibretaDirecciones.java:59)
at MostrarLibretaDirecciones.main(MostrarLibretaDirecciones.java:357)

para corregir este error ejecutamos :
java -cp /usr/lib/jvm/java-6-sun/db/lib/derby.jar:/usr/lib/jvm/java-6-sun/db/lib/derbytools.jar:. MostrarLibretaDirecciones

y con esto funciona perfectamente.

Para el caso de hacerlo funcionar con MySQL, hay que modificar unas cuantas lineas:

En el archivo direccion.sql
linea 5: IDDireccion INT NOT NULL AUTO_INCREMENT,
agregamos la linea 10: key(IDDireccion)

Luego de esto creamos la base de datos y asignamos permisos a los usuarios, y ejecutamos el codigo sql sobre la base de datos.

En el código del archivo ConsultaPersona.java, modificamos 2 lineas:

linea 14: private static final String URL = "jdbc:mysql://localhost/LibretaDirecciones";
cambiamos el controlador de derby a mysql.

linea 29: DriverManager.getConnection( URL+"?user="+NOMBREUSUARIO+"&password="+CONTRASENIA );
el parametro que se le pasa es un poco diferente, tiene forma de url para agregarle el user / password al manejador.

compilamos todo con javac *java.

para ejecutarlo :

java -cp /usr/share/java/mysql-connector-java.jar:. MostrarLibretaDirecciones

y con eso podemos tener la aplicación funcionando.

Compilando el kernel de opensolaris 1a. parte

Al parecer todo va bien hasta ahora para compilar el kernel de opensolaris. Lleva 5 horas en un pentium 4 HT con 1.5 en RAM.

Me gustaría mostrar de manera rápida y resumida los pasos que seguí para poner a compilar el kernel.

1. Instalar opensolaris, pueden descargarlo de http://hub.opensolaris.org/bin/view/Main/downloads
la versión utilizada fue la última estable: http://dlc.sun.com/osol/opensolaris/2009/06/osol-0906-x86.iso

2.Luego de instalarlo se necesitan instalar unos paquetes, que pueden ser desde el repositorio.
* SUNWonbld
* SUNWgcc

Estos los pueden añadir directamente del administrador de paquetes. Necesitan estar conectados a Internet.

3. Mientras se instalan estos paquetes, también pueden poner a descargar el Sun Studio 12.
Para instalarlo pueden seguir las intrucciones de http://hub.opensolaris.org/bin/view/Community+Group+tools/sun_studio_12_tools


4. Preparamos el código fuente necesario, para esto recomiendo crear una carpeta, proyecto, por ejemplo:
mkdir proyecto
cd proyecto

Bajamos y descomprimimos aqui lo siguiente.

Hay que obtener el código fuente de ON, se utiliza la herramienta "mercurial" :

hg clone ssh://anon@hg.opensolaris.org/hg/onnv/onnv-gate

y los binarios que no son open source.
http://dlc.sun.com/osol/on/downloads/current/on-closed-bins-nd.i386.tar.bz2

5. Preparamos el ambiente, copiamos onnv-gate/usr/src/tools/env/opensolaris.sh onnv-gate.
Esta carpeta onnv-gate fue la que se creo cuando bajamos el código fuente de ON en el paso 4.
En la carpeta proyecto tambien descomprimimos on-closed...

Una vez copiado opensolaris.sh que nos servirá para definir todas las variables de ambiente, hay que modificar algunos parametros:

GATE al nombre de la carpeta donde esta el código fuente, por ejemplo onnv-gate
CODEMGR_WS a la ruta donde se encuentra esa carpeta, por ejemplo /export/home/hugo/proyecto
STAFFER a tu nombre de usuario
VERSION. para que aparezca tu nombre en el kernel :)

ejecutamos onbld opensolaris.sh

6. En la carpeta onnv-gate/usr/src/tools/ creamos la carpeta prod y la carpeta opt dentro de ella
luego hacemos una liga suave a la carpeta donde estan las herramientas onbld
ln -s /opt/onbld /export/home/hugo/proyecto/onnv-gate/usr/src/tools/prod/opt/onbld

también añadimos a la variable de ambiente la ruta del sun studio compiler y del onbld
export PATH=/opt/onbld/bin:/opt/onbld/bin/i386:/opt/SUNWpro/bin:$PATH

7. Nos cambiamos al directorio onnv-gate/usr/src/utm
y ejecutamos
dmake all

Si todo sale bien y no da errores en unas cuantas horas tendremos el kernel de opensolaris, luego veremos como instalarlo.

Feliz Compilada !!!!

p.d. pueden consultar http://hub.opensolaris.org/bin/view/Community+Group+on/install_quickstart como referencia.

El API de bit.ly

Bit.ly es un servicio para acortar direcciones de internet (url), de esta forma puedes poner la dirección en twitter en menos caracteres.

Otra ventaja es que puedes dar seguimiento de cuantas visitas ha tenido tu url acortada, siempre y cuando estes registrado. El registro es gratis.

Bit.ly ofrece un API REST, que mediante una petición y ciertos parámetros te devuelve la url corta, la url extendida, la información de la url ...

Entre el formato en que te da respuestas está el de texto plano, y el json, que en otra ocasión hablaré de él ya que es MUY interesante y muy facil de utilizar (al menos en python).

En esta liga pueden consultar la documentación de la API, en otro post les presentaré mi programa en python para utilizarla

http://code.google.com/p/bitly-api/wiki/ApiDocumentation

Creando kmz desde la info de twitter. (y iii)

Luego de bastante tiempo, seguimos con la entrada.

Solo tenemos que acoplar lo anterior, para meterlo todo a un archivo bash y que genere tu nuevo kmz.

Para generar la info, vamos a utilizar la herramienta awk, para poder utilizar el flujo obtenido en el post (i) y darle formato necesario explicado en el post (ii).

Les dejo el código completo :



#!/bin/bash
# Program to convert info from SismologicoMX to KML to place in google-earth

final='doc.kml'

echo '<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://earth.google.com/kml/2.1">
<Document>
<name> Ultimos sismos registrados </name>
<Style id="bajo">
<IconStyle>
<scale> 0.7 </scale>
<Icon>
<href>root://icons/palette-3.png</href>
<x>64</x>
<y>64</y>
<w>32</w>
<h>32</h>
</Icon>
</IconStyle>
<LabelStyle>
<scale>0.7</scale>
</LabelStyle>
</Style>
<Style id="alto">
<IconStyle>
<scale> 0.7 </scale>
<Icon>
<href>root://icons/palette-3.png</href>
<x>64</x>
<y>96</y>
<w>32</w>
<h>32</h>
</Icon>
</IconStyle>
<LabelStyle>
<scale>0.7</scale>
</LabelStyle>
</Style>
<Folder>
<name> Sismos de SismologicoMX via Twitter</name> ' > $final



lynx --source http://twitter.com/SismologicoMX | grep "entry-content" | \
sed 's/<[^>]*>//g' | awk ' {print \
" <Placemark> \
<name> ", $11, " </name> \n \
<description> " $0" </description>\n \
<LookAt> \n \
<longitude>",$8,"</longitude> \n \
<latitude>",$6,"</latitude> \n \
<altitude>-"$10" </altitude> \n \
<range>100</range> \n \
<tilt>0</tilt> \n \
<heading>0</heading> \n \
</LookAt> \n \
<styleUrl>#bajo</styleUrl> \n \
<Point> \n \
<coordinates>",$8","$6",-"$10"</coordinates> \n \
</Point> \n \
</Placemark> \n " \
}' >> $final


echo '
</Folder>
</Document>
</kml>
' >> $final

zip sismos-`date +%Y-%m-%d.%R`.kmz doc.kml

echo "archivo sismos.kmz generado"



Creando kmz desde la info de twitter. (ii)

Ok, ahora voy a mostrar como está construido un archivo kml, que es el que contiene la información para desplegarla en el google-earth. El archivo es un XML que contiene información sobre los puntos (coordenadas, latitud, longitud) para desplegarlos sobre el mapa.



<?xml version="1.0" encoding="UTF-8"?> 
<kml xmlns="http://earth.google.com/kml/2.1"> 
    <Document>
      <name> Ultimos sismos registrados </name> 
         <Style id="bajo"> 
              <IconStyle> 
                <scale> 0.7 </scale> 
                <Icon> 
                       <href>root://icons/palette-3.png</href> 
                      <x>64</x> 
                      <y>64</y> 
                      <w>32</w> 
                      <h>32</h> 
                </Icon> 
              </IconStyle> 
             <LabelStyle> 
                 <scale>0.7</scale> 
              </LabelStyle> 
          </Style> 
          <Style id="alto"> 
              <IconStyle> 
                <scale> 0.7 </scale> 
                <Icon> 
                       <href>root://icons/palette-3.png</href> 
                      <x>64</x> 
                      <y>96</y> 
                      <w>32</w> 
                      <h>32</h> 
                </Icon> 
              </IconStyle> 
             <LabelStyle> 
                 <scale>0.7</scale> 
              </LabelStyle> 
          </Style> 
          <Folder> 
            <name> Sismos de SismologicoMX via Twitter</name> 

hasta aquí tenemos el encabezado, definiendo 2 tipos de estilos para mostrar los iconos, el nombre de la carpeta y la identificación del archivo.

Luego viene la parte de los puntos sobre el mapa, la cual se va a repetir dependiendo del número de puntos que se quieran mostrar.

<placemark>
      <name> NOMBRE </name>
         <description> DESCRIPCION  </description>
         <lookat>
                 <longitude> LONGITUD </longitude>
                 <latitude> LATITUD </latitude>
                 <altitude> ALTURA </altitude>
                 <range>100</range>
                 <tilt>0</tilt>
                 <heading>0</heading>
         </lookat>
         <styleurl>#bajo</styleurl>
         <point>
                 <coordinates> LONGITUD, LATITUD, ALTURA </coordinates>
         </point>
     </placemark>

Finalmente el cierre del documento:

 </Folder> 
</Document> 
</kml> 

Esta información la puedes observar en cualquier punto que añadas al google earth, lo exportes y luego la abras en un editor de texto, o bien puedes consultar los manuales oficiales de google-earth.

En la siguiente entrega, veremos como acoplar todo esto :)

Creando kmz desde la info de twitter. (i)

Las columnas de Dave Taylor en LinuxJournal son muy buenas, utiliza bash para MUCHAS cosas. Siguiendo la línea, voy a programar un script para que obtenga la información que el Sistema Sismológico Nacional "twittea" y lo ponga en un archivo kmz que googleearth entienda.

El dia de hoy, muchos sismos "menores" en Baja California, yo creo que la península se va a desprender :)

Los datos que ponen en Twitter bajo SismologicoMX son generados automáticamente, así que tienen una estructura consistente, lo primero es descargar la info de twitter, y para esto utilizaré el buen amigo lynx, con la opción de código fuente para parsear el html directamente, buscando la clase entry-content, que es la que contiene el micropost, afortunadamente está en la misma linea, asi que con el siguiente código lo obtenemos:


lynx --source http://twitter.com/SismologicoMX | grep "entry-content"


agrego un poco de sed para eliminar los tags html :


lynx --source http://twitter.com/SismologicoMX | grep "entry-content" | \
sed 's/<[^>]*>//g'


y con esto tenemos la linea de los datos, para obtener la información que me interesa, como fecha, hora, latitud, longitud, profundidad y magnitud, agrego un poco de awk :


lynx --source http://twitter.com/SismologicoMX | grep "entry-content" | \
sed 's/<[^>]*>//g' | awk ' {print $2,$4,$6,$8,$10,$11 }'


Con esto termino este post, ya con esos datos, en el siguiente veremos como utilizarlos para formar el archivo kmz.


Ejemplo de resultados:

2010-04-15 05:20:08 31.95 -113.47 10 M=4.2
2010-04-15 04:28:19 32.28 -115.32 16 M=3.5
2010-04-15 04:20:39 32.08 -114.92 20 M=3.9
2010-04-15 03:51:01 32.66 -115.55 10 M=3.8
2010-04-15 02:17:22 32.47 -115.33 8 M=3.4
2010-04-15 01:35:21 32.73 -115.81 16 M=3.6
2010-04-15 01:19:56 32.63 -115.76 16 M=3.7
2010-04-15 00:14:30 32.14 -115.23 17 M=3.5

Ejercicio en bash para descargar ...

Existen varias alternativas para descargar archivos de r*pidsh*re sin pagar por una cuenta, con la respectiva espera y todo ...

El que uso se llama autorapid.rb, y está escrito en ruby, es muy bueno.

La cuestión es que me dió curiosidad por comprar una cuenta para no tener que estar esperando por las descargas, blablabla ... y al intentar modificar este programa pues resulta que ... me resultó más fácil realizar otro que hiciera algo similar. MMM ya mencioné que el dicho programa funciona en modo texto ?? Eso es importante, ya que pretendo tener un Linux sin ambiente gráfico solo para descargas :)

Aunque existen "downloaders" que me permiten bajar del sitio en cuestión y de otros sitios, no encontré alguno en modo texto, así que urgando por ahí encontré que se puede utilizar el famoso **wget** para realizar estas descargas, y para no hacerlo a mano, pues tirando algunas lineas en bash (y aprovechando otros comandos) se puede automatizar algunas cosas al momento de descargar, por ejemplo:

* Verificar que todos los links estén disponibles antes de realizar la descarga.
* Interrumpir la descarga ... y tratar de continuar donde se quedó
* Hacer 4 descargas paralelas.

Para esto hacemos uso de lynx, wget y xargs, y a continuación les pego mi programa que llamé: bajarRapid.bash

nota: NECESITAS CUENTA PAGADA y haber creado la cookie.



##########################################################################################
#!/bin/bash
# Hugo Gonzalez, 2010
# hugo (dot) glez (AT) gmail (dot) com
# Programa para descargar de manera simultanea desde r*apidsh*are
# TENIENDO CUENTA PAGADA...



# archivo donde se verifican los links
file=".file.ok"

li=`cat $1`

###############
# Se verifican los links en paralelo :)
function chk_link
{
E=`lynx --dump $url | grep Error`
if [ "$E" = "Error" ]; then
echo "link roto ! : $url" >> $file
else
echo "OK : $url" >> $file
fi
}
################


if [ -f $file ]; then
echo "Ya se verificaron los links !"
else
# verificar links
echo "Validando links !"
for url in $li
do
chk_link $url &
done
wait # espera a que finalicen los procesos en segundo plano
E=`grep roto $file`
if [ "$E" == "" ]; then
echo "Todos los links OK"
else
echo "Existen algunos links rotos"
grep roto $file
exit 1
fi
fi


echo "Revisando archivos existentes !"

for a in $li
do
NA=`echo $a | cut -d'/' -f6`
if [ -f $NA ]; then
echo "$NA existe, omitiendo"
else
lin="$lin $a"
fi
done

echo "comenzando la descarga paralela de 4 archivos"


# para este paso debes haber creado previamente la cookie :)
echo $li| tr ' ' '\n' | xargs -P4 -I{} wget -c --load-cookies ~/.cookies/rapidshare {}

Sorpresa, sorpresa con el xserver-xorg en Ubuntu 9.04

Pues resulta que últimamente he tenido algunos conflictos en mi portatil con los gráficos, van lentos e incluso extrañamente en algunas ocasiones luego de un uso intenso (como una semana sin apagarlo) se ponen todavía más lentos y al reiniciar simplemente no funcionan las X. Dejo reposar la máquina unas horas, y al iniciar nuevamente todo parece funcionar correctamente.

Hoy estuve revisando alguna información y luego de meterle mano a la configuración del X e instalar un driver nuevo de ubutnu-x team, según como indican aquí el sistema parece ir MUY bien, vamos a probarlo un poco y vemos que pasa.

Luego al intentar ver el archivo de configuración de mi equipo de escritorio (que también trae tarjeta gráfica intel) me sorprendo que el archivo de configuración xorg.conf, esta vacio ...
Cabe mencionar que este equipo fue instalado desde cero, y el portátil ha sufrido actualizaciones.

Y como no he tenido ningún problema con el de escritorio, pues ni tocar la configuración, ni por curiosidad hasta ahora, y gran sorpresa que ya toda la configuración, drivers, resoluciones, dispositivos etc, etc se realizan de manera completamente automática. Creo que esto es un gran avance para los nuevos en el sistema, y claro que puedes modificar tu configuración para ajustarla si eres usuario avanzado.

Hace tiempo vi la nueva arquitectura de X y su relación con la capa de abstracción de hardeare (hal) ... creo que hace falta repasarla.

Estadísticas de vulnerabilidades en Apps web

Me acabo de enterar que Web Application Security Consortium [webappsec] publicó su reporte de 2008 y los datos son críticos, entre un 80 y 96% de los más de 12186 sitios evaluados contienen vulnerabilidades; y que un 99% de ellos no cumple las especificaciones del estándar PCI DSS.

La principal vulnerabilidad es el XSS (por cierto, blackboard tiene eso), seguida de divulgación de información y luego SQL injection.

Inicio del proyecto

Desde hace tiempo tengo la intención de volver a tener blog, ya que hace casi 2 años que se murió el anterior, en este me concentraré en recuperar y explicar las ponencias sobre temas de software libre y seguridad que he impartido en los últimos años.