El rincón de Zerial » Documentacion

Manipular volúmenes lógicos (LVM) en discos virtuales

Zerial — Wed, 14 Sep 2011 07:48:50 +0000

Me refiero a discos virtuales a los que creamos usando dd. Cuando creamos un disco utilizando por ejemplo dd if=/dev/zero of=imagen.img y lo usamos para crear una máquina virtual, en este caso con Xen, luego le instalamos un sistema operativo que maneje ya sea CentOS, RHEL, Debian o cualquier otro que maneje LVM en la instalación, hay veces que necesitamos manipularlo ya sea para clonarlo, hacerle mantención o simplemente montarlo para ver los archivos. En mi caso, tuve que clonar la máquina virtual en caliente y quedó el FS corrupto, por lo que tuve que corregirlo, tambien sirve para hacer tareas de mantención como aumentar o disminuir el tamaño del disco o volúmenes lógicos.

Tengo mi disco original llamado “vm1.img” y la clono simplemente con un cp o bien con “dd if=vm1.img vm1_clon.img“, paso a paso, lo que tenemos que hacer es:

Crear un dispositivo “loop” en base a nuestro disco virtual
Mapear el dispositivo loop creado
Revisar los dispositivos creados en /dev/mapper/
Activar el volúmen y realizar las tareas necesarias

Las herramientas que usé son losetup, kpartx y vgchange.

Primero, ya tenemos nuestro disco creado, en este caso lo llamaré “testing” y tiene un tamaño de 80GB.
# fdisk -l testing


Disk testing: 85.9 GB, 85899345920 bytes

255 heads, 63 sectors/track, 10443 cylinders, total 167772160 sectors

Units = sectors of 1 * 512 = 512 bytes

Sector size (logical/physical): 512 bytes / 512 bytes

I/O size (minimum/optimal): 512 bytes / 512 bytes

Disk identifier: 0x0007759f

Device Boot Start End Blocks Id System testing1 * 63 208844 104391 83 Linux testing2 208845 167766794 83778975 8e Linux LVM

Para comenzar vamos a usar el comando losetup para crear un dispositivo “loop” en base a nuestra imagen de disco, para esto ejecutamos:

# losetup -f testing

Y verificamos con el mismo comando losetup que se haya creado

# losetup -a /dev/loop0: [fe01]:24577 (/mnt/vardata/testing)

Ya tenemos nuestro dispositivo “loop” en /dev/loop0 mapeado a la imagen de disco virtual ubicada en /mnt/vardata/testing.

Ahora debemos usar la herramienta kpartx para mapear ese dispositivo que hemos mapeado a nuestro disco virtual hacia nuestro administrador de volúmenes lógicos

# kpartx -a -v /dev/loop0 add map loop0p1 (254:2): 0 208782 linear /dev/loop0 63 add map loop0p2 (254:3): 0 167557950 linear /dev/loop0 208845

Ahora tenemos otros dispositivos creados en /dev/mapper, corresponden a “loop0p1″ y “loop0p2″ correspondientes a las particiones de nuestro disco virtual. Así debería ser presentarse:

# ls -lia /dev/mapper/ total 0 1072 drwxr-xr-x 2 root root 140 sep 13 15:19 . 3 drwxr-xr-x 15 root root 3260 sep 13 15:19 .. 1073 crw------- 1 root root 10, 236 ago 11 12:12 control 2672529 lrwxrwxrwx 1 root root 7 sep 13 15:19 loop0p1 -> ../dm-2 2671232 lrwxrwxrwx 1 root root 7 sep 13 15:19 loop0p2 -> ../dm-3 3655 lrwxrwxrwx 1 root root 7 ago 11 12:12 VolGroup_ID_15211-backup -> ../dm-0 3672 lrwxrwxrwx 1 root root 7 ago 11 12:12 VolGroup_ID_15211-vardata -> ../dm-1

Y el comando vgdisplay debería mostrar la información del grupo

# vgdisplay --- Volume group --- VG Name VolGroup00 System ID Format lvm2 Metadata Areas 1 Metadata Sequence No 3 VG Access read/write VG Status resizable MAX LV 0 Cur LV 2 Open LV 0 Max PV 0 Cur PV 1 Act PV 1 VG Size 79,88 GiB PE Size 32,00 MiB Total PE 2556 Alloc PE / Size 2556 / 79,88 GiB Free PE / Size 0 / 0 VG UUID yAIBPd-1PD6-IN1U-aoK7-bLSW-rz08-ERktCp

