En ForosDelWeb he encontrado varias maneras de descargar paginas web utilizando PHP.

Definiciones

• file_get_contents()
• cURL
• HTTP_Request

Introducción

Hay varias maneras de mostrar un URL remoto en PHP. La elección de un método sobre otro depende de las necesidades de su simplicidad, control y portabilidad. Los tres métodos que vamos a describir son:

• Las funciones estandares de "filesystem"
• La extensión cURL
• La clase de PEAR HTTP_Request.

Estos tres métodos pueden generalmente hacer todo lo que necesita y por lo menos uno de ellos deben estar disponibles, sea cual sea su configuración del servidor o capacidad de instalar las extensiones personalizadas. Otras formas de recuperar las URL remotas incluye la extesión pecl_http (http://pecl.php.net/package/pecl_http), que, aunque todavía en desarrollo, ofrece algunas características prometedoras, y utilizando el fsockopen() para abrir un zócalo sobre el que envía una petición HTTP que lo construye pieza por pieza.

El uso de las funciones estandares de "filesystem" como la funciónfile_get_contents() es simple y conveniente. Sigue automaticamente las redirecciones, así que si utiliza esta función para recuperar el directoriohttp://www.example.com/persona/ y el servidor le redirecciona ahttp://www.example.com/people/, obtendrá el contenido de la página de índice de directorio, no un mensaje que le diga que la URL ha cambiado de dirección. El inconveniente de este método es que requiere la directiva de configuraciónallow_url_fopen a estar activado.

La extensión CURL es una poderosa herramienta. Se basa en el popular libcurl para proporcionar un rápido, configurable mecanismo para el manejo de una amplia variedad de peticiones de red. Si esta extensión está disponible en su servidor, le recomendamos que la utilice.

Si se desactiva allow_url_fopen y cURL no está disponible, el módulo PEARHTTP_Request salva el día. Al igual que todos los módulos de PEAR, es puro PHP, por lo que si puede guardar un archivo PHP en su servidor, puede utilizarlo.HTTP_Request soporta casi cualquier cosa que te gustaría hacer cuando se solicite una URL remota, incluyendo la modificación de cabeceras de petición y el cuerpo, utilizando un método arbitrario, respuesta y recuperación de los encabezados. Para mas informacion sobre como instalar los modulo de PEAR puedes ir ahttp://pear.php.net/manual/en/installation.getting.php

Para recibir información de URL seguras, solo escribe https en vez de http. Siempre y cuando en PHP haya sido construido en una libreria SSL, tal como OpenSSL. Todas las funciones que pueden recibir información de URL regulares pueden recibir información de URL seguras. Verifica la sección de OpenSSL en la salida de phpinfo() para ver si tu configuración de php tiene soporte de SSL.

Ejemplos

Obteniendo una URL

file_get_contents()

<?php
$page = file_get_contents('http://www.example.com/algo.txt');
echo $page;

cURL

<?php
$c = curl_init('http://www.example.com/algo.txt');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
$page = curl_exec($c);
curl_close($c);
echo $page;

HTTP_Request

<?php
require_once 'HTTP/Request.php';
$r = new HTTP_Request('http://www.example.com/algo.txt');
$r->sendRequest();
$page = $r->getResponseBody();
echo $page;

Mostrar una página protegida

file_get_contents()

<?php
$url = 'http://FDW:PASS@www.example.com/proyecto.php';
$page = file_get_contents($url);
echo $page;

cURL

<?php
$c = curl_init('http://www.example.com/proyecto.php');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
curl_setopt($c, CURLOPT_USERPWD, 'FDW:PASS');
$page = curl_exec($c);
curl_close($c);
echo $page;

HTTP_Request

<?php
$r = new HTTP_Request('http://www.example.com/proyecto.php');
$r->setBasicAuth('FDW','PASS');
$r->sendRequest();
$page = $r->getResponseBody();
echo $page;

Usar el metodo de POST

Enviar por el método de POST requiere de manejo especial en cada argumento. Con el método de GET, estos argumentos están en la cadena de consulta, pero en un POST van en la solicitud cuerpo. Además, la solicitud necesita una cabecera Content-Length que le dice al servidor el tamaño del contenido a esperar en la solicitud cuerpo.

Mostrar una dirección URL con el método de POST en vez del metdo de GET es bien útil cuando la cadena es muy larga, más de 200 caracteres aproximadamente. La especificación de HTTP 1.1 en el RFC 2616 no impone una longitud máxima en las URL, por lo que el comportamiento varía entre las diferentes web y servidores proxy. Si al mostrar las URL con GET y recibes resultados inesperados o resultados con el código de estado 414 ( "Request-URI Too Long"), convierte la solicitud al método de POST.

file_get_contents()

<?php
$url = 'http://www.example.com/submit.php';
$body = 'FDW=programacion&PHP=f18';
$options = array('method' => 'POST', 'content' => $body);
$context = stream_context_create(array('http' => $options));
$page = file_get_contents($url, false, $context);
echo $page;

cURL

<?php
$url = 'http://www.example.com/submit.php';
$body = 'FDW=programacion&PHP=f18';
$c = curl_init($url);
curl_setopt($c, CURLOPT_POST, true);
curl_setopt($c, CURLOPT_POSTFIELDS, $body);
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
$page = curl_exec($c);
curl_close($c);
echo $page;

HTTP_Request

<?php
require 'HTTP/Request.php';
$url = 'http://www.example.com/submit.php';
$r = new HTTP_Request($url);
$r->setMethod(HTTP_REQUEST_METHOD_POST);
$r->addPostData('FDW','programacion');
$r->addPostData('PHP','f18');
$r->sendRequest();
$page = $r->getResponseBody();
echo $page;

Enviar cookies

Las cookies se envían al servidor en el encabezado de solicitud de cookies. La extensión cURL tiene una opción específica en cookies, pero con HTTP_Request, tienes que agregar el encabezado de cookies al igual que con otras cabeceras de petición. Los valores de Cookie múltiples se envían en una lista delimitada por coma. En los ejemplos vamos a enviar dos cookies: una con el nombre de user y con el valor FDW y otra con el nombre de actividad y con el valor de programacion.

file_get_contents()

<?php
$options = array('http' =>
    array(
        'method'  => 'GET',
        'header'  => 'Content-type: text/plain;charset=UTF-8\r\n'.
        'Referer: http://www.forosdelweb.com\r\n'.
        'User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; es-ES; rv:1.9.0.6) Gecko/2009011913 Firefox/3.0.6\r\n'.
        'Cookie: user=FDW; actividad=programacion;\r\n'
    )
);
$context = stream_context_create($options);
$page = file_get_contents('http://www.example.com/enviar-cookies.php', false, $context);
echo $page;

cURL

<?php
$c = curl_init('http://www.example.com/enviar-cookies.php');
curl_setopt($c, CURLOPT_COOKIE, 'user=FDW; actividad=programacion');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
$page = curl_exec($c);
curl_close($c);
echo $page;

HTTP_Request

<?php
require 'HTTP/Request.php';
$r = new HTTP_Request('http://www.example.com/enviar-cookies.php');
$r->addHeader('Cookie','user=FDW; actividad=programacion');
$r->sendRequest();
$page = $r->getResponseBody();
echo $page;

Seguir redireccionamientos

file_get_contents()

Nota: El file_get_contents() sigue automáticamente las redirecciones (header("Location: redireccion.php")).

<?php
$url = 'http://www.example.com/redireccionar.php';
$page = file_get_contents($url);
echo $page;

cURL

<?php
$c = curl_init('http://www.example.com/redireccionar.php');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
curl_setopt($c, CURLOPT_FOLLOWLOCATION, true);
$page = curl_exec($c);
curl_close($c);
echo $page;

HTTP_Client

Nota: HTTP_request no sigue las redirecciones, pero el módulo de PEAR HTTP_Client logra lo que queremos

<?php
$url = 'http://www.example.com/redireccionar.php';
require_once 'HTTP/Client.php';
$client = new HTTP_Client();
$client->get($url);
$page = $client->currentResponse();
echo $page['body'];

No seguir redirecciones

Como hemos indicado anteriormente el file_get_contents() sigue automáticamente las redirecciones (header("Location: redireccion.php")). A partir de PHP 5.0.0, file_get_contents() y fopen() nos da unas opciones especificas acerca de como obtener el stream. En PHP 5.1.0 y posteriores, una de esas opciones esmax_redirects el número máximo de redirecciones a seguir. Si indicamos el max_redirects a 0 o 1, solo hace una solicitud.

El max_redirects realmente no indica el número de redirecciones deben seguirse, pero el número máximo de solicitudes que deben efectuarse en el momento siguiente a la cadena de redireccionamiento. Es decir, un valor de 1 le dice a PHP que al menos una solicitud debe seguir, y no un redireccionamiento. Un valor de 2 le dice a PHP para que al menos de 2 solicitudes deben seguir y no más de 1 redireccionamiento. Un valor de 0, sin embargo, se comporta como un valor de 1, PHP hace sólo 1 solicitud.

file_get_contents()

<?php
$url = 'http://www.example.com/redireccionar.php';
$options = array('max_redirects' => 1 );
$context = stream_context_create(array('http' => $options));
$page = file_get_contents($url, false, $context);
echo $page; 

cURL

Nota: Para no seguir las redirecciones no uses CURLOPT_FOLLOWLOCATION

<?php
$c = curl_init('http://www.example.com/redireccionar.php');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
$page = curl_exec($c);
curl_close($c);
echo $page;

HTTP_Request

Nota: HTTP_Request no sigue redirecciones

<?php
require_once 'HTTP/Request.php';
$r = new HTTP_Request('http://www.example.com/redireccionar.php');
$r->sendRequest();
$page = $r->getResponseBody();
echo $page;

Configurar tiempo limite

Si quieres obtener una URL remota, pero no quieres esperar demasiado tiempo si el servidor remoto está ocupado o lento.

file_get_contents()

Nota: Estableceremos el tiempo limite a 15 segundos

<?php
ini_set('default_socket_timeout', 15);
$page = file_get_contents('http://slow.example.com/');

cURL

Nota: Estableceremos el tiempo limite a 15 segundos

<?php
$c = curl_init('http://slow.example.com/');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
curl_setopt($c, CURLOPT_CONNECTTIMEOUT, 15);
$page = curl_exec($c);
curl_close($c);
echo $page;

HTTP_Request

Nota: Estableceremos el tiempo limite a 15 segundos

<?php
require_once 'HTTP/Request.php';
$opts = array('timeout' => 15);
$r = new HTTP_Request('http://slow.example.com/', $opts);
$page = $r->sendRequest();
echo $page;

Configurar el tiempo de leer

Si dependes de un servicio remoto, puede estar funcionando y en marcha, pero no estara en condiciones de manejar sus pedidos debido a problemas de red entre tu servidor y el servidor remoto. Limitar la cantidad de tiempo que espera de PHP para conectar a un servidor remoto es una buena idea, si se utilizan datos procedentes de fuentes remotas que sea parte del proceso de construcción de la página.

Todas las técnicas que describiremos limita la cantidad de tiempo de espera de PHP para conectar a un servidor remoto. Si estas realmente preocupado por las respuestas rápidas, adicionalmente configura el límite de cuánto tiempo PHP espera recibir los datos de los zócalos conectados. Para una conexión stream, utilice la función de [B]stream_set_timeout()[/B]. Para esta función necesitas abrir un stream con [B]fopen()[/B] y no con [B]file_get_contents()[/B]. En los ejemplo limitaremos el tiempo de leer a 20 segundos.

Aunque el establecimiento de conexión y los tiempos de lectura puede mejorar el rendimiento, también puede dar lugar a respuestas ilegibles. La secuencia de comandos puede leer sólo una respuesta parcial ante un tiempo de expiración. Si ha establecido los tiempos, asegúrese de validar toda la respuesta que ha recibido. Por otra parte, en situaciones en las que la generación de la página rápido es fundamental, puedes recuperar los datos externos en un proceso separado y escribir a una memoria caché local. De esta forma, sus páginas pueden usar el caché, sin temor a límites de tiempo o respuestas parciales.

fopen()

<?php
$url = 'http://slow.example.com';
$stream = fopen($url, 'r');
stream_set_timeout($stream, 20);
$page = stream_get_contents($stream);
fclose($stream);
echo $page;

cURL

<?php
$c = curl_init('http://slow.example.com/');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
curl_setopt($c, CURLOPT_CONNECTTIMEOUT, 15);
curl_setopt($c, CURLOPT_TIMEOUT, 20);
$page = curl_exec($c);
curl_close($c);
echo $page;

HTTP_Request

<?php
require_once 'HTTP/Request.php';
$opts = array('readTimeout' => array(20,0));
$r = new HTTP_Request('http://slow.example.com/', $opts);
$page = $r->sendRequest();
echo $page;

Otro método para incluir las variables y valores en la consulta

Haciendo uso de http_build_query() puedes mostrar una página incluyendo las variables con sus respectivos valores en la consulta. Se acepta una serie de clave/valor en pares y devuelve una única cadena con todo escapado correctamente. Tu eres responsable del símbolo de ? en el URL para establecer la consulta.

file_get_contents

<?php
$vars = array('FDW' => 4, 'Programación' => 'PHP & f18');
$qs = http_build_query($vars);
$url = 'http://www.example.com/search.php?' . $qs;
$page = file_get_contents($url);

Bajar archivos

file_get_contents

<?php
$url = "http://www.example.com/zip.zip";
$g=basename($url);
$content = file_get_contents($url);
file_put_contents($g,$content);

cURL

<?php
$url = 'http://www.example.com/hola.zip';
 
$g=basename($url);
 
if(!is_file($g)){
    $fp=fopen ($g, "w");
 
    $ch=curl_init($url);
    curl_setopt ($ch,CURLOPT_FILE, $fp);
    curl_setopt($ch,CURLOPT_CONNECTTIMEOUT,60);
    curl_exec ($ch);
    curl_close ($ch);
 
    fclose($fp);
}

Subir archivos

cURL

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "http://example.com/send_file.php");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
// lo mismo que <input type="file" name="nombre_del_input" />
$post = array(
    "nombre_del_input"=>"@C:/directorio/hacia/el/archivo.jpg",
);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
$page = curl_exec($ch);

