Vuelta a Casa

Bueno, como no puede ser de otra manera, voy a migrar (otra vez) este blog a mi sitio personal, a mi cueva, a mi guarida,Punto-K.com.ar, asi que los invito a darse una vuelta, este sitio queda destinado a campo de tiro, area de pruebas y/o zona de guerra.

Pequeño Browser Ilustrado

A pedido de las masas, aqui les dejo el codigo de un browser realmente minimalista, 88 lineas de C, 20k una vez compilado (linkado dinamico). Luego de compilar, lo ejecutan de la siguiente manera:

./browser http://www.url.com

Aqui les dejo el codigo, tengo problemas con el wordpress, la identacion se perdio en algun lado

——————————————————————————————————————————–

#include <gtk/gtk.h>
#include <webkit/webkit.h>

/*gcc -Wall -L /usr/lib -I /usr/include/webkit-1.0/ -g main.c -o main `pkg-config –cflags gtk+-2.0` `pkg-config –libs gtk+-2.0 webkit-1.0`*/

static GtkWidget* main_window;
static WebKitWebView* web_view;
static gchar* main_title;
static gint load_progress;

static void
update_title (GtkWindow* window)
{
GString* string = g_string_new (main_title);
g_string_append (string, ” – WebKit Launcher”);
if (load_progress < 100)
g_string_append_printf (string, ” (%d%%)”, load_progress);
gchar* title = g_string_free (string, FALSE);
gtk_window_set_title (window, title);
g_free (title);
}

static void
title_change_cb (WebKitWebView* web_view, WebKitWebFrame* web_frame, const gchar* title, gpointer data)
{
if (main_title)
g_free (main_title);
main_title = g_strdup (title);
update_title (GTK_WINDOW (main_window));
}

static void
progress_change_cb (WebKitWebView* page, gint progress, gpointer data)
{
load_progress = progress;
update_title (GTK_WINDOW (main_window));
}

static void
destroy_cb (GtkWidget* widget, gpointer data)
{
gtk_main_quit ();
}

static GtkWidget*
create_browser ()
{
GtkWidget* scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

web_view = WEBKIT_WEB_VIEW (webkit_web_view_new ());
gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (web_view));

g_signal_connect (G_OBJECT (web_view), “title-changed”, G_CALLBACK (title_change_cb), web_view);
g_signal_connect (G_OBJECT (web_view), “load-progress-changed”, G_CALLBACK (progress_change_cb), web_view);

return scrolled_window;
}

static GtkWidget*
create_window ()
{
GtkWidget* window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
gtk_widget_set_name (window, “GtkLauncher”);
g_signal_connect (G_OBJECT (window), “destroy”, G_CALLBACK (destroy_cb), NULL);

return window;
}

int
main (int argc, char* argv[])
{
gtk_init (&argc, &argv);

main_window = create_window ();
gtk_container_add (GTK_CONTAINER (main_window), create_browser ());

gchar* uri = (gchar*) (argc > 1 ? argv[1] : “http://localhost/sinapsis/main/”);
webkit_web_view_open (web_view, uri);

gtk_widget_grab_focus (GTK_WIDGET (web_view));
gtk_widget_show_all (main_window);
gtk_main ();

return 0;
}

Primero, fue el browser.

Realmente no se que vino primero, pero estoy casi convencido de que me pase a Rails, porque queria hacer un browser con Gtk/Webkit como marco de la applicacion rails.

static GtkWidget*
create_browser ()
{
    /* Basic browser view */

    GtkWidget* scrolled_window = gtk_scrolled_window_new (NULL, NULL);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
                                                    GTK_POLICY_AUTOMATIC,
                                                    GTK_POLICY_AUTOMATIC);

    web_view = WEBKIT_WEB_VIEW (webkit_web_view_new ());
    gtk_container_add (GTK_CONTAINER (scrolled_window),
                                GTK_WIDGET (web_view));

    g_signal_connect (G_OBJECT (web_view), "title-changed",
                               G_CALLBACK (title_change_cb), web_view);
    g_signal_connect (G_OBJECT (web_view), "load-progress-changed",
                               G_CALLBACK (progress_change_cb), web_view);
    g_signal_connect (G_OBJECT (web_view), "load-committed",
                               G_CALLBACK (load_commit_cb), web_view);
    g_signal_connect (G_OBJECT (web_view), "hovering-over-link",
                               G_CALLBACK (link_hover_cb), web_view);

    return scrolled_window;
}