Y con lvdisplay revisamos la información de los volúmenes dentro del grupo VolGroup00

# lvdisplay VolGroup00 --- Logical volume --- LV Name /dev/VolGroup00/LogVol00 VG Name VolGroup00 LV UUID Du8Hwj-BUff-RhS3-lNTZ-KsxS-jvEp-S71om4 LV Write Access read/write LV Status NOT available LV Size 77,84 GiB Current LE 2491 Segments 1 Allocation inherit Read ahead sectors auto

--- Logical volume --- LV Name /dev/VolGroup00/LogVol01 VG Name VolGroup00 LV UUID Sg3KQG-F3Ad-kgIx-yJi0-OSxm-fBUg-bKUR3O LV Write Access read/write LV Status NOT available LV Size 2,03 GiB Current LE 65 Segments 1 Allocation inherit Read ahead sectors auto

Si te fijan en un detalle, en ambos volúmenes, el estado es “NOT available“, pues debemos activarlo

# vgchange VolGroup00 -a y 2 logical volume(s) in volume group "VolGroup00" now active

Y volvemos a revisar

# lvdisplay VolGroup00 --- Logical volume --- LV Name /dev/VolGroup00/LogVol00 VG Name VolGroup00 LV UUID Du8Hwj-BUff-RhS3-lNTZ-KsxS-jvEp-S71om4 LV Write Access read/write LV Status available # open 0 LV Size 77,84 GiB Current LE 2491 Segments 1 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 254:4

--- Logical volume --- LV Name /dev/VolGroup00/LogVol01 VG Name VolGroup00 LV UUID Sg3KQG-F3Ad-kgIx-yJi0-OSxm-fBUg-bKUR3O LV Write Access read/write LV Status available # open 0 LV Size 2,03 GiB Current LE 65 Segments 1 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 254:5

Ya los tenemos disponibles y ahora podemos trabajar con ese volúmen como si fuese un “lvm” normal, realizar tareas de mantención, montar el volumen, disminuir o aumentar su tamaño, etc.

Cuando ya terminemos de hacer todo lo que queramos con el disco virtual, hay que volver todo a la normalidad, haciendo los pasos inversos:

Desactivar el volumen
# vgchange VolGroup00 -a n 0 logical volume(s) in volume group "VolGroup00" now active

Remover el mapeo de los dispositivos loop0p1 y loop0p2 creados desde loop0
# kpartx -d /dev/loop0

Remover el mapeo de /dev/loop0 creado desde nuestro disco virtual “testing”
# losetup -v -d /dev/loop0

Ya dejamos todo como estaba y podemos volver a utilizar nuestro disco virtual.

Mini-Post: Acceso directo a archivos de descarga

Zerial — Sun, 11 Sep 2011 01:36:22 +0000

Una forma de hacer un bypass a los sistemas de autenticación es poder acceder a archivos “sensibles” que sólo un usuario con autorización debería poder ver. Existen muchos sitios que tienen panel de administración pero no protegen los directorios donde se encuentran los archivos, por ejemplo, imaginemos que el usuario “admin” subió un archivo con datos de acceso a un servidor y en el sistema configuró que sólo algunos usuarios puedan verlo, sin embargo, cualquier persona que se sepa la URL puede acceder a el … Aunque suene bastante simple e incluso estúpido, es lamentable que existan sistemas o sitios web que lo permiten.

Por lo general, esto sucede cuando no existe una capa intermedia entre el archivo y el sistema, sino que se linkea directamente. Algo que debería ser http://www.dominio.cl/sistema/index.php/descargar/949394 es http://www.dominio.cl/sistema/admin/archivos/usuarios_y_passwords.docx, y en el peor de los casos hasta se puede eliminar el nombre del archivo y listar el contenido del directorio “archivos”

Los sistemas web deberían manejar internamente un “id” o nombre ficticio del archivo, hasheado y mapeado al momento de subirlo, para no permitir que cualquier usuario pueda acceder. Por ejemplo, si tenemos la URL de prueba dada anteriormente, 949394 correspondería al ID del archivo, el sistema debería -internamente- hacer una consulta a la base de datos y ver a que archivo corresponde ese ID, luego ver quienes tienen permisos para acceder a ese archivo y, luego de verificar la sesión y permisos, permitir la descarga del archivo.
Para evitar la descarga directa de los archivos, el directorio “uploads” debería estar fuera del directorio de la aplicación, por ejempo, si el directorio de la aplicación es /var/www/html/sistema1/, el directorio debería estar fuera de “sistema1″, sino, aunque hagas todas las validaciones posibles, de todas formas se podrá acceder directamente al archivo saltandose la validación de la aplicación.

