find /proyectos/app/ -name *.erb -exec ls -l {} \; | wc -l
  #busco todos los que terminan en .erb, porque es un proyecto en Rails

Me dió la módica suma de 444 archivos. Ahora si se complicaba demasiado hacerlo a mano.
Me puse a incursionar un poco en bash y salió esto:

a=$(find $1 -name "*.erb"); #busco los archivos y guardo los paths en una lista
for i in $a; do #recorro la lista
   cat $i | egrep 'class="' | awk -F 'class=' '{print $2}' | awk -F '"' '{print $2}' | awk -F ' ' '{for (j=1; j<=NF; j++)  print $j; print "\n"}' >> clases.txt
done  
 
sort clases.txt >> clases2.txt #ordeno el archivo y lo guardo en otro
rm clases.txt #elimino el primer archivo
uniq -u clases2.txt >> clases.txt #borro las l&iacute;neas duplicadas (ya que las clases no son &uacute;nicas)
rm clases2.txt #elimino el archivo auxiliar

La tercer linea del script la explico aca abajo, sino no se iba a entender nada

cat $i: muestra el contenido del path que le estamos pasando.
egrep ‘class=”‘: Me muestra solo las líneas que contienen ‘class=”‘, que es como definimos una clase en html.
awk -F ‘class=’ ‘{print $2}’:Hago como un split a un string separando por ‘class=’ y mostrando solo el segundo valor, es decir todas las clases que tenga ese tag.
awk -F ‘ ‘ ‘{for (j=1; j<=NF; j++) print $j; print "\n"}': Como ya tenemos en una sola línea todas las clases de un tag, y sabemos que las clases se separan con un espacio, hacemos nuestro split por espacios y recorremos todas las variables y las vamos imprimiendo con un salto de linea al final. Esto nos haría una lista con todas las clases que existan en los archivos html.
Después habriendo el archivo clases.txt, vemos las clases ordenadas y únicas

Quizá se pueda costumizar más, no usar 2 archivos sino solo uno. También se podria recorrer el archivo .css y compararlo con nuestro archivo, eliminando las líneas que necesitamos. Pero para salir del apuro anda perfecto. Y si queremos encontrar los id, es cuestión de reemplazar la búsqueda nomá, aunque me tira algunos datos sucios, ya que también se usa en javascript y en ruby, entonces por ahi se complicaba un poco más, pero les dejo como tarea para la casa jeje
Bueno espero les pueda servir y cualquier consulta no duden en comentar.

• Cortar segmentos de la red.
• Comprar software costosos.
• Incorporar Hardware tipo cazafantasmas con luces psicodélicas.
• Enviar memos y reprimir a los empleados que no son de sistemas, que no tienen la mas mínima idea de lo que es una dirección de IP.

Si en nuestra red tenemos una pc con linux esto es muy sencillo de resolver, el paquete se llama: arping.

Pasos para utilizarlo:

1) Instalación

sudo apt-get install arping

2) Uso

sudo arping -I eth0  192.168.0.1
 
ARPING 192.168.0.1
60 bytes from 00:26:55:36:ec:a1 (192.168.0.1): index=0 time=74.863 usec
60 bytes from 00:1a:92:4e:4c:9e (192.168.0.1): index=1 time=160.933 usec

Como se puede observar  el problema aquí es una IP duplicada asociada a dispositivos de red diferentes (placa de red, switch, router).

Su utilidad principal es hacer ping a direcciones mac, por ejemplo:

sudo arping -I eth0  00:26:55:2e:95:EE
 
ARPING 00:26:55:2e:95:EE
98 bytes from 192.168.0.1 (00:26:55:2e:95:EE): icmp_seq=2738 time=771.392 msec
98 bytes from 192.168.0.1 (00:26:55:2e:95:EE): icmp_seq=2740 time=770.830 msec

Esto ultimo resulta interesante de utilizarlo en redes WIFI. Entonces, de manera muy sencilla y sin costos adicionales resolvimos un problema  con Linux, espero les sea útil esta información.

Los héroes de esta historia son dos:

• SystemRescue
• VirtualBox