Y entonces, fue Rails.

Instalando Cherokee 0.8.1

El paquete que esta disponible en los repositorios es el 0.5.6, (uso Linux Mint, quien usa los repositorios de ubuntu), eso no es aceptable para mi. Para instalar la ultima versiond de cherokee, seguir los siguientes pasos:

• Descargar la version 0.8.1.
• Es un tar.gz, asi que tienen que extraer el paquete en algun lado.
• configurar, compilar e instalar
  • ./configure –localstatedir=/var –prefix=/usr –sysconfdir=/etc –with-wwwroot=/var/www
  • make
  • make install (como root)
• Copiar el archivo contrib/cherokee al directorio /etc/init.d/
• Editar el archivo /etc/init.d/cherokee, copiado en el paso anterior, y corregir los paths de la aplicacion. (cambiar /usr/local/sbin por /usr/sbin, /usr/local/lib por /usr/lib), pueden chequear esto haciendo un whereis cherokee y verificar que los paths esten bien.
• Arrancan cherokee (/etc/init.d/cherokee start)
• Apuntan su navegador favorito a localhost, y listo, tienen que ver la pagina de test de cherokee

Guia oficial de instalacion en Unix

La Creatividad: el origen del desarrollo de software.

No hay una simple y reconocida perspectiva o definicion de creatividad. Al menos 60 definiciones diferentes de creatividad se pueden encontrar en la literatura psicologica. Sin embargo, una aceptada concepcion de Creatividad es que se manifiesta en la produccion de cosas que son originales y utiles.

Original
La idea básica de escribir software es crear codigo que aun no ha sido producido. Tecnicas como orientacion a objetos, diseño basado en componentes, arquitectura basada en servicios, y refactorizacion existen para ayudarte a que cada linea de codigo sea unica. Los desarrolladores de software piensan que, en un mundo perfecto, cada pieza de codigo existe solamente una vez, y en la busqueda de esta utopia, intentando prevenir cualquier repeticion de trabajo, los desarrolladores cuentan con muchas mas posibilidades que los escritores, pintores, arquitectos y peluqueros. Ninguna de estas personas creativas poseen un conjunto de tecnicas para la abstraccion y referenciacion.

Utilidad
De la misma manera, producir cosas utiles es otra de las ideas basicas de escribir software. Posiblemente, ningun otro tipo de creatividad ha incrementado los niveles globales de productividad como lo ha hecho el software. El valor de los negocios de software supera casi cualquier otro producto creativo, por varios ordenes de magnitud. Los desarrolladores no pueden ser comparados con escritores, pintores, arquitectos o incluso peluqueros en esa materia. A menudo, los programadores siquiera se ven a si mismos como “creativos”, con todas las connotaciones que vienen con ese termino. La mayoria de los programadores no son del tipo que escribe poemas o bailan balet. Solo quieren ser practicos, y hacer cosas que sean utilizadas.

Asi que parece que el termino original y util toca el corazon del desarrollo de software. Incluso cuando la inteligencia, disciplina y rutina juegan papeles importantes en muchos proyectos de software, no hay nada que hacer cuando no hay creatividad.

Nota: No tienes que estar de acuerdo en que los productos creativos son utiles, pero eso no cambia el hecho de que el desarrollo de software sea una actividad creativa, una que es justamente, Util.

La especialización es para los insectos.

Tomado del blog de Linking Paths.

