Limadito

Introducción

Estos programas fueron escritos para probar el concepto que no es necesaria una gran infraestructura ni una inversión millonaria en coders para lograr una red P2P. Cualquier programador medianamente avezado puede hacerlo, por lo que prohibir este tipo de aplicaciones (a instancias de los oligopolios controlantes de los medios, claro está) no tendría mayor impacto en la distribución de archivos por Internet.

Desde luego, los autores indican que no están a favor de la violación de los derechos de obras comerciales.

Todos los programas comparten ciertas características básicas: son sistemas experimentales, muy pocas líneas de código, no tienen interfases gráficas, pueden funcionar como servidores o clientes, es necesario saber cuál es la dirección IP del server y una contraseña para acceder a los archivos, y probablemente sólo funcionen bien en redes pequeñas, nada de TB de información compartida.

Si bien esta entrada está ingresada bajo GNU/Linux, desde luego es válida para todos los sistemas operativos que tengan disponibles las herramientas necesarias (léase: tambien funcionan en Windows). El código aparece un tanto desprolijo debido al b-quote del WordPress (por cierto, actualizé a 2.0.2)

Tinyp2p

El programita que originó todo. Escrito en Python, usa HTTP y XML-RPC para establecer las comunicaciones y transferencias.

(Nota mental: tengo que aprender Python. Tengo que aprender Python. Tengo que aprender Python)

# tinyp2p.py 1.0 (documentation at http://freedom-to-tinker.com/tinyp2p.html)
import sys, os, SimpleXMLRPCServer, xmlrpclib, re, hmac # (C) 2004, E.W. Felten
ar,pw,res = (sys.argv,lambda u:hmac.new(sys.argv[1],u).hexdigest(),re.search)
pxy,xs = (xmlrpclib.ServerProxy,SimpleXMLRPCServer.SimpleXMLRPCServer)
def ls(p=”"):return filter(lambda n:(p==”")or res(p,n),os.listdir(os.getcwd()))
if ar[2]!=”client”: # license: http://creativecommons.org/licenses/by-nc-sa/2.0
myU,prs,srv = (”http://”+ar[3]+”:”+ar[4], ar[5:],lambda x:x.serve_forever())
def pr(x=[]): return ([(y in prs) or prs.append(y) for y in x] or 1) and prs
def c(n): return ((lambda f: (f.read(), f.close()))(file(n)))[0]
f=lambda p,n,a:(p==pw(myU))and(((n==0)and pr(a))or((n==1)and [ls(a)])or c(a))
def aug(u): return ((u==myU) and pr()) or pr(pxy(u).f(pw(u),0,pr([myU])))
pr() and [aug(s) for s in aug(pr()[0])]
(lambda sv:sv.register_function(f,”f”) or srv(sv))(xs((ar[3],int(ar[4]))))
for url in pxy(ar[3]).f(pw(ar[3]),0,[]):
for fn in filter(lambda n:not n in ls(), (pxy(url).f(pw(url),1,ar[4]))[0]):
(lambda fi:fi.write(pxy(url).f(pw(url),2,fn)) or fi.close())(file(fn,”wc”))

Uso
server: python tinyp2p.py contraseña server nombre_host puerto [otraurl]

[otraurl]: opción para conectarse a una red existente; si no se especifica comienza una nueva red.

nombre_host puerto: se utilizan para generar la url donde escucha el servidor (http://nombre_host:puerto)

cliente: python tinyp2p.py contraseña client urlserver patrón_de_búsqueda

Molester

Apareció como respuesta/desafío (en términos amistosos, claro) al programa del Prof. Felten. Tan sólo ¡¡466 bytes!! de código Perl en estado puro. Tal y como está configurado, limita el tamaño de los archivos a 1 MB el (”1e6″ al centro de la tercera línea). No requiere de librerías adicionales como TinyP2P.

(Nota mental: tengo que aprender Perl. Tengo que aprender Perl. Tengo que aprender Perl)

$/=$_;$,=shift;$w=$a=shift;$k{+shift}=1;socket S,2,1,6;bind S,&a;for(listen
S,5;$SIG{ALRM}=\&i;m! (\S+) ([e-i])([^/]*)/!s&&($k{$w=$1}=$,eq$`)&&&$2){alarm
9;(accept(C,S),alarm 0)?read C,$_,1e6:($_=”$, $a f”.shift)}sub i{}sub t{socket
C,2,1,6;$k{$w}&&=(connect C,&a)?print C”$, “.pop:0;close C}sub h{t”$_ i/”for
keys%k}sub a{$w=~/:/;pack’CxnC4×8′,2,$’,split’\.’,$`}sub f{$w=$_,t”$1 $3/”for
keys%k}sub e{open C,’>',$3;print C $’}sub g{open(C,’< ',$3)&&t"$a e$3/".;&h}

Código legible, ¿no?

Uso:
perl molester contraseña ip_local:puerto ip_remoto:puerto

Se maneja el programa con alguno de los siguientes comandos (hay más):

i avisa de tu conexión al resto de los peers.

g solicita un archivo

h obtiene la lista de peers de otro peer y la funde con la propia

f envía un mensaje de texto al peer

Existen algunos derivados de este programa, escritos en Ruby y Guile Scheme. En la página de MoleSter pueden encontrar mas detalles.

uP2P

Escrito en Bash, requiere de netcat compilado con la opción “-e” (mmmmm… peligroso, según el equipode desarrollo). Se sale del programa matando netcat.

#!/bin/sh
# uP2P.sh 0.0.1, 436 characters (excluding comments)
[ $3 ]&&export W=$1 H=”$2 $3″ K=`mktemp`;Z=/dev/null;e(){ echo “$*”;};n(){
nc $* 2>$Z;};x(){ nc -lp ${H#* } -e $1 &>$Z < $Z&};f(){ cat $K|while read h;do
e $W $1 “$2″|n $h;done };case $# in 4)e $W s “$4″|n $H|while read h p f; do
e $W g “$f”|n $h $p>”$f”;done;;5)e $H>$K;e $W d $H|n $4 $5>>$K;x $0;;0)x $0
read w c r;[ $W = $w ]&&case $c in s)f l “$r”;;g)cat “$r”;;a)e $r>>$K;;d)cat $K
f a “$r”;;l)ls|grep “$r”|sed “s/^/$H /”;;esac;;esac

Uso:

Server uP2P.sh contraseña ip_local puerto_local ip_remota puerto_remoto

ip_local puerto_local -> ip y puerto el en que el server escucha pedidos de otros peers
ip_remota puerto_remoto -> ip y puerto de otro peer en la red

Cliente: uP2P.sh contraseña ip_remota puerto_remoto patrón_archivos_a_descargar

ip_remota puerto_remoto -> ip y puerto de otro peer en la red
patrón -> patrón de archivo/s a descargar (puede ser una expresión regular)

Palabras finales:
(Nota mental: tengo tanto que aprender… tengo tanto que aprender… tengo tanto que aprender…)

Quizá el mejor uso de estos programas sea para el intercambio de archivos en pequeñas comunidades o pequeñas organizaciones comerciales (cifrando los archivos con GPG, por ejemplo). Sería posible desarrollar interfases gráficas muy simples (basadas en xwWindows, dialog, xdialog, zenity) para facilitar el uso a los neófitos, aunque terminaria por desbaratar lo mejor de estos programas: su pequeño tamaño.

No comments