Tethering con un BlackBerry 8520 en Archlinux via bluetooth

Zerial — Wed, 05 Jan 2011 17:09:10 +0000

Si bien lo probé con Archlinux, tambien hay evidencias que funciona en Debian aunque, independiente de la distribución, debería funcionar para cualquiera. Tambien debería funcionar con cualquier celular que soporte “Dial Up“.
Debemos tener instaladas las herramientas de bluetooth: bluez-utils bluez-libs dbus wvdial

Primero, debemos poner el bluetooth del teléfono en modo escucha y escanearlo con nuestro disponisitivo, para ver si soporte el modo.

[root@balcebu zerial]# hcitool scan Scanning ... F4:0B:93:DB:90:FF BlackBerry 8520 [root@balcebu zerial]#

Y vemos si soporta el modo Dial Up

root@balcebu zerial]# sdptool browse F4:0B:93:DB:90:FF Browsing F4:0B:93:DB:90:FF ... [...] Service Name: Dialup Networking Service RecHandle: 0x10000 Service Class ID List: "Dialup Networking" (0x1103) "Generic Networking" (0x1201) Protocol Descriptor List: "L2CAP" (0x0100) "RFCOMM" (0x0003) Channel: 1 Profile Descriptor List: "Dialup Networking" (0x1103) Version: 0x0100 [...]

En este caso soporta, en el canal 1.

Hay que configurar el archivo /etc/bluetooth/rfcomm.conf

#
# RFCOMM configuration file.
#

rfcomm0 {
#       # Automatically bind the device at startup
        bind yes;
#
#       # Bluetooth address of the device
        device F4:0B:93:DB:90:FF;
#
#       # RFCOMM channel for the connection
        channel 1;
#
#       # Description of the connection
        comment "BlackBerry 8520";
}

“device” corresponde a la MAC encontrada al hacer el scan, es decir, la de nuestro dispositivo movil y Channel, el canal en el cual está soportado el “Dial Up”.

Luego ejecutamos hidd –connect F4:0B:93:DB:90:FF y rfcomm connect 0 para establecer la conexion con el telefono.

[root@balcebu bluetooth]# hidd --connect F4:0B:93:DB:90:FF [root@balcebu bluetooth]# rfcomm connect 0 Connected /dev/rfcomm0 to F4:0B:93:DB:90:FF on channel 1 Press CTRL-C for hangup

En el telefono debería aparecer la opción de “emparejamiento”. Ahora debemos configurar wvdial, editamos el archivo /etc/wvdial.conf y agregamos:

[Dialer blackberry]
Modem = /dev/rfcomm0
Baud = 115200
Dial Command = ATDT
Init2 = AT+CGDCONT=1,"IP","imovil.entelpcs.cl"
FlowControl = crtscts
Modem Type = Analog Modem
Username = entelpcs
Password = entelpcs
Stupid Mode = 1
New PPPD = yes
Phone = *99#

En este caso, estoy conectado con el operador “entelpcs” y los datos corresponden a ésta compañía, en el caso de pertenecer a otro proveedor, deben camiar los datos” Init2, Username y Password por los que correspondan.
Una vez añadida la configuración al archivo, ejecutamos

# wvdial blackberry --> WvDial: Internet dialer version 1.61 --> Cannot get information for serial port. --> Initializing modem. --> Sending: ATZ ATZ OK --> Sending: AT+CGDCONT=1,"IP","imovil.entelpcs.cl" AT+CGDCONT=1,"IP","imovil.entelpcs.cl" OK --> Modem initialized. --> Sending: ATDT*99# --> Waiting for carrier. ATDT*99# CONNECT --> Carrier detected. Starting PPP immediately. --> Starting pppd at Wed Jan 5 09:52:13 2011 --> Pid of pppd: 24392 --> Using interface ppp0 --> pppd: Ð¶·¸[12][10] --> pppd: Ð¶·¸[12][10] --> pppd: Ð¶·¸[12][10] --> pppd: Ð¶·¸[12][10] --> local IP address 186.10.247.119 --> pppd: Ð¶·¸[12][10] --> remote IP address 169.254.1.1 --> pppd: Ð¶·¸[12][10] --> primary DNS address 200.63.56.3 --> pppd: Ð¶·¸[12][10] --> secondary DNS address 200.63.56.4 --> pppd: Ð¶·¸[12][10]