A human being should be able to change a diaper, plan an invasion, butcher a hog, conn a ship, design a building, write a sonnet, balance accounts, build a wall, set a bone, comfort the dying, take orders, give orders, cooperate, act alone, solve equations, analyze a new problem, pitch manure, program a computer, cook a tasty meal, fight efficiently, die gallantly. Specialization is for insects.

Traducción libre:

Un ser humano debería ser capaz de cambiar un pañal, planear una invasión, descuartizar un cerdo, dirigir un barco, diseñar un edificio, escribir un soneto, cuadrar cuentas, construir un muro, encajar un hueso, reconfortar al moribundo, recibir ordenes, dar ordenes, cooperar, actuar solo, resolver ecuaciones, analizar un nuevo problema, preparar abono, programar un ordenador, cocinar una rica cena, pelear eficientemente, morir elegantemente. La especialización es para los insectos.

Player shot 2

Contribuyendo: Mi primer patch para Gtk+

Finalmente, llego el momento de que me ponga las pilas y aportara algo al open source que tantas gratificaciones me dió. El pasado fin de semana vivi una de las experiencias mas edificantes que puede vivir un programador, participar en un proyecto open source con una comunidad de excelentes desarrolladores, de mas esta decir que aprendi mucho y me diverti aun mas. Esto es adictivo pero benigno, y en adelante espero poder seguir contribuyendo.

Si bien desde hace tiempo tenia las intenciones de empezar, el disparador fue la oleada de posts sobre la “decadencia de gnome”, siendo un usuario vitalicio de gnome, no podia dejar que esto pasara y no me queria quedar con los brazos cruzados. Asi que en lugar de opinar, decidi contribuir.

Quiero agradecer a Diego y a Christian Dywan de Inmendio por la buena onda y las prontas respuestas, gracias a todos por sus comentarios y sugerencias.

El bug en cuestion es un small fix para el dialogo de seleccion de archivos (gtkfilechosser). He aqui el pequeño patch:

Index: gtkfilechooser.c
===================================================================
--- gtkfilechooser.c    (revision 21136)
+++ gtkfilechooser.c    (working copy)
@@ -1021,6 +1021,10 @@
g_return_val_if_fail (GTK_IS_FILE_CHOOSER (chooser), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+  if (g_file_is_native (file))
+  {
+    g_return_val_if_fail (g_file_test (g_file_get_uri (file), G_FILE_TEST_IS_DIR), FALSE);
+  }

return GTK_FILE_CHOOSER_GET_IFACE (chooser)->set_current_folder (chooser, file, error);
}

Como premio, obtuve mi primer punto en Bugzilla!

gtk+/gstreamer player

Hey! Hace unas semanas escribi este reproductor de canciones en C con gtk+ y gstreamer. Aun debo corregir muchas cosillas y agregar features basicos. Pero les queria dejar una imagen de lo que hay ahora, y como el trabajo me esta absorviendo, no queria esperar hasta el release oficial para mostrarselas. He aqui, mi player en estado larval.

Tiny Encryption

Tiny Encryption Algorithm (TEA) es un cifrado de bloques notable por su simplicidad de descripcion e implementacion, tipicamente unas pocas lineas de codigo. Fue diseñado por David Wheeler y Roger Needham en el Laboratorio de Computacion de Cambridge, y presentado por primera vez en el taller Fast Software Encryption en 1994. Este cifrado no esta sujeto a patentes.

TEA opera con bloques de 64 bits y usa una clave de 128 bits. Tiene una estructura Feistel con 64 rondas (sugeridas), tipicamente implementada en pares llamados ciclos. Tiene un extremadamente sencillo procesamiento de la clave, mezclando todo el material clave en exactamente la misma forma en todos los ciclos. Diferentes multiplos de una constante magica son utilizados para prevenir ataques simples basados en la simetria de los rondas.