El primero es una LiveDistro es decir una distribución de Linux que se ejecuta en el arranque sin instalarse en un disco duro. Un comentario al margen respecto de esto es que en nuestro país Argentina se encuentra una de las primeras LiveDistro del Planeta y lleva el nombre de UTUTO, además de ser la primer Distribución reconocida totalmente libre por el proyecto GNU.

Volviendo a SystemRescue en particular la uso por el Kit de herramientas necesarias para cuando ocurre lo peor, una de estas herramientas que me agrada mucho utilizar es Partimage http://www.partimage.org, por medio de esta podemos crear imágenes comprimidas en Bzip2 o Gzip de particiones (ext2/3, ntfs, fat32,etc) y luego restaurarlas.Entonces si tengo una imagen de mi sistema esto me permitira clonarlo en otra maquina sin mayores problemas y si es una maquina virtual con VirtualBox mucho mejor.

Aqui nos detendremos a darle su mencion a VirtualBox que si bien hoy por hoy es parte del imperio Oracle, no deja de ser una herramienta útil, simple y actualizada. Entre las importantes cualidades que tiene para mi son: Multiplataforma y exportación Appliance.

Por lo tanto la idea es salvar sistemas de la siguiente manera:

1. Booteo la maquina que quiero salvar con SystemRescue
2. Una vez SystemRescue termino de levantar y me dio una Consola, ejecuto Partimage
3. Con Partimage voy a crear imágenes del Sistema que estará en algunos de los discos presentes (Generalmente suele ser /dev/hda o /dev/sda).
4. La imagen resultante la copiare en otro medio, por ejemplo un disco extraíble de buena capacidad.
5. Instalo en otra maquina VirtualBox y creo una maquina Virtual.
6. En esa maquina virtual hago que arranque SystemRescue.
7. En la maquina virtual que contendrá un disco virtual restauro en el por medio de partimage la imagen del sistema creada en el punto 3.
8. Se necesitara también restaurar el masterboot récord de la imagen a la maquina virtual.
9. Reiniciamos nuestra maquina virtual y tendremos nuestro sistema clonado y listo para sincronizarlo o ponerlo en producción directamente.

Espero les sea útil este Post y dejen sus comentarios de las experiencias que tengan.

Uno de mis compañeros intentó detectar los sectores erróneos con System Rescue, y reportó que estaba todo bien.