Tengo la grata oportunidad de informar que la revista de la Facultad de Informática – UPM conocida como COLEÓPTEROS ha sido adquirida por el Proyecto Smultron.

La historia de esta revista se remonta a principios de los años 90, y su trayectoria se conmemora hasta finales de 2009, cuando el Proyecto Smultron adopta esta herramienta como medio de comunicación y la impulsa para que pase de informar a un grupo reducido de alumnos, a informar a TODO EL MUNDO, compaginando una edición online junto a una edición tradicional.

COLABORADORES | PATROCINADORES | LECTORES | TODO EL MUNDO

CONTACTA !!

Aquí podeis ver un par de números de esta exitosa revista.

Numeros Anteriores.

Si no conoces Spotify te aconsejo ir a http://smultron.es/spotify

Hazte Fan de Smultron en FACEBOOK

Copy&Page: http://www.elwebmaster.com/general/insertar-y-personalizar-google-maps-en-tu-sitio-web

(version Inglesa: http://stiern.com/tutorials/adding-custom-google-maps-to-your-website)

En los sitios web de una compañía a menudo se utilizan mapas para mostrarle a los clientes dónde los pueden encontrar. Para esto, Google Maps es excelente.

Pero ¿No sería genial añadir el logo de nuestra compañía, los estacionamientos cercanos, las estaciones de trenes, y otros datos alternativos en el mapa para ayudar más a los clientes?

Antes de empezar, veamos lo que vamos a crear:

Google Maps API

La API Google Maps te permite embeber mapas directamente en tu sitio web. Sólo se necesita un poco de JavaScript, y algo de CSS para embellecer. Recientemente ha sido lanzada la Version 3 de la API Google Maps que es la que vamos a utilizar.

Obteniendo las coordenadas

Como seguramente no conocen las coordenadas precisas de su locación, les explicaremos una forma rápida que Google ha puesto a nuestra disposición para conocerlas. Cuando conoces la dirección exacta, puedes ingresar una URL de esta forma:

Cuando ingreses esto en tu barra de direcciones, verás lo siguiente:

Las coordenadas del cuartel general de Apple en Cupertino

El primer número es el código del estado en el que está el punto del mapa según Google, y 200 quiere decir que todo está bien. El segundo número muestra cuán precisa es la dirección, en este caso el número es 8, que es bastante bueno. Los últimos dos números son latitudes y longitudes, que son los números que necesitamos.

Añadiendo el mapa a tu web

Abre tu editor HTML favorito y crea un archivo HTML estándar con codificación UTF-8.

Primero que nada es necesario crear el puerto de visualización y decirle a nuestro archivo HTML que obtenga el archivo Javascript del código Google.

Añade estas líneas entre <head> y </head>:

Luego de la URL, notarás sensor=false. Dado que no utilizamos ningún sensor, como un GPS, para localizar el lugar, esto se programa en false. Justo debajo de lo que hemos insertado, escriban lo siguiente:

En la línea 2 creamos la función initialize(). Dentro de esta function vamos a definir las configuraciones básicas del mapa. En la línea 3 creamos una nueva variable, latlng. latlng que representa las latitudes y longitudes. La variable contiene las coordenadas que utilizaremos como centro de nuestro mapa.

Luego de esto creamos la variable settings. Aquí tenemos muchas opciones.

• zoom específica cuánto zoom tundra el mapa.
• center específica nuestro centro. Al escribir latlng, nos referemos a la variable que hemos creado antes y se utilizará la coordenada dentro de ésta.

El último código cambia el diseño del mapa para que sea un poco más minimalista. Los controles en la esquina superior derecha (Map, Satellite, Terrain) se cambian por un menu desplegable y los controles de navegación/escalamiento en el lado izquierdo se cambiar por controles pequeños.

mapTypeId: google.maps.MapTypeId.ROADMAP define que nuestro mapa debe ser del tipo ROADMAP – lo puedes cambiar por SATELLITE, HYBRID o TERRAIN.

Debajo del código anterior, escriban esto:

Este código crea la variable map, y define que el mapa debe utilizar las configuraciones que hemos creado.

Escriban:

Para terminar la función, y en body, escriban esto:

Al hacer esto le decimos a nuestro sitio que ejecute la función the initialize() al cargar, y que inserte un div con el tamaño que deseamos que tenga nuestro mapa.

Añadiendo marcadores

Ahora debemos añadir algunos marcadores. Comencemos por crear los estándar y luego los personalizaremos.

Justo debajo de:

Inserten el siguiente código:

Primero, hemos creado la variable companyPos, donde especificamos la posición del marcador. Luego hemos creado al marcador en sí utilizando la variable companyMarker.

Personalizando los marcadores

Podemos hacer mucho más bonitos nuestros marcadores. Simplemente creemos una imagen en Photoshop con un tamaño de 100×50 píxeles, y creemos algo similar a esto:

Luego, creemos una sombra para la imagen:

Para añadir estas imágenes como marcadores, tenemos que cambiar el código del marcador por esto:

La variable companyImage apunta al nombre de la imagen del logo. Luego define el tamaño, origen y el tip de la imagen (dónde estará la imagen añadida a la coordenada). Luego, hacemos exactamente lo mismo para la sombra en la variable companyShadow. En la variable companyMarker añadimos icon y shadow, y listo.

Ahora, si actualizas tu sitio verás que el marcador ha cambiado por tu propio logo. Para añadir más marcadores, sigue simplemente el mismo método, cambiando los nombres de las variables.

Si tienes dos marcadores muy cerca el uno del otro, quizá debas agregar algo de z-index. El marcador con el z-index más alto, es el que más arriba está:

Añadir zIndex nos permite seleccionar qué marcador debe ir arriba.

Añadiendo cajas de información

Para añadir una descripción de tu compañía que aparezca cuando un visitante hace clic en el logo podemos agregar un infobox. Con la API Google Maps esto es fácilisimo.

Peguemos este código luego de definir la variable map:

Para hacer que las cajas de información aparezcan al hacer clic en nuestro logo, simplemente debemos añadir este código justo antes del último } en la función initialize():

