Archivo

Archivo del autor

mayúsculas y minúsculas en BASH (toupper(), tolower()) [copia y pega]

Martes, 13 de Marzo de 2012 Gaspar Fernández Sin comentarios

mayuscula En ocasiones, es muy útil crear scripts en bash, aunque en ocasiones debemos controlar las mayúsculas y minúsculas, por ejemplo renombrando archivos, escribiendo informes o para ajustarse a diferentes convenciones a la hora de hacer un programa. Aquí dejo ejemplos de funciones tipo strtoupper(), strtolower(), por decir un equivalente en PHP.

Hay opciones, la elección de alguna de estas opciones depende del entorno en que nos encontremos, ya sea BASH, algún otro clon, y dispongamos de awk o tr.

La primera de ellas es para poner un texto en mayúsculas:

1
2
3
4
function uppercase()
{
    echo "$1" | awk '{print toupper($0)}'
}

Otra opción puede ser:

1
2
3
4
function uppercase()
{
    echo "$1" | tr 'a-z' 'A-Z'
}

Si usamos la versión 4.0 o superior de BASH, que ya tiene un tiempo, podemos hacer lo siguiente:

1
2
3
4
function uppercase()
{
    echo "${^^*}"
}

La segunda de ellas para poner un texto en minúsculas:

1
2
3
4
function lowercase()
{
    echo "$1" | awk '{print tolowe($0)}'
}

Otra opción puede ser:

1
2
3
4
function lowercase()
{
    echo "$1" | tr 'A-Z' 'a-z'
}

Si usamos bash 4.0 o superior podemos hacerlo mucho más fácil!

1
2
3
4
function lowercase()
{
     echo "${1,,*}"
}

C.I. XVII: Historia de C por Denis Ritchie, tareas elefante, Raspberry PI, NVIDIA y la Linux Foundation, sed, urandom en python

Domingo, 11 de Marzo de 2012 Gaspar Fernández 1 comentario

Mucho tiempo sin una sección de estas, y traigo contenidos muy variados:

Calmando los ventiladores de netbooks Acer One

Lunes, 5 de Marzo de 2012 Gaspar Fernández 2 comentarios

En ocasiones, el ventilador de los netbook Acer puede llegar a ser algo molesto, y bueno, no es porque sea molesto, sobre todo es porque un ventilador girando a toda pastilla, aunque es bueno que tenga fresco el procesador, es capaz de gastar una batería un 40% más rápido y si estamos fuera de casa o lejos de un enchufe se nos acaba el chollo pronto, eso sí, el portátil estará frío. ¿Tal vez será para vender baterías de 6 celdas?

He visto que el fallo afecta igual a usuarios de Windows o Linux, por lo que no parece que sea problema del sistema operativo. Navegando un poco por Internet encontré un script, acerfand de Rachel Greenham. No enlazo porque su web no funciona, avisadme si encontráis alguna que sí funcione. acerfandtar.

Este script debemos ejecutarlo como root y al iniciar el ordenador para que se encargue de controlar el movimiento del ventilador. Lo primero es dar permisos de ejecución y luego añadirlo a los scripts de arranque, por ejemplo añadiendo la ejecución a /etc/rc.local . Pero para evitar que el script se ejecute varias veces podemos crear otro script: /etc/acerfanloader (he supuesto que acerfand está en /usr/local/bin):

1
2
3
4
5
6
#!/bin/bash
prcs=`ps ax`
if [[ -z `echo $procs | grep acerfand` ]]
then
   /usr/local/bin/acerfand
fi

Luego el script acerfanloader lo podemos llamar desde rc.local y se ejecutará nada más encender el ordenador, para no tener que preocuparnos.

Actualización 20/04/2012 : Corregido el código gracias al comerario de luisgulo

Problema en Acer Aspire One AOA150: No carga la batería

Jueves, 1 de Marzo de 2012 Gaspar Fernández Sin comentarios