Buscando encontré un foro en ubuntu-es que planteaba el mismo problema (http://www.ubuntu-es.org/?q=node/120405).

Resultó ser un bug, pueden verlo reportado en https://bugs.launchpad.net/ubuntu/+source/libatasmart/+bug/438136.

Afortunadamente, no tuve que cambiar el disco.

Para evitarme el trabajo de hacerlo manualmente me puse a buscar una herramienta para automatizar la tarea, ya que tenía que pasar a PDF el padrón la provincia de Corrientes con electores agrupados y separados por sexo, municipios y circuitos en casi 300 archivos de texto. Haciendo un poco de investigación me topé con Text2PDF una sencilla aplicación que permite la exportación de archivos de texto plano a PDF, esta herramienta tiene una desventaja ya que no tiene un paquete precompilado para Linux, así que tenemos que bajar el código fuente desde acá y compilarlo.

Para realizar la compilación necesitamos tener instalados los paquetes de desarrollo, en Ubuntu podemos hacerlo mediante aptitude

sudo aptitude install build-essentials

luego creamos una carpeta y bajamos el código fuente de la aplicación

mkdir text2pdf
cd text2pdf
wget http://www.eprg.org/pdfcorner/text2pdf/text2pdf.c
gcc text2pdf.c -o text2pdf

para mayor comodidad podemos agregar la ruta al ejecutable dentro en el PATH, ahora podemos hacer una pequeña prueba al estilo UNIX

text2pdf -h | text2pdf > help.pdf

Listo, resta hacer un script que recorra todos los archivos de texto dentro del directorio y que los pase a PDF, sencillo no?.

Vamos a ver dos maneras, una mediante uno de mis lenguajes favoritos: ruby y la otra mediante BASH por si no quieren instalar ruby.

Primero vamos con Ruby, en un archivo llamado text2pdfmasivo.rb escribimos lo siguiente:

Dir.glob("*.txt").each { |file| system "text2pdf "#{file} > #{file}.pdf" }

con Dir.glob(”*.txt”) filtramos y obtenemos un array con todos los archivos txt y luego lo recorremos, con el comando system hacemos podemos ejecutar programas externos y para poder ejecutarlo usamos el intérprete de ruby

ruby text2pdfmasivo.rb

Ahora vamos a hacerlo con BASH, en un archivo llamado text2pdfmasivo.sh agregamos

for i in "ls -a -A *.txt $1"
do
text2pdf $i > "$i.pdf"
done;

La lógica es exactamente la misma que en el ejemplo anterior, le damos los permisos de ejecución necesarios y listo ya lo podemos correr.

Nota: no soy experto en BASH por lo que cualquier comentario para mejorar el script es bienvenido .

Una desventaja importante de Text2PDF es que arroja errores de segmentación para archivos grandes de aproximadamente 500 páginas o más, pero exportar ese tipo de volumen suele ser muy raro .

$ lspci

Luego nos aparece un listado del siguiente tipo:

00:00.0 Host bridge: Intel Corporation Mobile PM965/GM965/GL960 Memory Controller Hub (rev 0c)
00:02.0 VGA compatible controller: Intel Corporation Mobile GM965/GL960 Integrated Graphics Controller (rev 0c)
00:02.1 Display controller: Intel Corporation Mobile GM965/GL960 Integrated Graphics Controller (rev 0c)
00:1a.0 USB Controller: Intel Corporation 82801H (ICH8 Family) USB UHCI Controller #4 (rev 02)
00:1a.1 USB Controller: Intel Corporation 82801H (ICH8 Family) USB UHCI Controller #5 (rev 02)
00:1a.7 USB Controller: Intel Corporation 82801H (ICH8 Family) USB2 EHCI Controller #2 (rev 02)
00:1b.0 Audio device: Intel Corporation 82801H (ICH8 Family) HD Audio Controller (rev 02)
00:1c.0 PCI bridge: Intel Corporation 82801H (ICH8 Family) PCI Express Port 1 (rev 02)
00:1c.1 PCI bridge: Intel Corporation 82801H (ICH8 Family) PCI Express Port 2 (rev 02)
00:1c.4 PCI bridge: Intel Corporation 82801H (ICH8 Family) PCI Express Port 5 (rev 02)
00:1d.0 USB Controller: Intel Corporation 82801H (ICH8 Family) USB UHCI Controller #1 (rev 02)
00:1d.1 USB Controller: Intel Corporation 82801H (ICH8 Family) USB UHCI Controller #2 (rev 02)
00:1d.2 USB Controller: Intel Corporation 82801H (ICH8 Family) USB UHCI Controller #3 (rev 02)
00:1d.7 USB Controller: Intel Corporation 82801H (ICH8 Family) USB2 EHCI Controller #1 (rev 02)
00:1e.0 PCI bridge: Intel Corporation 82801 Mobile PCI Bridge (rev f2)
00:1f.0 ISA bridge: Intel Corporation 82801HEM (ICH8M) LPC Interface Controller (rev 02)
00:1f.1 IDE interface: Intel Corporation 82801HBM/HEM (ICH8M/ICH8M-E) IDE Controller (rev 02)
00:1f.2 SATA controller: Intel Corporation 82801HBM/HEM (ICH8M/ICH8M-E) SATA AHCI Controller (rev 02)
00:1f.3 SMBus: Intel Corporation 82801H (ICH8 Family) SMBus Controller (rev 02)
02:09.0 FireWire (IEEE 1394): Ricoh Co Ltd R5C832 IEEE 1394 Controller (rev 05)
02:09.1 SD Host controller: Ricoh Co Ltd R5C822 SD/SDIO/MMC/MS/MSPro Host Adapter (rev 22)
02:09.2 System peripheral: Ricoh Co Ltd R5C843 MMC Host Controller (rev 12)
02:09.3 System peripheral: Ricoh Co Ltd R5C592 Memory Stick Bus Host Adapter (rev 12)
02:09.4 System peripheral: Ricoh Co Ltd xD-Picture Card Controller (rev ff)
09:00.0 Ethernet controller: Marvell Technology Group Ltd. 88E8040 PCI-E Fast Ethernet Controller (rev 12)
0b:00.0 Network controller: Intel Corporation PRO/Wireless 3945ABG [Golan] Network Connection (rev 02)


Luego nos fijamos en la linea que dice VGA compatible controller, resaltada en rojo en el listado de arriba y prestamos atención a la cadena del dispositivo (00:02:0), luego simplemente ejecutamos:


$ lspci -v -s 00:02.0


lo que nos da el siguiente resultado:


00:02.0 VGA compatible controller: Intel Corporation Mobile GM965/GL960 Integrated Graphics Controller (rev 0c)
Subsystem: Dell Device 022f
Flags: bus master, fast devsel, latency 0, IRQ 2297
Memory at fea00000 (64-bit, non-prefetchable) [size=1M]
Memory at e0000000 (64-bit, prefetchable) [size=256M]
I/O ports at eff8 [size=8]
Capabilities:
Kernel modules: intelfb


Para más información sobre este comando, simplemente vean el manual, tiene muchas funciones interesantes


$ man lspci


Gracias a nixCraft (http://www.cyberciti.biz/faq/howto-find-linux-vga-video-card-ram/)

Como se puede ver el Router RB433uah es una poderosísima placa con procesador Mips de 680Mhz con overlock hasta 800Mhz, 128Mb de RAM y almacenamiento NAND Flash de 512 Mb. Con un plus de 2 puertos USB lo cual expande enormemente sus posbilidades de uso. Además equipada claro de 3 slots minipci y 3 ethernets.

Para este momento en particular se usa el development branch de openwrt:

 svn co svn://svn.openwrt.org/openwrt/packages/

actualmente con kernel 2.6.30

Como primera medida habrá que agregar el modelo a la lista de placas soportadas, lo cual nos permitirá bootear de la misma via tftpboot y reconocer el almacenamiento NAND Flash de 512Mb donde alojar permanentemente la instalación.

Primero parchar los archivos mach-rb-4xx.c, prom.c y ar71xx.h:

Index: target/linux/ar71xx/files/arch/mips/include/asm/mach-ar71xx/ar71xx.h
===================================================================
--- target/linux/ar71xx/files/arch/mips/include/asm/mach-ar71xx/ar71xx.h (revision 16741)
+++ target/linux/ar71xx/files/arch/mips/include/asm/mach-ar71xx/ar71xx.h (working copy)
@@ -124,7 +124,9 @@
AR71XX_MACH_AW_NR580, /* AzureWave AW-NR580 */
AR71XX_MACH_RB_411, /* MikroTik RouterBOARD 411/411A/411AH */
AR71XX_MACH_RB_433, /* MikroTik RouterBOARD 433/433AH */
+ AR71XX_MACH_RB_433U, /* MikroTik RouterBOARD 433/433UAH */
AR71XX_MACH_RB_450, /* MikroTik RouterBOARD 450 */
+ AR71XX_MACH_RB_450G, /* MikroTik RouterBOARD 450G */
AR71XX_MACH_RB_493, /* Mikrotik RouterBOARD 493/493AH */
AR71XX_MACH_PB42, /* Atheros PB42 */
AR71XX_MACH_PB44, /* Atheros PB44 */
Index: target/linux/ar71xx/files/arch/mips/ar71xx/prom.c
===================================================================
--- target/linux/ar71xx/files/arch/mips/ar71xx/prom.c (revision 16741)
+++ target/linux/ar71xx/files/arch/mips/ar71xx/prom.c (working copy)
@@ -39,10 +39,16 @@
.name = "433",
.mach_type = AR71XX_MACH_RB_433,
}, {
- .name = "450",
+ .name = "433U",
+ .mach_type = AR71XX_MACH_RB_433U,
+ }, {
+ .name = "450",
.mach_type = AR71XX_MACH_RB_450,
}, {
- .name = "493",
+ .+ .mach_type = AR71XX_MACH_RB_450G,
+ }, {
+ .name = "493",
.mach_type = AR71XX_MACH_RB_493,
}, {
.name = "AP81",
Index: target/linux/ar71xx/files/arch/mips/ar71xx/mach-rb-4xx.c
===================================================================
--- target/linux/ar71xx/files/arch/mips/ar71xx/mach-rb-4xx.c (revision 16741)
+++ target/linux/ar71xx/files/arch/mips/ar71xx/mach-rb-4xx.c (working copy)
@@ -72,7 +72,7 @@
}
};

-#if 0
+#if 0
/*
* SPI device support is experimental
*/
@@ -84,7 +84,8 @@
{
.bus_num = 0,
.chip_select = 0,
- .max_speed_hz = 25000000,
+ .max_speed_hz = 33000000,
+ .mode = SPI_MODE_0,
.modalias = "m25p80",
.platform_data = &rb4xx_flash_data,
}
@@ -98,13 +99,15 @@
{
.bus_num = 0,
= "450G",
.chip_select = 0,
- .max_speed_hz = 25000000,
+ .max_speed_hz = 33000000,
+ .mode = SPI_MODE_0,
.modalias = "m25p80",
- .platform_data = &rb433_flash_data,
+ .platform_data = &rb4xx_flash_data,
}, {
.bus_num = 0,
.chip_select = 2,
- .max_speed_hz = 25000000,
+ .max_speed_hz = 10000000,
+ .mode = SPI_MODE_0,
.modalias = "mmc_spi",
.platform_data = &rb433_mmc_data,
}
@@ -113,7 +116,6 @@
static u32 rb433_spi_get_ioc_base(u8 chip_select, int cs_high, int is_on)
{
u32 ret;
-
if (is_on == AR71XX_SPI_CS_INACTIVE) {
ret = SPI_IOC_CS0 | SPI_IOC_CS1;
} else {
@@ -205,7 +207,31 @@
}

MIPS_MACHINE(AR71XX_MACH_RB_433, "MikroTik RouterBOARD 433/AH", rb433_setup);
+static void __init rb433u_setup(void)
+{
+ rb4xx_generic_setup();
+ rb433_add_device_spi();

+ ar71xx_add_device_mdio(0xffffffe9);
+
+ ar71xx_eth0_data.phy_if_mode = PHY_INTERFACE_MODE_MII;
+ ar71xx_eth0_data.phy_mask = 0x00000006;
+ ar71xx_eth0_data.speed = SPEED_100;
+ ar71xx_eth0_data.duplex = DUPLEX_FULL;
+
+ ar71xx_eth1_data.phy_if_mode = PHY_INTERFACE_MODE_RMII;
+ ar71xx_eth1_data.phy_mask = 0x00000010;
+
+ ar71xx_add_device_eth(1);
+ ar71xx_add_device_eth(0);
+
+ ar71xx_add_device_usb();
+
+ ar71xx_pci_init(ARRAY_SIZE(rb4xx_pci_irqs), rb4xx_pci_irqs);
+}
+
+MIPS_MACHINE(AR71XX_MACH_RB_433U, "MikroTik RouterBOARD 433UAH", rb433u_setup);
+
static void __init rb450_setup(void)
{
rb4xx_generic_setup();
@@ -226,7 +252,27 @@
}

MIPS_MACHINE(AR71XX_MACH_RB_450, "MikroTik RouterBOARD 450", rb450_setup);
+static void __init rb450g_setup(void)
+{
+ rb4xx_generic_setup();
+ rb4xx_add_device_spi();

+ ar71xx_add_device_mdio(0xffffffe0);
+
+ ar71xx_eth0_data.phy_if_mode = PHY_INTERFACE_MODE_MII;
+ ar71xx_eth0_data.phy_mask = 0x0000000f;
+ ar71xx_eth0_data.speed = SPEED_1000;
+ ar71xx_eth0_data.duplex = DUPLEX_FULL;
+
+ ar71xx_eth1_data.phy_if_mode = PHY_INTERFACE_MODE_RMII;
+ ar71xx_eth1_data.phy_mask = 0x00000010;
+
+ ar71xx_add_device_eth(1);
+ ar71xx_add_device_eth(0);
+}
+
+MIPS_MACHINE(AR71XX_MACH_RB_450G, "MikroTik RouterBOARD 450G", rb450g_setup);
+
static void __init rb493_setup(void)
{
rb4xx_generic_setup();

Una vez aplicado arrancamos via tftpboot, previamente formateamos la memoria flash NAND desde la Bios:

comprobamos si la memoria fue detectada correctamente:

$ cat /proc/mtd
dev: size erasesize name
mtd0: 00040000 00040000 "booter"
mtd1: 003c0000 00040000 "kernel"
mtd2: 1fc00000 00040000 "rootfs"

mtd0 partición booter no nos interesa, mtd1 partición donde se guarda el kernel y finalmente partición mtd2 para filesystem raiz.

montamos la partición para el kernel:

root@OpenWrt:/# mount /dev/mtdblock1 /mnt/
yaffs: dev is 32505857 name is "mtdblock1"
yaffs: passed flags ""
yaffs: Attempting MTD mount on 31.1, "mtdblock1"
yaffs: auto selecting yaffs2
yaffs_read_super: isCheckpointed 0

root@OpenWrt:/# ls /mnt/
lost+found

root@OpenWrt:/# df -h
Filesystem Size Used Available Use% Mounted on
tmpfs 62.1M 52.0K 62.1M 0% /tmp
tmpfs 512.0K 0 512.0K 0% /dev
/dev/mtdblock1 3.8M 2.3M 1.5M 60% /mnt

root@OpenWrt:/# find /mnt/
/mnt/
/mnt/lost+found

Aparentemente por un problema con el driver del soporte mtd la partición de 4mb aparece con 60% de espacio ocupado a pesar de estar literalmente vacía.
Nuestra imagen elf del kernel generalmente tendrá 2,5 Mb o más y no habrá manera de copiarla aquí.

la partición raiz se ve similar:

root@OpenWrt:/# df -h
Filesystem Size Used Available Use% Mounted on
tmpfs 62.1M 40.0K 62.1M 0% /tmp
tmpfs 512.0K 0 512.0K 0% /dev
/dev/mtdblock1 3.8M 2.3M 1.5M 60% /mnt
/dev/mtdblock2 508.0M 2.3M 505.8M 0% /tmp/rootfs

Se necesitará extender mientras tanto la partición kernel de tal forma que sea posible ubicar nuestra imagen elf creada para tal fin.
En la mayoría de los sistemas embebidos (http://www.ssiembedded.com/embedded_linux_managing_memory.html), los dispositivos flash se usan directamente sin tabla de particiones, como otras memorias tales como las CF, que emulan discos duros. El driver de mapeo MTD provee funciones para leer/escribir en la memoria flash y aquí es donde se especifica una estructura de partición harcodeada. Vemos a continuación una porción del archivo rb4xx_nand.c que nos interesa:

Archivo trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb4xx_nand.c:

static struct mtd_partition rb4xx_nand_partitions[] = {
{
.name   = "booter",
.offset = 0,
.size   = (256 * 1024),
.mask_flags = MTD_WRITEABLE,
},
{
.name   = "kernel",
.offset = (256 * 1024),
.size   = (4 * 1024 * 1024) - (256 * 1024),
},
{
.name   = "rootfs",
.offset = MTDPART_OFS_NXTBLK,
.size   = MTDPART_SIZ_FULL,
},
};

incrementamos el tamaño de la partición kernel a 8mb con el siguiente parche:

Index: trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb4xx_nand.c
===================================================================
--- trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb4xx_nand.c (revision 16778)
+++ trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb4xx_nand.c (working copy)
@@ -92,7 +92,7 @@
{
.name = "kernel",
.offset = (256 * 1024),
- .size = (4 * 1024 * 1024) - (256 * 1024),
+ .size = (8 * 1024 * 1024) - (256 * 1024),
},
{
.name = "rootfs",

Recompilamos y booteamos Openwrt. Ahora la tabla de particiones se ve un poco diferente:

root@OpenWrt:~# cat /proc/mtd
dev: size erasesize name
mtd0: 00040000 00040000 "booter"
mtd1: 007c0000 00040000 "kernel"
mtd2: 1f800000 00040000 "rootfs"

root@OpenWrt:/# df -h
Filesystem                Size      Used Available Use% Mounted on
tmpfs                    62.1M     40.0K     62.0M   0% /tmp
tmpfs                   512.0K         0    512.0K   0% /dev
/dev/mtdblock1            7.8M      2.3M      5.5M  29% /mnt

Con espacio suficiente para ubicar la imagen elf del kernel openwrt.

Siguiente paso montamos las particiones:

root@OpenWrt:/# mkdir /tmp/kernel
root@OpenWrt:/# mkdir /tmp/rootfs
root@OpenWrt:/# mount /dev/mtdblock1 /tmp/kernel/
root@OpenWrt:/# mount /dev/mtdblock2 /tmp/rootfs

debería verse asi:

root@OpenWrt:/# df -h
Filesystem                Size      Used Available Use% Mounted on
tmpfs                    62.1M     40.0K     62.0M   0% /tmp
tmpfs                   512.0K         0    512.0K   0% /dev
/dev/mtdblock1            7.8M      2.3M      5.5M  29% /tmp/kernel
/dev/mtdblock2          504.0M      2.3M    501.8M   0% /tmp/rootfs

Finalmente compiamos la imagen openwrt-ar71xx-vmlinux.elf del kernel con el nombre “kernel” y desempaquetamos openwrt-ar71xx-rootfs.tgz en rootfs por ej con:

root@OpenWrt:/# tar -xzvf openwrt-ar71xx-rootfs.tgz -C /tmp/rootfs
root@OpenWrt:/# umount /tmp/kernel
root@OpenWrt:/# umount /tmp/rootfs
root@OpenWrt:/# reboot

Tenemos Openwrt completamente funcional.

Los números entonces eran los siguientes:

- 8.859.683 líneas de código, con un 10% de crecimiento por año 3621 líneas se añaden por día, provocando esto que se anuncie un nuevo release cada 2.7 meses.

- Cada día aproximadamente 1000 desarrolladores de más de 100 corporaciones trabajan en el desarrollo, de estos el 70 por ciento trabajan en empresas reconocidas tales como:IBM, Intel, The Linux Foundation, MIPS Technology, MontaVista, Movial, NetApp, Novell y Red Hat.

Lamentablemente este informe ya está obsoleto, y es por esto que la Fundación Linux publicó un informe en el día de ayer, 19 de agosto del 2009, con nuevos datos en base al kernel 2.6.30, los números son:

- Aproximadamente 1000 desarrolladores de 200 compañías diferentes trabajan en el núcleo, lo que representa un incremento del 10% respecto del 2008. El 70% de las contribuciones viene de desarrolladores Red Hat, IBM, Novell, Intel, Oracle, Fujitsu y otras muchas empresas de menor talla.

- El principal contribuyente individual es David Miller, y la nota particular es que Linus Torvalds ya no se encuentra dentro de los mayores aportantes, pero esto no tiene que sorprender dado el rol administrativo que lleva.

Nunca antes en la historia de la computación ha habido tantas empresas, usuarios y desarrolladores unidos detrás de un mismo proyecto.

El texto completo de ambos informes se encuentra disponible en los siguientes links:

Informe Linux Foundation Marzo 2008

Informe Linux Foundation Agosto 2009

Correcciones: @mariana_cecilia

sudo apt-get install sshfs

Ahora podemos montar cualquier disco remoto utilizando el siguiente comando:

sshfs nombreusuario@servidor:/ruta/del/directorio /directorio/destino

Un aclaración importante es que si montamos una partición a través de Internet, tenemos que tener en cuenta el proceso extra que requiere el encriptamiento de la comunicación, SSHFS puede ser LENTO si tenemos que trabajar con muchos archivos.

Aca van los ejemplos:

curl --basic --user username:password --data status="Twitter desde mi consola " http://twitter.com/statuses/update.xml

Explicacion de los parametros

1. --basic --user username:password . Usuario y password que usas para twitter

2. --data status="Twitter desde mi consola:D" . Actualizacion de tu estado en twitter.
3. http://twitter.com/statuses/update.xml . Ah no olvidar esto, URL de la API.


Otra opcion puede ser  con Wget  (http://www.gnu.org/software/wget.

Ejemplo

wget --keep-session-cookies --http-user=miusuario --http-password=mipassword --post-data="status=Actualizo con Wget:D" http://twitter.com:80/statuses/update.xml