Listo, el proveedor ya me asignó una ip publica y puedo navegar a traves de mi celular.

Referencias:

Bluetooth GPRS Howto: https://wiki.archlinux.org/index.php/Bluetooth_GPRS_Howto
Configurando un Blackberry como Modem en Debian: http://apostols.net/?p=176
Guía Bluetooth de Gentoo Linux: http://www.gentoo.org/doc/es/bluetooth-guide.xml

Migración de datos en Drupal

Zerial — Fri, 02 Oct 2009 01:25:14 +0000

Drupal 6 nos provee de una API que nos permitirá trabajar directamente con el core, usando las funciones, módulos y configuraciones ya existentes. De esta forma, y gracias a los hooks, podemos realizar distintas funciones tales como agregar, eliminar y modificar usuarios y contenidos, manejar los comentarios, configuraciones, etc.
La idea de este artículo es ayudar a las personas que necesiten realizar una migración (importación/exportación) desde un sistema distinto hacia Drupal.

Las funciones que necesitamos de la API de Drupal son:

user_save(): Permite la manipulación de los usuarios.
node_save(): Manipulación de los nodos (contenidos).
db_query(): Nos permite realizar consultas a la base de datos usando la configuración de Drupal.

Con estas funciones ya podemos pensar en realizar una migración total o partial de un sitio. La lógica del asunto es sencilla, tenemos que hacer un “wrapper” que conecte ambas plataformas (hablando de base de datos y ficheros), hacer que por un lado se conecte a la base de datos de la plataforma antigua y por otro lado a Drupal, que vaya leyendo los datos desde la plataforma antigua y luego insertandolos en la nueva plataforma usando las funciones de la API, por ejemplo, si tenemos la tabla usuarios con los tipicos campos nombre, email, usuario, password, en Drupal la estructura de la tabla {users} es similar, contiene los campos email, name y pass (los que nos sirven) entre otros. Entonces lo que debemos hacer es un pequeño script que haya un SELECT email, password, usuario FROM usuarios y hacer que cada registro que lea, lo inserte en la tabla {users} mediante la API (función user_save()).
Ejemplo:

$var1 = mysql_query("SELECT email,password,usuario FROM usuarios", $link);
while($data = mysql_fetch_array($var1)){
$userdata = array(
‘status’ => 1,
‘name’ => $data[‘usuario’],
‘pass’ => ’123′,
‘picture’ => $_avatar,
‘mail’ => $data[‘email’],
);
user_save(”, $userdata);
}

El tema de la contraseña es más complicado, va a depender únicamente de que si la contraseña está en texto plano o encriptada en la base de datos de origen. Si esta en texto plano, entonces basta con agregar al arreglo userdata el valor $data['password'] a la variable pass. De lo contrario, tendremos que hacer un pequeño truco. Creamos el usuario asignandole una clave fake, por ejemplo 123456 y posteriormente, usando la función db_query, hacemos el UPDATE necesario para cambiarle el password al usuario creado, ingresando directamente el HASH original (pensando que esta en md5).

Para realizar la migración de contenido, el procedimiento es de la misma forma, seleccionar la información de un lado y llevarla a otra usando la función node_save.
Si algo se nos escapa de las manos y no sabemos como hacerlo, basta con que entendamos el modelo de la base de datos e ingresemos directamente las consultas a la base de datos (no lo recomiendo).

Hace unos días me tocó la tarea de realizar la migración de una plataforma X a Drupal, para esto diseñe una clase que me permite hacer la migración paso por paso.