chocolate
Ha llegado a mis manos un Acer Aspire One ZG5 AOA150, tras un tiempo sin usarse, al enchufarlo todo va bien, pero cuando se trata de funcionar con él por batería, resulta imposible, es más, incluso estando enchufado, al cabo de un tiempo se apaga (sólo cuando tiene la batería puesta), y por supuesto la batería no carga, es más, ni se calienta. Todo apunta a que la batería está mal.

Estos portátiles tienen un circuito de protección de la batería, y se desactiva su uso cuando se lleva un tiempo sin usar. Después de desarmar el portátil y que luego me sobrara un tornillo, aunque son fáciles de desarmar, de hecho tienen que ser desarmados para cambiar la RAM o el disco duro, que es lo reemplazable. Después de probar otra batería, sin éxito, me da por mirar si hay actualizaciones de BIOS en la web, en efecto hay.

Pues vamos a reemplazar la BIOS. Aunque como buen fan del software libre, viendo las dos opciones que hay: desde Windows o desde MS-DOS. Me decido por la segunda. Por experiencia y sabiendo cómo es Windows yo no me fiaría reescribiendo la BIOS desde ese SO, el más mínimo fallo y perdemos el ordenador. Aunque actualmente, como fan del software libre (y porque no hay BIOS libre para este equipo, si no intentaríamos escribir esta). De la página anterior me bajé el 3310 y siguiendo este artículo podemos crear un disco con FreeDOS. En ese mismo pendrive USB podemos grabar los archivos para reprogramar la BIOS desde MSDOS. Tras ello, arrancar el netbook con el pendrive de FreeDOS y cargar el programa para reprogramar.
Apaga el Netbook, enciéndelo y la batería debería estar cargando, pero mejor pregúntaselo al sistema operativo:

$cat /proc/acpi/battery/BAT0/state

Si pone charging, la cosa va bien. De hecho ahora este netbook está funcionando como un campeón.

Aunque pongo en el artículo que es especial para este modelo de Netbook, creo que esto vale para muchos portátiles de Acer. Si nos aseguramos bien de que la BIOS corresponde al modelo que tenemos delante no hay ningún problema en reprogramarla.

Creando una unidad USB de arranque DOS (FREEDOS) con software libre

Lunes, 27 de Febrero de 2012 Gaspar Fernández Sin comentarios

dos
¿Echas de menos tener un sistema MS-DOS? Si eres de los que ya llevas tiempo en el mundo de la informática, esta pantalla de arriba te resultará familiar. Aquel modo texto a 80×25, clásica que podíamos ver en los ordenadores antiguos. Y es que, a veces, puede ser muy útil disponer de un sistema de estos, ya sea para una máquina virtual, o para nuestro ordenador, donde podemos ejecutar las instrucciones que nos vengan en gana sin preocuparnos de que al sistema operativo le gusten o no, para investigar, para revivir viejos tiempos con un antiguo juego, o analizar un programa que sólo funciona en ese sistema, que aún los hay, y debemos portar la información a programas más nuevos. Casi siempre por necesidad, porque donde se ponga “ls” que se quite “dir” :)

Esto lo podemos hacer de dos formas distintas, con makebootfat, nativo para GNU/Linux, o emulando FreeDOS y utilizando sus herramientas (elegir sólo un método):

Método nativo para GNU/Linux

Lo primero que tenemos que hacer es instalar makebootfat y syslinux. En una distribución tipo Debian/Ubuntu/Linux Mint podemos hacer lo siguiente:

$ sudo apt-get install makebootfat syslinux

Una vez tenemos instalados los paquetes, después de asegurarnos de que el pendrive (unidad USB), no tiene nada importante, debemos formatearlo. Usaremos el sistema de archivos FAT16, por lo que el tamaño máximo de la unidad será de 2Gb. Si la unidad es pequeña (menos de 2Gb, como hemos visto antes), habrá que cambiar el tipo de partición solamente), si la unidad es más grande (debemos eliminar la partición existente, ya que supongo que tu pendrive es sólo una unidad, y luego crear una partición pequeña).

Debemos sustituir la sdX por el dispositivo de nuestra unidad USB. Podemos verlo haciendo:

$ dmesg | tail