Para hacer un poco más bonita la caja de información, añadamos algo de estilo en nuestra hoja de estilos:

Y ahí lo tienen. Un Google Map bonito y fácilmente añadido en tu sitio web o blog.

Descarga

Para descargar los archivos de muestra hagan clic aquí.

Fuente: Stiern

Copy&Page: http://systemadmin.es/2009/09/programacion-de-un-modulo-del-kernel-simple

Programación de un modulo del kernel simple

La programación de un módulo del kernel de Linux no es tan diferente de la programación de cualquier otro software, simplemente los errores se suelen pagar más caros. Vamos a ver el típico Hello World como módulo del kernel:

Primero de todo deberemos incluir algunos headers que contienen definiciones que vamos a necesitar:

#include <linux/init.h>
#include <linux/module.h>

A continuación deberemos definir la licencia del modulo:

MODULE_LICENSE("GPL");

Si nos la inventamos simplemente nos avisara al hacer el insmod:

helloworld: module license 'xGPL' taints kernel.

A continuación deberemos definir las funciones de inicialización i destrucción del modulo en las cuales para este sencillo ejemplo haremos un simple printk (equivalente de printf en el kernel):

static int hello_world_init(void)
{
        printk(KERN_ALERT "Hello World!\n");
        return 0;
}