< ?php
chdir("api/");
include_once ‘api/includes/bootstrap.inc’;
drupal_bootstrap(DRUPAL_BOOTSTRAP_FULL);
flush();
class Drupal{
private $user;
private $id_uid;
public $counter;
public function __construct(){
$this->id_uid = array();
$this->counter = array(‘users’ => 0, ‘news’ => 0, ‘comments’ => 0);
$this->clearDatabase();
}
public function clearDatabase(){
$_queries = array(
‘users’ => ‘DELETE FROM dp_users WHERE name != \’admin\’ AND name != \’asdf\’‘,
‘nodes’ => ‘DELETE FROM dp_node WHERE type NOT IN (\’intro\’, \’adminpage\’)’,
‘comments’ => ‘DELETE FROM dp_comments’,
// ‘terms_rel’ => ‘DELETE FROM dp_term_node’,
// ‘terms’ => ‘DELETE FROM dp_term_data WHERE tid NOT IN (3, 6)’,
‘groups’ => ‘DELETE FROM dp_og’,
‘groups_uid’ => ‘DELETE FROM dp_og_uid’,
‘groups_ancestry’ => ‘DELETE FROM dp_og_ancestry’,
‘groups_notifications’ => ‘DELETE FROM dp_og_notifications’,
‘dp_job_posting’ => ‘DELETE FROM dp_job_posting’,
‘dp_job_posting_country’ => ‘DELETE FROM dp_job_posting_country’,
);
foreach($_queries as $query){
print ">>[DP_SQL] ".$query."\n";
db_query($query);
}
}
public function createUser($data){
$_avatar_base_path = "sites/default/files/pictures/";
$_avatar = ($data[‘avatar’] == "usuarioSinAV.jpg")?NULL:$_avatar_base_path.$data[‘avatar’];
$_user = array(
‘status’ => 1,
‘access’ => time(),
‘name’ => $data[‘username’],
‘pass’ => ’123′,
‘picture’ => $_avatar,
‘profile_nombres’ => $data[‘nombres’],
‘profile_apellido’ => $data[‘apellidos’],
‘profile_intereses’ => $data[‘about’],
‘profesion’ => $data[‘profesion’],
‘mail’ => $data[‘email’],
);
$user = user_save(”, $_user);
self::_setPassword($user->uid, $data[‘password’]);
// self::_setUserRole($user->uid);
self::_configureProfile($data, $user->uid);
if($data[‘admin’]) self::_setAdmin($user->uid);
$this->user = &$user;
$this->id_uid[$data[‘id’]] = $user->uid;
$this->counter[‘users’]++;
}
public function createContent($data, $type){
$node = new stdClass();
$node->type = $type;
$node->uid = $this->user->uid;
$node->name = $user->user->name;
$node->promote = 1;
$node->format = FILTER_FORMAT_DEFAULT;
$node->status = 1;
$node->title = html_entity_decode($data[‘titulo’]);
$node->body = $data[‘cuerpo’];
$node->taxonomy = self::_convertTaxonomy();
$node->comment = 2;
$node->created = strtotime($data[‘fecha’]);
print ">>[node:".$type."] ".substr($node->title, 0, 30)."… (".substr($node->body, 0, 20)." …) [tax:{".implode(";", $node->taxonomy)."},uid:".$node->uid."]\n";
$this->counter[‘news’]++;
node_save($node);
$q = "INSERT INTO dp_node_access(nid, grant_view, realm) VALUES((SELECT MAX(nid) FROM dp_node),1, ‘all’)";
db_query( $q );
}
public function insertCommentProfile($data){
print ">>[comment;autor:".$this->id_uid[$data['autor']].",uid:".$data['userid']."] (".rtrim(substr($data[‘comentario’], 0, 30))." …)\n";
db_query("INSERT INTO {comments} (pid, uid, hostname, comment, status, name, mail, homepage, timestamp) VALUES(%d, %d, ‘%s’, ‘%s’, %d, ‘%s’, ‘%s’, ‘%s’, %d)", $data[‘userid’], $this->id_uid[$data[‘autor’]], ’127.0.0.1′, $data[‘comentario’], 1, ”, ”, ”, time());
$this->counter[‘comments’]++;
}
private function _convertTaxonomy($taxonomy = NULL){
$_categories = array();
$_categories[] = 29;
$_categories[] = 30;
$_categories[] = 31;
$_categories[] = 32;
$_categories[] = 33;
$_categories[] = 34;
$_categories[] = 35;
return array( ($taxonomy)?$_categories[–$taxonomy]:35 );
}
private function _setPassword($id, $md5){
$query = "UPDATE dp_users SET pass = ‘".$md5."’ WHERE (name != ‘asdf’ AND name != ‘admin’) AND uid = ".$id;
print ">>[DP_SQL] ".$query."\n";
db_query($query);
}
private function _setAdmin($id){
$table = "dp_users_roles";
//$query = "UPDATE ".$table." SET rid = 4 WHERE uid = ".$id; # 4 es el que corresponde segun SELECT * FROM dp_role
$query = "INSERT INTO ".$table."(rid, uid) VALUES(4, ".$id.")"; # 2 es el que corresponde segun SELECT * FROM dp_role
print ">>[DP_SQL] ".$query."\n";
db_query($query);
}
private function _setUserRole($id){
$table = "dp_users_roles";
$query = "INSERT INTO ".$table."(rid, uid) VALUES(2, ".$id.")"; # 2 es el que corresponde segun SELECT * FROM dp_role
print ">>[DP_SQL] ".$query."\n";
db_query($query);
}
private function _configureProfile($info, $_uid){
$uid = $info[‘id’];
$query = "SELECT a.nombre_esp FROM cat_paises a LEFT JOIN usr_users b ON b.pais = a.id WHERE b.id = ".$uid;
$_r = mysql_result(sqlExec($query, ‘query’), 0, ‘nombre_esp’);
db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(8, ".$_uid.", ‘".$_r."’)");
$query = "SELECT a.nombre_esp FROM paises a LEFT JOIN users b ON b.pais_residencia = a.id WHERE b.id = ".$uid;
$_r = mysql_result(sqlExec($query, ‘query’), 0, ‘nombre_esp’);
db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(9, ".$_uid.", ‘".$_r."’)");
/* $query = "SELECT a.profesion FROM users a WHERE a.id = ".$uid;
$_r = mysql_result(sqlExec($query, ‘query’), 0, ‘profesion’);
db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(3, ".$_uid.", ‘".$_r."’)");*/
$query = "SELECT a.nombre FROM cat_usr a LEFT JOIN usr_users b ON b.categoria = a.id WHERE b.id = ".$uid;
$_r = mysql_result(sqlExec($query, ‘query’), 0, ‘nombre’);
db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(4, ".$_uid.", ‘".$_r."’)");
$query = "SELECT a.subcategoria_es FROM areas_ciencia_subcat a, usr_users b WHERE b.area_ciencia_subcat != 0 AND b.area_ciencia_subcat = a.id_subcat AND b.id = ".$_uid;
if($_r = mysql_result(sqlExec($query, ‘query’), 0, ‘subcategoria_es’)){
db_query("UPDATE dp_profile_values SET value = ‘".$_r."’ WHERE fid = 7 AND uid = ".$_uid);
// db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(7, ".$_uid.", ‘".$_r."’)");
}
}
}