nada más enchufar la unidad. Luego hacemos:

$ sudo fdisk /dev/sdX

Lo primero será eliminar la partición (sólo si tenemos un pendrive de más de 2Gb), lo hacemos pulsando d [INTRO]

Luego creamos una nueva partición (n [INTRO]):

  • Lo primero que nos pide es si será (p) principal o (e) extendida, elegimos princpal
  • Lo siguiente es el número de la partición, elegimos el 1
  • Luego dónde empieza (damos a enter, ponemos el valor por defecto)
  • Lo siguiente el tamaño. Escribiremos +100M para darle 100Mb a la unidad, podemos darle hasta 2Gb

Lo siguiente es elegir el tipo de partición, pulsamos la letra t [INTRO] y luego elegimos el tipo 6 (FAT16), podemos ver con L un listado de tipos de partición.

Tras todo esto, escribimos los cambios con w [INTRO]

Ya tenemos una unidad FAT16 en nuestro pendrive, ahora la formateamos:

Tenemos que formatear sdX1 (X depende del dispositivo donde nuestro sistema lo detecte)

$ sudo mkfs.vfat /dev/sdX1

Ahora debemos bajar el siguiente archivo:
kernels.zip, lo grabamos en /home/usuario/trabajo/ .
Ahora vamos a esta página, y descargamos la imagen de un disquette de arranque de FreeDOS, por ejemplo el disquette de 2.88Mb, que es el que trae algunos comandos. Lo copiamos también en /home/usuario/trabajo/
Y desde ahí:

$ unzip kernels.zip # Descomprimimos el archivo
$ mkdir pendrive # Creamos una nueva carpeta
$ cp source/ukernel/boot/fat*.bin . # Copiamos los kernels en el directorio de trabajo
$ cp /usr/lib/syslinux/mbr.bin . # Copiamos la imagen del mbr en el directorio de trabajo
$ gunzip FDSTD.288.gz # Descomprimimos la imagen de disco
$ sudo mkdir /mnt/floppy # Creamos un punto de montaje para el disquette
$ sudo mount -t vfat -o loop FDSTD.288 /mnt/floppy # Montamos el disquette
$ cp -r /mnt/floppy/* pendrive/ # Copiamos todos los archivos del disquette al directorio de nuestro pendrive
$ sudo umount /mnt/floppy # Desmontamos el disquette

Ya lo tenemos todo listo, sólo falta crear el disco de arranque, para ello ejecutamos:

$ sudo makebootfat -o /dev/sdX -E 255 -1 fat12.bin -2 fat16.bin -3 fat32lba.bin -m mbr.bin pendrive

Esto escribirá en el pendrive /dev/sdX (sin el 1):

  • -E 255 detecta la unidad BIOS, FAT12 y FAT16 requieren poner el valor correcto para poder arrancar, 255 autodetecta
  • -1, -2, -3 son los kernels de fat12, fat16 y fat32
  • -m, define la imagen del mbr
  • pendrive, copia todos estos archivos

Ya podemos retirar el pendrive para usarlo y arrancar con él.

Emulando FreeDOS

Lo primero es decargar un disquette de arranque de Freedos desde aquí, y descargamos la imagen de un disquette de arranque de FreeDOS, por ejemplo el disquette de 2.88Mb, que trae más cosas. (Ver en la explicación de arriba cómo descomprimir la imagen).

Luego instalaremos qemu. Desde Debian/Ubuntu/Mint:

$ sudo apt-get install qemu

Ahora arrancaremos qemu para emular FreeDOS utilizando como disco duro el pendrive (si está vacío mejor):

$ qemu -hda /dev/sdX -drive file=FDSTD.288,if=floppy

Esto arrancará en una ventana FreeDOS desde la imagen de disquette, lo que tenemos que hacer es utilizar fdisk (como el de MS-DOS para eliminar la partición existente y crear otra nueva), format para formatear el pendrive, en este caso podemos hacer FORMAT C: sin miedo, ya que el disco duro es el pendrive, y luego desde A: hacer “sys C:” para copiar el sistema base al disco duro. Es recomendable copiar luego con copy todos los archivos del disquette.

Una vez hecho esto, podemos cerrar qemu, sacar el pendrive y utilizarlo

Entrada automática en LMDE con GDM3

Viernes, 24 de Febrero de 2012 Gaspar Fernández Sin comentarios

El paquete gdm para LMDE suele traernos a todos por la calle de la amargura, y es que en ocasiones viene con gdm-setup, y en cuanto se actualiza, ya no trae este pequeño programa.

Aunque la configuración de gdm no es nada del otro mundo, se agradece el entorno gráfico, aunque sólo sea para activar el autologin. Aunque puede ser un riesgo para la seguridad de nuestro ordenador, cuando instalamos un sistema para alguien que no se quiere complicar mucho la vida, es conveniente ofrecerle la opción de entrar automáticamente en su sesión.

Para ello tenemos que editar /etc/gdm3/daemon.conf (como root):

$ sudo nano /etc/gdm3/daemon.conf

Y en la sección [daemon] debemos incluir:

AutomaticLoginEnable=true
AutomaticLogin=usuario

(Control+X, Sí, Intro <- Para salir y guardar cambios en nano)
Donde usuario es el nombre de usuario que queremos que se identifique automáticamente.

Categories: Linux Tags: , , , , , , ,

Navegando a través de un tunel SSH

Miércoles, 22 de Febrero de 2012 Gaspar Fernández 2 comentarios

blogtunel

En ocasiones, si queremos navegar de una forma algo más anónima y privada, en el lugar que nos encontramos no tenemos acceso a determinados servicios, o simplemente queremos usar una conexión diferente a la red, podemos intentar esto.
Podemos navegar desde cualquier ordenador que disponga de un servidor SSH, por ejemplo un servidor que tengamos contratado (Dreamhost ofrece además de hosting SSH. Podéis usar el código DFIFTYHOST para tener casi un 50% de descuento el primer año). Para llevar esto a cabo, basta con ejecutar el siguiente comando en la máquina local (no el servidor):

$ ssh -D 8080 usuario@servidor.ext

Donde 8080 será el puerto al que debemos mandar las peticiones (en realidad es el puerto del proxy), y lo demás son los datos del servidor al que nos conectamos. Con esto sólo podemos hacer el tunel para conexiones locales, es decir, sólo podremos utilizarlo en nuestra máquina.

Imagina ahora que queremos compartir la conexión de ese túnel con otros ordenadores, en caso de encontrarte, por poner un ejemplo absurdo, en la sala de ordenadores de la facultad, y un profesor te mande programar un juego tipo arkanoid, pero la página con la documentación la encuentras en un archivo llamado arkanoid.html; el proxy de la facultad bloquea las páginas con ese nombre y por tanto no se puede leer la documentación (era un caso real, en el que hubiera deseado poder hacer esto). En este momento, al encontrarte con varios amigos en la biblioteca y querer acceder todos al mismo recurso, podemos hacer que uno de ellos haga el túnel y comparta el proxy con los demás. Si por ejemplo la IP dentro de la red local (no con la que se conecta a Internet) es 192.168.1.8 , debería hacer:

$ ssh -D 192.168.1.8:8080 usuario@servidor.ext

Con esto, asociamos el puerto a la IP de la red local y no a localhost.

Luego en el navegador debemos configurar la forma en la que conectamos, debemos elegir configuración manual del proxy, y en la casilla de servidor Socks (versión 5) poner la IP: 192.168.1.8 (o localhost si cogemos la primera opción), y en el puerto 8080. En Firefox encontramos esa opción en Editar (Herramientas en Windows) / Preferencias / Avanzado / Red / Configuración

Por supuesto podemos elegir el número de puerto que queramos, siempre que sea mayor a 1024 (para hacerlo como usuario) y no haya nada corriendo en esos puertos.

Para Windows, podemos usar Putty.

Foto: marru-birra (Flickr) Con licencia CC-by-nc a 22/02/2012.

Estadísticas de directorios en PHP

Miércoles, 15 de Febrero de 2012 Gaspar Fernández Sin comentarios

A veces, tenemos la necesidad de generar una estadística básica de algún subdirectorio de nuestras aplicaciones. Por ejemplo, para ver cuánto tenemos ocupado en caché, y ver si ésta se está regenerando bien (es sólo un ejemplo), puede que tengamos un directorio donde alojemos los archivos que suben nuestros usuarios y queramos ver si crece o no en el tiempo.

Este par de funciones pueden resultar útiles. Aún se pueden optimizar un poco, pero la idea aquí está. Es un conteo recursivo de los archivos de nuestros directorios en PHP, que es capaz de calcular:

  • ¿Cuántos archivos hay en total?
  • ¿Cuántos subdirectorios
  • El archivo más nuevo
  • El archivo más viejo
  • El subdirectorio con más archivos
  • El subdirectorio con menos archivos

y que podemos extender con algún que otro criterio que se nos ocurra.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
<?php
  /**
   ******************************************************************
   * @brief Fusiona estadísticas de directorios (ver getFolderStats())
   *
   * @param $s1     Es la colección de estadísticas 1 (la salida irá aquí)
   * @param $s2     Es la colección de estadísticas 2
   *
   * @return $s1    Revisada
   *
   ******************************************************************/