En la función de destrucción haremos lo mismo:

static void hello_world_exit(void)
{
        printk(KERN_ALERT "Bye World!\n");
}

Finalmente deberemos indicar como hemos llamado a las funciones mediante module_init y module exit:

module_init(hello_world_init);
module_exit(hello_world_exit);

Finalmente deberemos crear el fichero de Makefile:

obj-m += helloworld.o

all:
        make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
        make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

Es obligatorio que antes de los comandos “make” haya un tabulador y no un conjunto de espacios, sino no va a reconocer el formato del Makefile.

Con el comando make vamos a compilar el modulo del kernel:

# make
make -C /lib/modules/2.6.18-53.1.21.el5PAE/build M=/home/jordi/helloworld modules
make[1]: Entering directory `/usr/src/kernels/2.6.18-53.1.21.el5-PAE-i686'
  CC [M]  /home/jordi/helloworld/helloworld.o
  Building modules, stage 2.
  MODPOST
  CC      /home/jordi/helloworld/helloworld.mod.o
  LD [M]  /home/jordi/helloworld/helloworld.ko
make[1]: Leaving directory `/usr/src/kernels/2.6.18-53.1.21.el5-PAE-i686'

Mediante un ls podemos ver los ficheros que ha generado:

# ls
helloworld.c  helloworld.ko  helloworld.mod.c  helloworld.mod.o  helloworld.o  Makefile  Module.symvers

Podemos cargar el módulo mediante insmod:

insmod helloworld.ko

A continuación mediante el dmesg podremos ver el Hello World:

audit(1254211500.001:3472101): user pid=1772 uid=0 auid=0 msg='insmod helloworld.ko '
Hello World!

Una forma de ver que el módulo esta cargado es mediante lsmod:

# lsmod  | grep hel
helloworld              5504  0

Para ver el “Bye World” lo descargamos mediante rmmod:

rmmod helloworld

Y de nuevo, con dmesg, podremos ver el mensaje de despedida:

audit(1254211613.892:3472132): user pid=1772 uid=0 auid=0 msg='rmmod helloworld'
Bye World!
audit(1254211627.421:3472133): user pid=1772 uid=0 auid=0 msg='dmesg 

Copy&Page: http://systemadmin.es/2009/09/seguir-una-llamada-a-sistema-concreta-con-strace

Cuando se deben resolver problemas extraños con el sistema se suele recurrir a strace para ver que esta ocurriendo. El principal inconveniente de strace es que da mucha información, lo cual puede llegar a despistar más que ayudar. Vamos a ver como seguir una llamada concreta al sistema.