TEA tiene una debilidad. Notablemente, sufre de claves equivalentes, cada clave es equivalente a otras tres (3), lo que significa que el tamaño efectivo de la clave es solamente 126 bits. Como resultado, TEA es especialmente malo como funcion de hash cryptografico. Esta debilidad fue lo que permitio un hack a la consola de juegos de Microsoft, la Xbox, donde el cifrado TEA fue utilizado como funcion hash. TEA es tambien susceptible al ataque de clave-relacionada (related-key) que requiere 223 textos planos seleccionados bajo un par de related-key.

El considerablemente pequeño tamaño del algoritmo TEA lo convierte en una opcion viable en situaciones donde existen condiciones extremas, como por ejemplo sistemas hardware (embebidos quizas) donde la cantidad de RAM disponible es minima.

El codigo para encriptar y desencriptar en lenguaje C, lo pueden obtener de wikipedia. Se los dejo aqui:

void encrypt (unsigned long* v, unsigned long* k) {
    unsigned long v0=v[0], v1=v[1], sum=0, i;           /* set up */
    unsigned long delta=0x9e3779b9;                     /* a key schedule constant */
    unsigned long k0=k[0], k1=k[1], k2=k[2], k3=k[3];   /* cache key */
    for (i=0; i < 32; i++) {                            /* basic cycle start */
        sum += delta;
        v0 += ((v1<>5) + k1);
        v1 += ((v0<>5) + k3);  /* end cycle */
    }
    v[0]=v0; v[1]=v1;
}

void decrypt (unsigned long* v, unsigned long* k) {
    unsigned long v0=v[0], v1=v[1], sum=0xC6EF3720, i;  /* set up */
    unsigned long delta=0x9e3779b9;                     /* a key schedule constant */
    unsigned long k0=k[0], k1=k[1], k2=k[2], k3=k[3];   /* cache key */
    for (i=0; i<32; i++) {                              /* basic cycle start */
        v1 -= ((v0<>5) + k3);
        v0 -= ((v1<>5) + k1);
        sum -= delta;                                   /* end cycle */
    }
    v[0]=v0; v[1]=v1;
}

Con estas dos funciones en mano, y recordando un poco de C, construi este simple y limitado programa que cifra o descrifa el archivo que le pasamos como parametro en la ejecucion. La clave esta hard-coded en el codigo del programa, esa es una muy grave limitacion que les dejo como tarea resolver/agregar.

#include
#include
#include 

int
main(int argc, char **argv) {
    unsigned long v[2];
    unsigned long k[4];

    /*
     * Esta es la clave,
     * necesito cambiar esto
     */
    k[0] = 1979;
    k[1] = 1980;
    k[2] = 1981;
    k[3] = 1982;	

    if(argc != 3) {
        fprintf(stderr, "tinyEnc [e|d] 'file'\n");
        exit(EXIT_FAILURE);
    }

    if((strcmp(argv[1], "e") != 0) && (strcmp(argv[1], "d") != 0))
    {
	fprintf(stderr, "Opcion no valida: %s\n", argv[1]);
	exit(EXIT_FAILURE);
    }

    FILE *fp = fopen(argv[2], "r");
    if(!fp) {
        perror("fopen");
        exit(EXIT_FAILURE);
    }

    FILE *tinyfp = fopen("output.tiny", "w");
    if(!tinyfp) {
	perror("fopen");
	exit(EXIT_FAILURE);
    }

    printf("Input File: %s\n", argv[2]);
    printf("Output File: output.tiny\n");

    while (fread(&v, sizeof(unsigned long), 2, fp)){
	if ((strcmp(argv[1], "e")) == 0){
	    encrypt(v, k);
	} else if ((strcmp(argv[1], "d")) == 0){
	    decrypt(v, k);
	}
    	fwrite(&v, sizeof(unsigned long), 2, tinyfp);
	v[0] = 0x0;
	v[1] = 0x0;
    }

    fclose(fp);
    fclose(tinyfp);
    exit(EXIT_SUCCESS);
}

Sugerencias y correcciones son bievenidas!