function mergeFolderStats(&$s1, $s2)
{
  $s1['size']      +=$s2['size'];     // Los tamaños totales los sumamos
  $s1['files']     +=$s2['files'];    // Los números de archivo también se suman
  $s1['subfolders']+=$s2['subfolders']; // Los números de directorios también se suman

  if ($s2['maxFilesFolder'])
    {
      if ((!$s1['maxFilesFolder']) || ($s2['maxFilesFolder'][1]>$s1['maxFilesFolder'][1]))
    $s1['maxFilesFolder']=$s2['maxFilesFolder'];
    }

  if ($s2['minFilesFolder'])
    {
      if ((!$s1['minFilesFolder']) || ($s2['minFilesFolder'][1]<$s1['minFilesFolder'][1]) )
    $s1['minFilesFolder']=$s2['minFilesFolder'];
    }

  if ($s2['newestFile'])
    {
      if ((!$s1['newestFile']) || ($s2['newestFile'][1]>$s1['newestFile'][1]))
    $s1['newestFile']=$s2['newestFile'];
    }

  if ($s2['oldestFile'])
    {
      if ((!$s1['oldestFile']) || ($s2['oldestFile'][1]<$s1['oldestFile'][1]))
    $s1['oldestFile']=$s2['oldestFile'];
    }

  return $s1;
}

/**
 ******************************************************************
 * @brief Obtiene estadísticas sobre un directorio
 *
 * @param $folder    Directorio a consultar
 *
 * @return Array con estadísticas: array('size'           => X,
 *                                       'files'          => X,
 *                                       'subfolders'     => X,
 *                                       'maxFilesFolder' => array (X, num, size), // Carpeta con más archivos y número de archivos y tamaño
 *                                       'minFilesFolder' => array (X, num, size), // Carpeta con menos archivos y número de archivos y tamaño
 *                                       'oldestFile'     => array (name, date),   // Archivo más viejo y fecha
 *                                       'newestFile'   => array (name, date),   // Archivo más nuevo y fecha
 *                                       )
 *
 ******************************************************************/