Mediante el parámetro -e podemos indicar una expresión que filtre las llamadas que queremos ver. Por ejemplo, si queremos ver solo las llamadas a la función open usaríamos como parámetro trace=open. El comando completo sería:

# strace -s 128 -fF -e trace=open ls
open("/etc/ld.so.cache", O_RDONLY)      = 3
open("/lib64/librt.so.1", O_RDONLY)     = 3
open("/lib64/libacl.so.1", O_RDONLY)    = 3
open("/lib64/libc.so.6", O_RDONLY)      = 3
open("/lib64/libpthread.so.0", O_RDONLY) = 3
open("/lib64/libattr.so.1", O_RDONLY)   = 3
open("/lib64/libdl.so.2", O_RDONLY)     = 3
open("/lib64/libsepol.so.1", O_RDONLY)  = 3
open("/proc/mounts", O_RDONLY)          = 3
open("/usr/lib/locale/locale-archive", O_RDONLY) = 3
open(".", O_RDONLY|O_NONBLOCK|O_DIRECTORY) = 3
index.php

También podemos definir un conjunto de llamadas separadas por comas:

# strace -s 128 -fF -e trace=open,close ls
open("/etc/ld.so.cache", O_RDONLY)      = 3
close(3)                                = 0
open("/lib64/librt.so.1", O_RDONLY)     = 3
close(3)                                = 0
open("/lib64/libacl.so.1", O_RDONLY)    = 3
close(3)                                = 0                           = 0
open("/lib64/libc.so.6", O_RDONLY)      = 3
close(3)                                = 0
open("/lib64/libpthread.so.0", O_RDONLY) = 3
close(3)                                = 0
open("/lib64/libattr.so.1", O_RDONLY)   = 3
close(3)                                = 0
open("/lib64/libdl.so.2", O_RDONLY)     = 3
close(3)                                = 0
open("/lib64/libsepol.so.1", O_RDONLY)  = 3
close(3)                                = 0                            = 0
open("/proc/mounts", O_RDONLY)          = 3
close(3)                                = 0
open("/usr/lib/locale/locale-archive", O_RDONLY) = 3
close(3)                                = 0
open(".", O_RDONLY|O_NONBLOCK|O_DIRECTORY) = 3
close(3)                                = 0
index.php
close(1)                                = 0

Podemos incluso definir filtros inversos, es decir, ver todas las llamadas al sistema excepto una o un conjunto indicando una admiración (!) para indicar la negación del filtro. Por ejemplo, para ver todas las llamadas excepto open y close usaríamos el filtro “trace=!open,close“:

# strace -s 128 -fF -e 'trace=!open,close' ls
execve("/bin/ls", ["ls"], [/* 25 vars */]) = 0
brk(0)                                  = 0x127c3000
uname({sys="Linux", node="maria.grupointercom.com", ...}) = 0
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
fstat(3, {st_mode=S_IFREG|0644, st_size=39087, ...}) = 0
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0 \"`<2\0\0\0@\0\0\0\0\0\0\0\10\307\0\0\0\0\0\0\0\0\0\0@\0008\0\t\0@\0'\0&\0\6\0\0\0\5\0\0\0@\0\0\0\0\0\0\0@\0`<2\0\0\0@\0`<2\0\0\0\370\1\0\0\0\0\0\0\370\1\0\0\0\0\0\0\10\0\0\0\0\0\0\0\3\0\0\0\4\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=53448, ...}) = 0
mprotect(0x323c607000, 2097152, PROT_NONE) = 0
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\0\31 \2234\0\0\0@\0\0\0\0\0\0\0(f\0\0\0\0\0\0\0\0\0\0@\0008\0\5\0@\0\35\0\34\0\1\0\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0 \2234\0\0\0\0\0 \2234\0\0\0004Y\0\0\0\0\0\0004Y\0\0\0\0\0\0\0\0 \0\0\0\0\0\1\0\0\0\6\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=28008, ...}) = 0
(...)

Tutorial, Guía o Simplemente Introducción al Comando Sed de Unix

Copyright (c) 2009 Héctor Francisco Hernández <hectorfh@gmail.com>.

Se otorga permiso para copiar, distribuir y/o modificar este documento bajo los términos de la Licencia de Documentación Libre de GNU, Versión 1.3 o cualquier otra versión posterior publicada por la Free Software Foundation; sin Secciones Invariantes ni Textos de Cubierta Delantera ni Textos de Cubierta Trasera. Una copia de la licencia se encuentra en http://www.gnu.org/copyleft/fdl.html.

1. Introducción

La herramienta de Unix "sed" ("stream editor" o "editor de flujo") es, junto con "awk" (y sin
contar a Perl, la panacea, en la contienda), la más poderosa en lo que
a procesamiento de texto plano se refiere.

Al igual que el editor "ed", del cual toma todos sus comandos, permite escribir pequeños scripts de edición de texto en un
particular lenguaje:

# el comando "i" inserta texto en la línea
# que se le indique
sed '7i hola mundo' zaraza.txt

# el comando "d" borra líneas
sed '1d' zaraza.txt

# el comando "s" sustituye texto utilizando
# expresiones regulares si se desea
sed '1,$s/palavra/palabra/g' zaraza.txt

Sin embargo, su característica distintiva es la habilidad de procesar
texto proveniente desde la entrada estándar. La que lo convierte en una
herramienta ideal para construir filtros y utilizarlos en nuestros scripts
Bourne, Korn, tcsh, bash, o lo que fuere.

2. Uso Básico

Las instrucciones que entiende "sed" están compuestas primero por el
número o rango de líneas sobre el cual se realizará la transformación y
luego por la acción a realizar. Omitir el número o rango de líneas
implicará que la acción se ejecute sobre la totalidad de las mismas.

De este modo si, por ejemplo, disponemos del siguiente listado obtenido por el
comando "ps":

 PID   TTY TIME     CMD
6245 pts/1 00:00:00 bash
6246 pts/1 00:00:00 ps