Esta clase nos permite crear una instancia para trabajar con Drupal y de esta forma poder migrar usuarios, contenidos, asignar taxonomias/categorias, resetear claves, insertar comentarios, etc. Cada método público debe ser llamado pasando como argumento un array con la información que desea ser insertada. Por ejemplo, una llamda al método createUser:

$_users = mysql_query("SELECT * FROM usuarios", $link);
while($_users_row = mysql_fetch_array($_users)){
// Llamada a API drupal para crear usuario
$drupal->createUser($_users_row);
}

Sencillamente, lo que hace este pedazo de código es consultar en una base de datos por todos los usuarios y posteriormente, por cada registro encontrado, llamar al método “createUsers” pasándole como argumento el row correspondiente al ciclo.

Les dejo el script “Migrar.php” que instancia la clase Drupal y hace uso de sus métodos:

< ?php
/*
* Lunes, 21 de Septiembre del 2009.
*
* Migrador de plataformas para
* Drupal.
*
*/
// Config
require_once("Config.php");
$conexion = mysql_connect($host, $username, $password) OR die("Error al conectar a la base de datos.\n");
// Llamada a nuestro wrapper
require_once("Drupal.class.php");
if(!mysql_select_db($database, $conexion)){
print "Error al seleccionar la base de datos.\n";
}
else{
$start = time();
$drupal = new Drupal();
// Usuarios
$table = "usr_users";
$query = "SELECT * FROM ".$table;
$_users = sqlExec($query, "print_query");
getRows($_users);
while($_users_row = mysql_fetch_array($_users)){
// Llamada a API drupal para crear usuario
$drupal->createUser($_users_row);
// Fin
$table = "infoc_news";
$query = "SELECT * FROM ".$table." WHERE autor = ".$_users_row[‘id’]." ORDER BY fecha";
$_news = sqlExec($query, "print_query");
getRows($_news);
while($_news_row = mysql_fetch_array($_news)){
// Llamada a API drupal para crear contenido
$drupal->createContent($_news_row, "news");
// Fin
}
}
// Comentarios en perfiles
$table = "usr_comments";
$query = "SELECT * FROM usr_coments WHERE responseTo = 0";
$_comments = sqlExec($query, "print_query");
getRows($_comments);
while($_comments_row = mysql_fetch_array($_comments)){
// Llamada a API drupal para insertar comentarios en perfiles
$drupal->insertCommentProfile($_comments_row);
// FIn
}
$stop = time();
$time = $stop – $start;
print "Migration done.\n";
print "+ Summary:\n";
print "|- Users:\t".$drupal->counter[‘users’]."\n";
print "|- Nodes:\t".$drupal->counter[‘news’]."\n";
print "|- Comments:\t".$drupal->counter[‘comments’]."\n";
print "|_ Time:\t".date("s", $time)." secs.\n";
}
/* sqlExec()
* Ejecuta y/o imprime una consulta SQL
*/
function sqlExec($query, $type){
global $conexion;
switch($type){
case ‘print’:
print ">>[SQL] ".$query."\n";
break;
case ‘query’:
return mysql_query($query, $conexion);
break;
case ‘print_query’:
print ">>[SQL] ".$query."\n";
return mysql_query($query, $conexion);
break;
case ‘default’:
print "Error en el modo de trabajo.\n";
break;
}
return NULL;
}
/* getRows()
* Imprime la cantidad de resultados obtenidas desde una consulta
*/
function getRows($resource){
print "< < ".mysql_num_rows($resource)." rows.\n";
}
?>