function getFolderStats($folder)
{
  $res=array('size'           => 0,
         'files'          => 0,
         'subfolders'     => 0,
         'oldestFile'     => false,
         'newestFile'   => false,
         'maxFilesFolder' => false,
         'minFilesFolder' => false,
         );
// Pone una barra al final
  if ($folder[strlen($folder)-1]!='/')
    $folder.='/';

  $d = dir($folder);
  $files=0;
  $size=0;
  while ($file=$d->read())
    {
      if ( ($file!='.') && ($file!='..') )
    {
      if (is_dir($folder.$file))
        {
          $tmp = getFolderStats($folder.$file);
          mergeFolderStats($res, $tmp);
          $res['subfolders']++;
        }
      else
        {
          $files++;
          $size+=filesize($folder.$file);
          $filemtime=filemtime($folder.$file);
          $oldest=(isset($res['oldestFile'][1]))?$res['oldestFile'][1]:0;
          $newest=(isset($res['newestFile'][1]))?$res['newestFile'][1]:0;

          if ( (!$res['oldestFile']) || ($filemtime<$oldest) )
        $res['oldestFile']= array($folder.$file, $filemtime);
          if ( (!$res['newestFile']) || ($filemtime>$newest) )
        {
          $res['newestFile']= array($folder.$file, $filemtime);
        }
        }
    }
    }

  $res['files']+=$files;
  $res['size']+=$size;
  if ( (!$res['maxFilesFolder']) || ($files>$res['maxFilesFolder'][1] ) )
    $res['maxFilesFolder']=array($folder, $files, $size);

  if ( (!$res['minFilesFolder']) || ($files<$res['minFilesFolder'][1] ) )
    $res['minFilesFolder']=array($folder, $files, $size);

  return $res;
}

print_r(getFolderStats('.'))
?>

Directamente podemos analizar el array que devuelve la función getFolderStats()

Menos tiempo para actualizar

Lunes, 13 de Febrero de 2012 Gaspar Fernández 2 comentarios

A partir de ahora voy a tener mucho menos tiempo para actualizar el blog, no quiero dejar de publicar, sólo bajará la frecuencia de las publicaciones, ya que no puedo mantener el ritmo. A pesar de que tengo muchos artículos en el tintero, voy a tener que retrasarlos aún más por motivos personales y laborales. Seguiré por aquí, además, tenéis la página de Facebook donde voy publicando las novedades del blog, podéis seguirme en Twitter (@blakeyed), aunque sea un nombre raro, pero soy yo.

Generar texto e implantarlo en una imagen desde PHP

Viernes, 10 de Febrero de 2012 Gaspar Fernández 1 comentario

En ocasiones, se puede presentar la necesidad de introducir en nuestros proyectos una imagen cuyo contenido sea un texto, y sobre todo necesitamos integrarlo dentro de nuestro contenido, intentando que no se note que es una imagen, a no se que seleccionen el contenido para copiarlo.

Una de las principales utilidades de esto es evitar el SPAM al escribir nuestra dirección de e-mail en una web. Muchos clientes prefieren enviar un e-mail en lugar de utilizar un formulario de contacto y tenemos que satisfacerles, sin arriesgar la seguridad de nuestro sistema, en el sentido de que hay cientos de motores que se dedican a rastrear webs en busca de direcciones de e-mail (lo cual es muy sencillo de hacer con expresiones regulares, por ejemplo).

Tenemos que estudiar bien cómo hacemos el script, ya que la entrada de datos es esencial. Sería improductivo hacer un script cuya llamada fuera:

1
<img src="scriptGenerador.php?texto=midireccion@miservidor.com" />

Ya que un motor se enteraría de que eso es una dirección de correo igualmente. Por lo que yo sugiero algunas opciones:

  • Para simplificar, podemos codificar el texto, por ejemplo, en base 64, el e-mail anterior quedaría así:bWlkaXJlY2Npb25AbWlzZXJ2aWRvci5jb20 y sería más complicado de detectar, aunque es nuestra responsabilidad hacer la conversión. Además, si en cualquier momento queremos identificar el texto que pusimos, en cierto punto del código debemos hacer la conversión inversa. Por otra parte, aunque es difícil que algún motor se dedique a convertir el texto en base64 a binario de nuevo, es posible.
  • Otra posibilidad es, si sólo vamos a escribir un sólo texto de esta forma, implantarlo dentro del archivo php que genera la imagen, como una variable del propio código, así no debemos escribir nada cuando llamemos al script. Si tenemos que cambiar el texto, basta con editar el script
  • Si, por el contrario, vamos a escribir varios mensajes, podemos asignar una clave a cada uno, por ejemplo, un número o una cadena de texto corta, y en nuestro script hacer corresponder ese número con el texto en cuestión.