Y para procesar el listado queremos suprimir los títulos,
podríamos eliminar la primera línea con la instrucción
"1d". Por lo tanto nuestro comando en el shell sería
"ps | sed ’1d’" y obtendríamos:

6245 pts/1 00:00:00 bash
6246 pts/1 00:00:00 ps

Los rangos de líneas son de la forma "n,m" que significa
"desde la línea n inclusive hasta la línea m".
Pudiendo "m" ser el símbolo especial "$" que
indica el final del archivo.

Así, por ejemplo, si quisiéramos, como generalmente ocurre,
obtener desde la línea 74 hasta la 83 de un archivo de texto denominado
"xxx" podríamos hacerlo con la instrucción
"74,83p" así:

sed -n '74,83p' xxx

En este ejemplo debo hacer notar el parámetro "-n". Por
defecto "sed" imprime todo a la salida estándar, sólo
que "-n" modifica este comportamiento para que no lo haga. Por lo
tanto, si no usáramos el parámetro "-n"
obtendríamos todo el archivo "xxx" con las
líneas desde la 74 hasta la 83 duplicadas, ya que la instrucción
"p" volvería a imprimirlas.

No sólo es posible indicar un número de línea o un rango numérico,
también es posible indicar una expresión regular o un rango de
expresiones regulares.

Cuando queremos que la acción se ejecute sobre las líneas que
coincidan con una expresión determinada, debemos escribirla delante del
comando entre barras:

# imprime sólo las líneas que tengan la
# palabra "proc", lo mismo que haría el
# comando "grep proc"
sed -n '/proc/p'

# borra lo que se encuentre entre
# "#ifdef __WIN32__" y "#endif"
sed '/#ifdef __WIN32__/,/#endif/d'

De este modo, por ejemplo, si disponemos del siguiente listado arrojado por
"ls":

total 888
-rw-r--r--  1 usuario1 users   2737 2003-04-01 04:36 LICENSE.txt
-rw-r--r--  1 usuario1 users   3639 2003-04-01 04:36 README.txt
drwxr-xr-x  4 usuario1 users   4096 2007-09-08 21:52 build
drwxr-xr-x  2 usuario1 users   4096 2007-09-08 21:52 convert
drwxr-xr-x  5 usuario1 users   4096 2007-09-08 21:52 docs
drwxr-xr-x 12 usuario1 users   4096 2007-09-08 21:52 examples
drwxr-xr-x  3 usuario1 users   4096 2003-04-01 04:35 src
drwxr-xr-x 12 usuario1 users   4096 2003-04-01 04:36 test
-rw-r--r--  1 usuario1 users 351405 2003-04-01 04:36 velocity-1.3.1.jar
-rw-r--r--  1 usuario1 users 510105 2003-04-01 04:36 velocity-dep-1.3.1.jar
drwxr-xr-x  5 usuario1 users   4096 2007-09-08 21:52 xdocs

Y queremos obtener un listado sólo de los directorios (las filas que
comienzan con la letra "d"). Podríamos utilizar el sed para
borrar las entradas que no comienzan con esa letra:
"ls -l | sed ‘/^d/!d’":

drwxr-xr-x  4 usuario1 users 4096 2007-09-08 21:52 build
drwxr-xr-x  2 usuario1 users 4096 2007-09-08 21:52 convert
drwxr-xr-x  5 usuario1 users 4096 2007-09-08 21:52 docs
drwxr-xr-x 12 usuario1 users 4096 2007-09-08 21:52 examples
drwxr-xr-x  3 usuario1 users 4096 2003-04-01 04:35 src
drwxr-xr-x 12 usuario1 users 4096 2003-04-01 04:36 test
drwxr-xr-x  5 usuario1 users 4096 2007-09-08 21:52 xdocs

Note que el símbolo de exclamación "!" detrás
de la expresión regular niega la condición. Esto debería
leerse como "borre todas las líneas que no comiencen con la letra
d".

Otra forma de obtener el mismo resultado es imprimiendo sólo
las líneas que comienzan con la letra "d":

ls -l | sed -n '/^d/p'

Explicar las expresiones regulares va más allá de los
límites de este artículo, pero el carácter "^"
significa "comienzo de línea", por lo tanto "^d"
hace referencia a las líneas que poseen una "d" seguida de
su comienzo.

3. Lo Más Importante: El Comando "s"

El comando "s" sustituye expresiones regulares en la línea actual.
Este comando por sí sólo sería justificación para
la existencia del sed.

El modo de uso de este comando es "s/patrón/reemplazo/flags". Donde
"patrón" es la expresión regular que debe sustituirse por
"reemplazo" y los flags son modificadores opcionales que indican, por ejemplo,
si la búsqueda debe discriminar entre mayúsculas y
minúsculas o no.

Siguiendo mi uso de explicar con ejemplos, suponga que posee un texto donde
las palabras podrían estar separadas por más de un espacio:

Aquí   me pongo a   cantar
al  compás de    la vigüela,
que al hombre  que lo desvela
una   pena     estrordinaria,
como la ave solitaria
con    el cantar se   consuela.

Sin embargo usted necesita, por alguna extraña razón que ahora no
se me ocurre, que estén separadas por exactamente un único
espacio. Podría sustituir el patrón "uno o más espacios"
por un único espacio. El comando sería:

sed 's/ \+/ /g'

El "\+" luego de un carácter significa una o más ocurrencias de
ese carácter (se recomienda leer sobre expresiones regulares en general).
La letra "g" al final es un flag que hace que se sustituyan todos los patrones
encontrados en cada línea. Sin él sólo se
sustituirá la primera ocurrencia en cada renglón del texto.

El resultado:

Aquí me pongo a cantar
al compás de la vigüela,
que al hombre que lo desvela
una pena estrordinaria,
como la ave solitaria
con el cantar se consuela.

Y así también es posible hacer referencia al "patrón" o a
"subpatrones" en el "reemplazo" mediante los carácteres especiales
"\&" y "\1", "\2", "\3"… "\n" respectivamente. Por ejemplo, suponga que
posee la siguiente lista en la que cada elemento es de la forma
"archivo@direcorio":