NOTA Estos scripts son los originales que he usado para migrar una plataforma, si alguien quiere darle un uso personal debe hacer las modificaciones correspondientes que se adapten a su propio modelo de datos y a sus propias necesidades.

Validar correctamente la subida de un archivo con php

Zerial — Thu, 04 Jun 2009 17:09:52 +0000

Cuando nos enfrentamos a esta situación se nos viene a la cabeza distintas formas de querer validar un fichero, según sea la necesidad; por tamaño, extension, etc.
Lo que voy a explicar es como realizar la una validación correcta y eficiente del tipo de archivo que se está subiendo y aprovecho de explicar tambien la importancia de realizar bien esta validación.

Antes que todo, hay que tener en claro como funciona esto de la subida de archivos y tener en mente que la validación se puede y debe hacerse a nivel de cliente y a nivel de servidor. Muchas veces me he enfrentado a situaciones donde el desarrollador solo hace la validación a nivel de cliente, en javascript. Por ejemplo, así:

Si llamamos a esa función pasando como parámetro archivo.txt no mostrara ningún error, de lo contrario, si pasamos otro argumento como pelicula.avi devolverá error y no nos dejará continuar.
Este tipo de validación es el menos eficiente, ya que realizar una petición por POST sin pasar por el formulario es algo muy simple, basta con tener las herramientas necesarias como por ejemplo curl.
Hay que dejar en claro que el hecho de validar un formulario unicamente en javascript es una gran irresponsabilidad, ya sea la validación de unos simples datos como los típicos nombres, apellidos, email hasta la subida de archivos. El realizar una validación por javascript nos entrega una capa más de seguridad, pero no la única.

Cuando realizamos un upload, para que el archivo pueda ser validado y procesado a nivel de servidor (php), es necesario que el archivo exista fisicamente en el servidor, es decir, que ya se haya subido, lo que no significa que vaya a ser publicado.

La validación correcta para el tipo de un archivo es mediante mime-type y no mediante su extension, ya que cambiarla es muy simple. El mime-type viene impregnado en las cabeceras del archivo y php es capáz de acceder a ellas cuando el fichero se encuentra en nuestro directorio temporal (ver imágen).
Cuando ya hemos realizado el upload, antes de realizar la operación mode_uploaded_file() debemos hacer la validación por su mime:

< ?php
$_FILES[‘nombreDelCampo’][‘type’];
?>

En esa variable se guardara el mimetype del fichero que ya hemos subido y que, actualmente, esta en nuestro directorio temporal. Los tipos de mimes pueden ser:

[...]
image/jpeg
image/png
image/gif
text/plain
application/octet-stream
audio/mpeg3
application/msword
[...]

Lista más completa de MimeTypes.

La importancia de realizar una validación correcta es sensilla, nos pueden meter un caballo de troya, es decir, subir un fichero que tenga extension .jpg pero que en realidad sea un .mp3. Si nos basamos solamente en la validacion javascript, será muy facil saltarnos esa validacion y subir un fichero con la extension que nosotros queramos, por ejemplo un .php “maligno” que nos permita una shell remota via web o algún fichero .exe con algún virus o troyano que queramos difundir.
Un ejemplo claro es lo que pasó en este caso, donde alguien subio a un servidor un fichero .exe infectado que luego empezo a propagarlo vía email usando un dominio supuestamente fiable.

Virtualizacion usando Xen

Zerial — Sun, 20 Jan 2008 01:05:02 +0000

Hasta hace unos dias solo habia probado la Virtualizacion usando vmware pero hace unos dias me puse a trabajar e investigar sobre Xen y hay varias cosas que me llamaron la atencion, su modo de trabajar, los conceptos que emplea, la facilidad y versatilidad, etc.

Bueno, en resumen Xen es una herramienta de virtualizacion que usa el mecanismo de paravirtualizacion y nos permite cambiar de un sistema operativo a otro en caliente (sin necesidad de apagar o reiniciar la maquina), ademas de cambiarle varias configuraciones (por ejemeplo la ram) en caliente tambien. A nivel de procesador, el sistema operativo se ejecuta en una capa o nivel superior a la de los programas, bueno, Xen despacha de ese nivel al sistema operativo quedando el en ese nivel. Se dice que el sistema operativo es el supervisor de los programas que se ejecutan, pues Xen es nuestro Hipervisor (que esta por sobre el supervisor), es quien ‘supervisa’ al supervisor, es decir, un rango mas alto … Se podria decir que el sistema operativo se ejecuta sobre Xen.

Por ejemlpo, cuando uno esta en un sistema operativo puede abrir y cerrar aplicaciones, iamgen eso pero abriendo y cerrando segun el antojo de cada uno los sistemas operativos.
Esta caracteristica se logra modificando el codigo fuente de nuestro sistema operativo, por lo que solo en sistemas de codigo abierto se puede instalar, como el Kernel de Linux. Intel y AMD han colaborado con todo este desarrollo de la
virtualizacion y como es en el caso de Windows, que es un sistema de codigo cerrado, no se podria virtualizar. Pues Intel y AMD desarrollaron procesadores con capacidad de correr el sistema operativo en otro nivel, sin necesidad de modificar el codigo, dando la posibilidad de virtualizar cualquier sistema operattivo.

Una de las preguntas que me hicieron fue

O sea, Xen en Linux funciona en cualquier pc, Xen con Windows requiere
procesadores con soporte para virtualización… Eso es?

En teoria, segun lo dicho anteriormente deberia ser asi, ya que Microsoft no da acceso al codigo fuente de Windows, pero si Microsoft colaboro con este proyecto para que si se pudiera (a ellos tambien les ayudaria).

Algoritmos de ordenamiento

Zerial — Thu, 22 Nov 2007 00:29:32 +0000

Por motivos de estudio, he estado durante unos dias investigando sobre los distintos metodos de ordenamiento. Imaginemos un vector o una matriz con numeros o letras (o palabras) desordenadas u ordenadas, los algoritmos de ordenamiento nos permite ordenar en distinto orden los elementos de nuestro vector o matriz. Cada algoritmo tiene distinta complejidad.

Existen algoritmos o metodos simples como el conocido “Burbuja” o “Bubble”, siendo algo tan facil de entender y de escribir, existen tres versiones, una mas eficiente que otra, donde el tiempo de ejecucion o de ordenacion puede reducir hasta “n” veces. (donde n es la cantidad e elementos). Existen metodos aun mas eficientes y usando la tecnica de recursion podemos llegar a ordenar millones de elementos en menos de 1 segundo, como el conocido como “Ordenamiento Rapido” o “Quicksort”.

He hecho un informe o trabajo de investigacion comparando y explicando distintos tipos de ordenamiento. El lenguaje de programacion que he usado para los algoritmos y el para medir el tiempo de ejecucion es Java.

Descargar Documento (Informe):
PDF