Aquí vamos a hacer un ejemplo de la tercera opción. Aunque podemos extender el ejemplo usando bases de datos (si tenemos que introducir muchos mensajes, o muchas direcciones de e-mail diferentes), aquí vamos a crear un array en PHP para hacer corresponder la clave introducida con el valor (el texto que de verdad escribimos).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
<?php
  // Con esta función calculamos la anchura, altura del texto y dónde está la baseline de nuestro texto
  // con el tipo de letra seleccionado.
function dimensions($ldef, $texto)
{
  // Calcular el ancho
  $box=imagettfbbox ($ldef['size'], 0, $ldef['font'], $texto);
  $width = abs(abs($box[2]) - abs($box[0]));

  // Calcular el alto y la baseline
  $box=imagettfbbox ($ldef['size'], 0, $ldef['font'], 'ILyjgq'); // Tiene caracteres que no terminan en la baseline
  $height = abs($box[7] - $box[1]);
 
  $baseline = abs($box[5]);

  return array($width, $height, $baseline);
}

// Definimos un array con los posibles textos que vamos a presentar
$textArray=array("ejemplo", "de un fragmento de texto", 'gaspy@mi_servidor.com');


// Definimos el tipo de letra y el tamaño
$letra = array ('font'  => './LinLibertine_Bd.ttf',
        'size'  => 12,
        'color' => array(0,0,0),
        );

// Definimos el texto a presentar
$textID  = (isset($_GET['texto']))?$_GET['texto']:0;
$text = $textArray[$textID];

header('Content-Type: image/png');

// Creamos la imagen, calculando primero sus dimensiones dependiendo del tamaño del texto
$box_size=dimensions($letra, $text);
$im = imagecreatetruecolor($box_size[0], $box_size[1]);

// Creamos dos colores, y definimos el color que actuará como transparente
$background = imagecolorallocate($im, 255, 255, 255);
$fontColor  = imagecolorallocate($im, $letra['color'][0], $letra['color'][1], $letra['color'][2]);
imagecolortransparent($im, $background);

// Ponemos el fondo de la imagen transparente
imagefilledrectangle($im, 0, 0, $box_size[0], $box_size[1], $background);


// Creamos el texto
imagettftext($im, $letra['size'], 0, 0, $box_size[2], $fontColor, $letra['font'], $text);

// Generamos la salida
imagepng($im);
imagedestroy($im);
?>

Para el ejemplo he utilizado la fuente Linux Libertine Bold cuyo fichero ttf es LinLibertine_Bd.ttf, en realidad podemos utilizar cualquier fuente de la que dispongamos el fichero TTF.
El script que vemos, si lo llamamos desde el navegador con el parámetro textID=1 mostrará una imagen con el texto “de un fragmento de texto” dibujado dentro con el tipo de letra especificado anteriormente.

Ahora hacemos el siguiente archivo html:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>Ejemplo de texto</title>
    <style text="text/css">
      <!--
     @font-face {
     font-family: "Linux Libertine";
     src: url(LinLibertine_Bd.ttf);
     }
     body{
     background: #eee;
     font: 12pt Linux Libertine,sans;
     }

     .texto{
     vertical-align:bottom;
     margin: 0;
     padding: 0;
     }
    -->
    </style>
    <meta name="author" content="Gaspar Fernández">
  </head>

  <body>
    <h1>Ejemplo de texto</h1>

    Esto es un ejemplo de inserción <img src="texto.php?textID=1" class="texto"/> incluyendo una imagen en PHP
   
    <hr>
    <address>
      <a href="http://totaki.com/poesiabinaria">Gaspar Fernández</a>,
    </address>
  </body>
</html>

Con la parte CSS:

1
2
3
4
@font-face {
     font-family: "Linux Libertine";
     src: url(LinLibertine_Bd.ttf);
     }

Estamos definiendo el fichero que se descargará para visualizar el tipo de letra, así nos aseguramos de que sea el mismo tipo de letra (el de la imagen y el de nuestro texto). El resultado debería ser algo parecido a esto:
textexample

Visita otras webs de la red