libhardware.a@dosbox-0.70/src/hardware
Makefile.in@dosbox-0.70/src/libs
video.h@dosbox-0.70/include
README.video@dosbox-0.70/docs
Makefile@dosbox-0.70/visualc_net

Luego de aplicarle a la lista "sed ‘s_\(.*\)@\(.*\)_\2/\1_’", obtenemos:

dosbox-0.70/src/hardware/libhardware.a
dosbox-0.70/src/libs/Makefile.in
dosbox-0.70/include/video.h
dosbox-0.70/docs/README.video
dosbox-0.70/visualc_net/Makefile

Esto significa que "\1" hace referencia al subpatrón que se encuentra
entre los primeros paréntesis y que "\2" hace referencia al
subpatrón entre los segundos paréntesis. Fíjese
también que en lugar de separar los parámetros del comando con
una barra "/" lo hice con "_". Esto es porque sed nos permite utilizar cualquier
carácter como separador y se dará cuenta automáticamente
de cuál estamos usando.

Aunque el ejemplo que acabo de enseñar parece estúpido,
créame que es real y que para un trabajo me ha tocado hacer un script
que leía una lista con esa estructura.

4. Procesando Varias Líneas por Vez

Hasta el momento en todos los ejemplos que mostré se leía una
línea, se chequeaba una condición y se realizaba una
operación. Y así cada operación involucraba una
única línea.

Existen, sin embargo, circunstancias en las que es necesario operar sobre
más de una línea por vez. Observe el siguiente archivo:

Registro: 1
Nombre: Anibal
Telefono: 621-229

Registro: 2
Nombre: Hector
Telefono: 562-245

Registro: 3
Nombre: Pablo
Telefono: 622-354

Alguien ha decidido guardar una lista de personas con sus números
de teléfonos en un extraño formato, utilizando cuatro
líneas por registro.
Nuestra tarea es poner la información en una manera más
conveniente para su procesamiento:

1;Anibal;621-229
2;Hector;562-245
3;Pablo;622-354

Claro está que sería imposible
solucionar este problema leyendo de a una línea a la vez. Sería
bueno poder trabajar leyendo de a un registro (cuatro líneas) por
iteración.

Este tipo de problemas se resuelve con el comando "N", que fuerza
la lectura
de la siguiente línea en la iteración actual.

Al comenzar la iteración, sed trae la línea al buffer.
Internamente el valor del buffer sería:

buffer = "Registro: 1"

Luego de ejecutar la instrucción "N", que lee la
línea siguiente y la concatena en el buffer, quedaría:

buffer = "Registro: 1\nNombre: Anibal"

Observe que "\n" significa "nueva línea"
(el carácter ASCII número 10).

Como vemos, nos vamos aproximando a la solución. Basta con leer
dos líneas más y ya tenemos el registro completo.
Y luego de hacerlo debemos reemplazar el retorno de carro "\n"
por ";" con "s/\n/;/g", para así llegar a:

buffer = "Registro: 1;Nombre: Anibal;Telefono: 621-229;"

Ahora resta quitar lo que molesta, las palabras
"Registro: ", "Nombre: ", "Telefono: " y el
punto y coma de más al final.

Para lograrlo utilizaremos una super sustitución con expresiones
regulares:

"s/^Registro: \(.*\);Nombre: \(.*\);Telefono: \(.*\);$/\1;\2;\3/"

buffer = "1;Anibal;621-229"

Ahora podríamos poner todo junto.
Suponiendo que los datos originales estaban en el archivo "agenda",
nuestro comando quedaría:

sed 'N;N;N;s/\n/;/g;s/^Registro: \(.*\);Nombre: \(.*\);Telefono: \(.*\);$/\1;\2;\3/' agenda

Ilegible, ¿verdad? Si así lo considera, puede hacerlo en dos
pasos invocando dos veces al sed.

5. Programación en Sed

En la documentación del sed de GNU, el capítulo que explica esto dice
"Comandos para gurúes del sed … En la mayoría de los casos, el uso de
estos comandos indican que probablemente sea mejor programar en awk o Perl".
La razón por la cual enseño estos comandos es para mostrar el límite de la herramienta.

A pesar de no tener variables ni poseer forma de controlar el flujo de
ejecución más que con etiquetas, un comando para "GOTO" y otro
para "GOTO" condicional, sed es un lenguaje "Turing-completo". Esto es que
tiene un poder computacional equivalente a la máquina universal de
Turing. Por eso circula un mito nerd de que en algún lugar de la web
se puede descargar los fuentes de un sokoban, un arkanoid y algún otro
juego clásico implementado en sed.

Los comandos para hacer un "GOTO" incondicional y condicional son "b" y "t"
respectivamente. Las etiquetas se definen con el comando ":". Además
sed posee un buffer denominado "hold space" que provee un espacio adicional para
almacenar datos sobre el cual podremos guardar y recuperar lo que pongamos con
los comandos h, H, g, G, x. Refiéranse a la documentación del sed
los interesados, pues no tengo interés en explicar sobre este asunto.

Imaginese que sin variables, sin estructuras de control y sin operadores
aritméticos entre otras cosas,
la programación en sed no es más que otro aburrido juego de
ingenio para simios. Por este motivo será que finalizaré este
capítulo copiándole un script del tutorial "Sed – An Introduction and
Tutorial" de Bruce Barnett que ilustra algo de esto y dejaré el tema
allí mismo.

Lo que hace el ejemplo es guardar los párrafos en el "hold buffer" a
medida que los va leyendo. Si el párrafo posee el patrón pasado
por parámetro al script lo imprime.

#!/bin/sh
sed -n '
# Si es una línea vacía, finaliza el párrafo.
# Por lo tanto se debe analizar. Se hace un "GOTO" a "para".
/^$/ b para
# Si la línea no está vacía, se agrega al "hold buffer".
H
# Al final del archivo se analiza el último párrafo.
# "GOTO" a "para".
$ b para
# Se hace un "GOTO" al final del script.
b
# La etiqueta "para". Sección donde se analiza el párrafo.
:para
# Se recupera el párrafo completo.
x
# Se busca el patrón, si se encuetra se imprime el párrafo.
/'$1'/ p
'

6. Apéndice A: Quitando Tags XML. El Criterio "The Longest Match"

Para mostrar cómo se hace haré el siguiente ejercicio. Suponga
el siguiente código HTML:

<h2>Contenido</h2>
<ul>
<li class="toclevel-1">1 <span class="toctext">Historia</span></li>
<li class="toclevel-1">2 <span class="toctext">Ventajas del XML</span></li>
<li class="toclevel-1">3 <span class="toctext">Estructura del XML</span></li>
</ul>

Para obtener el texto sin los tags podría acceder a la página
ya procesada por el navegador web, copiar el texto con Ctrl-c y pegarlo con
Ctrl-v en mi editor favorito (las teclas pueden cambiar según el entorno
en el que estemos trabajando). Pero aquí, como mi intención es
mostrar el sed, lo haré con esta herramienta.

Lo que se me ocurre es sustituir el patrón "<.*>"
por una cadena vacía. Sin embargo el resultado obtendido luego de
ejecutar "sed ‘s/<.*>//g’ temp" es varias líneas
vacías.

Lo que pasa es que el patrón es ambiguo. Por ejemplo para
"<h2>Contenido</h2>" sed comenzaría leyendo desde
el primer "<", pero podría detenerse en el ">"
detrás del primer h2 o en el ">" detrás del segundo
h2. Y los creadores de la herramienta han decidido que se tome siempre la
coincidencia más larga, "the longest match".

Una solución al problema sería, por ejemplo, utilizar el
patrón "<[^<]*>". "[^<]" significa
cualquier caracter que no sea "<". En ese caso el resultado
sería:

Contenido
1 Historia
2 Ventajas del XML
3 Estructura del XML

7. Apéndice B: El Editor "ed"

Los comandos del sed provienen del editor más primitivo de Unix, llamado
"ed". Este editor, a diferencia de sed que es un editor de flujo, es
un editor común y corriente… bueno, casi. A diferencia de los editores
modernos no es "WYSIWYG" (What You See Is What You Get, o "lo que
vés es lo que obtenés"), o sea que no nos muestra el texto
que estamos editando, simplemente nos permite escribir comandos (más o
menos los mismos que el sed) de manera interactiva.

El uso de este editor no es común en estos tiempos, ya que la
mayoría de los programadores y administradores de Unix prefieren trabajar
con el "vi". Sin embargo, el ed puede aprovecharse como otro comando
para nuestros scripts cuando necesitamos abrir un archivo, hacer una
edición y volver a grabarlo. En ese caso no precisamos un editor de
flujo como el sed, sino más bien alguno que edite el archivo en el lugar.

Volvamos al ejemplo de eliminar los espacios sobrantes.

Aquí   me pongo a   cantar
al  compás de    la vigüela,
que al hombre  que lo desvela
una   pena     estrordinaria,
como la ave solitaria
con    el cantar se   consuela.

Imagínese que el texto se encuentra en el archivo "prueba.txt".
Si lo resolviésemos con el sed, como hicimos en el ejemplo pasado,
obtendríamos el resultado en la salida estándar o en otro archivo. Sin
embargo queremos que los datos permanezcan en "prueba.txt" luego de la
transformación. Por lo que tenemos dos opciones: a) obtener los datos
en un archivo auxiliar y luego reemplazar "prueba.txt" por este
archivo; o b) editar el archivo en el lugar utilizando el "ed".

El comando para editar el archivo en "ed" es el mismo que en el
"sed" pero con tres salvedades. La primera es que "ed" no
tiene como rango implícito todas las líneas del archivo, por lo
que sí o sí tenemos que indicarle el rango
"1,$" delante del comando. La segunda es que luego de la
transformación debemos ejecutar el comando "w" para grabar
el archivo, ya que "ed" no lo hará automáticamente.
Y la tercera es que los comandos se separan con una nueva línea, y no
con un ";".

"ed" recibe el nombre del archivo como parámetro y lee los
comandos desde la entrada estándar. También requiere la
opción "-n" para suprimir molestos mensajes. Por lo que
quedaría de la siguiente manera:

ed -s prueba.txt <<< $'1,$s/ \+/ /g\nw'

Pero algunas implementaciones modernas del "sed", como por ejemplo la
de GNU, también poseen la opción "-i" que permite
modificar el archivo en el lugar y obtener el mismo resultado:

sed -i 's/ \+/ /g' prueba.txt

8. Final

"sed" se encuentra siempre entre mi reducido y selecto repertorio de
herramientas de trabajo. Podría decir que está entre las muy
primeras opciones a la hora de realizar cualquier tipo de transformación
sobre textos extensos y que no conozco otra cosa que lo haga mejor.

Además de eso he tenido la oportunidad de operar en varios sistemas
tipo Unix distintos y todos poseen la herramienta. Y cuando me encontré
trabajando con sistemas de otro tipo, a falta de alguna mejor opción, he
tenido la necesidad de instalarla. Dicho sea de paso, he conseguido
implementaciones libres en la internet que se instalan fácilmente y sin
ningún tipo de problema.

La herramienta es más bien compacta, sencilla y poderosa. Por lo que se
logra dominar luego de usarla un par de veces, siempre y cuando se esté
familiarizado con las expresiones regulares. Y si no lo está es muy
recomendable que lea algún tutorial pequeño sobre el asunto y lo
ponga en práctica.

Hasta aquí espero que haya obtenido una idea acerca del "sed" y
del provecho que le puede sacar tanto para crear scripts o para transformar
todo tipo de textos.

Para más información sugiero que lea la documentación de

la implementación en su sistema operativo. Si tiene GNU instalado

escriba "info sed". También encontrará muchos textos

escritos en todos los idiomas en la internet, lo que es un punto a favor

del uso del "sed".

Ampliar

ENLACE: http://bitelia.com/2009/02/como-crear-una-aplicacion-para-iphone-en-30-dias

Enlace Oficial: http://developer.apple.com/iphone/designingcontent.html