Poesía binaria

A mí me gusta tener el control sobre la frecuencia de la CPU, ya sea porque muchas veces no estoy haciendo nada y lo quiero dejar al mínimo de velocidad para que se caliente menos, o porque algunas veces necesito un poco más de potencia, y otras veces lo dejo a su aire para que cambie de frecuencia solo.

El script se basa en llamadas a cpufreq-set de cpufrequtils, aunque la llamada tiene que ser con permisos de root, por lo que conviene ver antes este artículo, de todas formas, todo esto se hará paso a paso.

Requisitos

• CPU soportada por cpufreq
• Sudo / Gksudo
• Cpufrequtils
• Zenity
• Xosd

Editando sudoers

Este script lo ejecutaremos desde nuestro usuario, pero la llamada a cpufreq-set necesita permisos especiales, por lo tanto, lo haremos con sudo. Si saltamos este paso, nos preguntará la contraseña para ejecutar los comandos, pero si no queremos que nos pregunte, debemos hacer esto.

Lo primero es ejecutar:

$ sudo visudo

Y en el archivo, debajo de la última línea sin comentario, escribimos:

mi_usuario   ALL= NOPASSWD : /usr/bin/cpufreq-set

Sustituyendo mi_usuario por el usuario que va a ejecutar el script. Si tenéis varios usuarios podéis añadirlos uno por línea, o ver el artículo mencionado antes para más opciones.

El script

Notas del script

• He optado por filtrar el resultado de cpufreq-info -g y cambiar las palabras, me gusta filtrar todos los datos que me llegan.
• Añadí la primera opción para no hacer nada, porque me resultó más cómoda cuando quiero cancelar el menú
• zenity nos devuelve dos cosas: El resultado de la ejecución y el valor elegido, por tanto el primer valor lo podemos averiguar del script, el segundo lo devuelve como texto, por eso lo almacenamos en un archivo temporal
• Para cambiar el tipo de letra, tenemos que ejecutar xfontsel, desde ese programa, elegir el tipo de letra y copiar el texto que nos devuelve a la variable XOSD_FONT

Por último…

Para disfrutar de este script, lo bueno es asociarlo a una tecla, por ejemplo yo lo tengo en Meta+F3 y con ello se puede cambiar la frecuencia rápidamente.

Estos días, aunque inactivos, he seleccionado algunos enlaces que me han parecido interesantes:

• Hashtables vs. Arrays. Un enlace donde vemos la diferencia entre estos dos conceptos que seguro que estamos acostumbrados a utilizar. Vía @jmaguilar
• Citas matemáticas en la obra de Borges. Vía @Jose_A_Alonso
• Renombrar archivos masivamente en Linux. Via @Felinfo
• Ejemplos de crontab. Ejemplos para la utilización de crontab. Muy detallado y con información interesante. Vía @Geek_Mate
• Linux 3.2 disponible! Y yo todavía con la 2.6.39, va tocando actualizar
• Granada, capital internacional del Software Libre. Lo cancelarán esta vez? A lo mejor luego nos presentamos en la puerta y nos encontramos con que no hay nada. Ya veremos.

Cuando estamos utilizando la terminal y queremos ejecutar comandos con privilegios de superusuario (root), los usuarios de Ubuntu o Mint entre otras estarán acostumbrados a pedir las cosas con sudo.

Cuando estamos delante, es muy cómodo hacerlo, aunque tengamos que introducir la contraseña nada más ejecutar el comando (en muchos sistemas, cuando la has introducido una vez, te deja ejecutar comandos como root durante un rato sin introducir contraseña).

El problema está cuando creamos scripts y automatizamos tareas que requieren en una pequeña parte privilegios de root. Por un lado, podemos ejecutar los scripts como root y olvidarnos, pero es algo muy inseguro, lo suyo es que ejecutemos el comando con sudo y no nos pregunte por contraseña.

Tenemos que tener cuidado con esto, ya que se permitirán algunos comandos de root sin contraseña, y puede que muchos de ellos sean dañinos para el sistema, eso es nuestra responsabilidad.

Un comando, para un sólo usuario

Para los ejemplos, vamos a ejecutar como root el comando service (para arrancar o parar servicios de sistema). De este modo no tendremos que introducir la contraseña cuando queramos hacerlo.

Para ello vamos a editar el archivo sudoers. Y con ese fin debemos ejecutar el comando visudo como root:

$ sudo visudo

Se abrirá un editor (vi, por ejemplo) con el que podremos editar los contenidos de ese fichero de forma segura. Allí debemos añadir la siguiente línea:

Si os fijáis, es la palabra clave NOPASSWD la que provoca que no se pregunte contraseña cuando se invoca el comando.

Podemos hacerlo al final del fichero. En este caso daremos permiso a usuario para que ejecute:

$ sudo service xxxxx xxxxxx

por ejemplo:

$ sudo service apache restart

las veces que quiera sin pedir contraseña.

Un comando, un grupo

Una opción, es que si el ordenador lo utilizan varios usuarios, es permitir a un grupo entero la ejecución de comandos de esta forma, para ello, primero creamos el grupo (el grupo se llamará administradores)

$ sudo groupadd administradores

Ahora introucimos usuarios en el grupo:

$ sudo gpasswd -a usuario1 administradores
$ sudo gpasswd -a usuario2 administradores
$ sudo gpasswd -a usuario3 administradores

o también

$ sudo gpasswd -M usuario1,usuario2,usuario3 administradores

Ahora introducimos lo siguiente en sudoers (con el comando visudo, como antes):

Muchos comandos, muchos usuarios

También puede ser que tengamos muchos comandos para permitir a muchos usuarios y, aunque podemos introducir 200 líneas en sudoers, a lo mejor es algo complicado de administrar en el caso de que queramos quitar un comando, ya que tendremos que modificar varias líneaas, o queramos quitar a un usuario. Para eso utilizaremos los alias de sudoers.

Podemos utilizr comandos especiales dentro de sudoers que nos permitirán crear un Alias donde introducir una enumeración de datos (por ejemplo usuarios y comandos):

• User_Alias NOMBRE_DE_LA_COLECCION = usuario1, usuario2, usuario3, etc : Configurará una colección de usuarios llamada NOMBRE_DE_LA_COLECCION
• Cmnd_Alias COLECCION_COMANDOS = comando1, comando2, comando3, etc : Configura una colección de comandos llamada COLECCION_COMANDOS

Luego estos alias podemos utilizarlos en la línea de sudoers que activa la utilización sin contraseña:

Algo que me dejé en el tintero

En esta guía no quise introducir el host (es ese ALL) que nos queda colgado, y es que podemos limitar el uso de sudo a un host determinado. Por ejemplo, permitir esa ejecución cuando se ejecuten en modo local o desde un determinado nodo remoto (para que no desde todos lados se pueda hacer). Aquí podemos especificar tanto nombres de host como direcciones IP.

Foto: xkcd

Estos son los enlaces que he visto interesantes durante la semana:

• Arduino IDE 1.0 disponible: muchos de los que programamos en esta plataforma lo agradecerán. Sobre todo porque en la librería Ethernet han implementado DHCP, lo cual es muy interesante. Aunque el entorno, como IDE, le siguen faltando muchas opciones.
• Uno de los actos de presentación del Nokia Lumia (Nuevo Teléfono con Windows Phone) era una presentación sobre el edificio en Londres donde trabaja Canonical. Bueno, estos hicieron un contraataque titulado Ubuntu Operation NightLight, no tan grande como podemos esperar, pero ¡ están ahí !
• Impresiones de Linux Mint 12: Lisa: Tengo ganas de probarlo, mientras, vamos a ver qué nos depara esta nueva versión.
• Tipos de gobernadores de las CPUs: Es un tema interesante que muchos lo dejamos tal y como está, pero podemos controlarlo.
• El captcha de Adafruit: Nada, sólo por el Captcha habrá que darle una oportunidad a la tienda. Muy curioso para los que os guste la electrónica. Lo descubrí gracias a @fransolano.
• ¿Cómo funciona el servicio FTP?. Buena explicación de cómo funciona (varias partes)
• Notificaciones de tuenti en Linux: Si eres Linuxero y usas tuenti, te interesa ver esto.

Actualizado a 5 / 12 / 2011 : Añadida la mención a @fransolano en el enlace de Adafruit.

Hablemos de un fenómeno que nos afecta, sobre todo en desarrollos que están en ejecución durante mucho tiempo, pero , y es que, debido a la mala gestión de la memoria podemos llegar a consumir más de lo necesario y podemos volver loco al sistema operativo utilizando la memoria virtual para darnos el espacio que necesitamos.

Los memory leaks son fugas de memoria debidas a que hemos pedido un cierto espacio de memoria durante la ejecución de nuestro programa, la hemos usado y cuando hemos dejado de usarla, no la hemos liberado, por tanto estamos ocupando más de lo que necesitamos y acaparando recursos; un ejemplo de esto son esos procesos o programas que tenemos arrancados durante varios días, y cuanto más tiempo llevan arrancados más memoria ocupan (a veces es necesario, pero otras veces, la mayoría, no).

Antes de iniciarnos en la creación de un programa acerca de lo que no debemos hacer, vamos a hacerlo bien, y echaremos un vistazo a un artículo sobre el Out Of Memory Killer (desconozco si Windows tiene algo parecido, tal vez instalando alguna aplicación), que será una utilidad de nuestro kernel que matará el proceso cuando esté consumiendo mucha memoria, o nos permitirá matarlo fácilmente con las teclas (Alt+SysRq o imprimir pantalla+F). Con unas líneas antes de nuestro programa, nos podemos evitar un disgusto, como puede ser un reinicio de sistema mientras hacemos pruebas, y puede que estemos ejecutando algo útil.

¡Precaución!

Si vemos que nuestro proceso hace que el sistema vaya muy lento, será porque en lugar de utilizar nuestra RAM, estará usando la memoria virtual de forma intensa, esta memoria es mucho más lenta que nuestra RAM, si hemos entendido lo que quiero demostrar, podemos parar el proceso gracias al OOM Killer de antes con Alt+SysRq+F, pero sólo pulsa una vez las teclas, aunque veamos que no nos hace mucho caso, el sistema tarda un tiempo en volver a recolocar toda la información y limpiar la memoria del proceso. Si pulsamos más veces, lo mismo terminamos matando el servidor gráfico o algún proceso importante, y no queremos eso.

Ajustando OOM Killer

Para todo eso, debemos incluir el siguiente código (al final pondré todo el programa, pero primero lo analizamos por separado), el objetivo es escribir el valor 15 sobre el fichero /proc/PID/oom_adj:

Gastando memoria

Para esta parte hay que tener cuidado, ya que depende de la RAM que tengamos cada uno, yo he hecho esto en un equipo con 2GB de RAM, hasta que se ha vuelto extremadamente lento. Aunque el objetivo es que veamos la memoria que está actualmente en consumo. Podemos utilizar el comando free() en paralelo con el programa para ver que cada vez tenemos más memoria consumida, cuando no deberíamos, porque la intuición nos diría que cuando salimos de la función todo lo reservado se libera, pero no es así.
En los sistemas operativos actuales no podremos ponernos a reservar memoria sin control, ya que el SO casi siempre nos la dará (aunque no disponga de ella, dejando el marrón al gestor de memoria del futuro), si de verdad queremos reservar memoria, gastarla y darnos cuenta, debemos utilizar la memoria que reservamos; por ello he optado por rellenar un vector de números. Cuidado con subir mucho más MAX_NEW_ELEMENTS, es más, si tienes poca memoria, te recomiendo bajarla un poco, a la mitad, por ejemplo, en un primer cálculo, sólo contando los elementos del vector (8.000.000 x 8 (long int) = 64Mb), por lo que depende de lo que haya en ejecución, con cuatro llamadas a la función gasta_memoria() habremos gastado 256Mb de memoria.
Para ver lo que vamos gastando, debemos ejecutar en un terminal el programa que voy a mostrar, y en otro terminal ejecutamos free. El programa hará varias paradas pidiendo que pulsemos intro a cada llamada de gasta_memoria() para que podamos ver lo que se ha gastado, después del código veremos la ejecución.

La ejecución será escalonada, es decir, ejecutamos, y antes de pulsar intro ejecutamos free(), así vemos cómo se va gastando la memoria tal y como indica la imagen.

Lo que quiero demostrar es que el puntero al vector v, cada vez que ejecutamos new vector sobre ella, restablece su valor, y por tanto, aunque la memoria asociada a ese vector sigue reservada (y encima tiene 8000000 de elementos), ya no tenemos forma de acceder a ella, ya no sabemos la dirección de memoria con la que accedemos; vamos que el hecho de que no sea accesible no significa que no esté reservada, en uso y molestando, porque el sistema no podrá utilizar esos datos para otras cosas.
En este caso, la solución a este problema habría sido escribir:

al final de la función gasta_memoria(). Aunque en ocasiones esto no es tan fácil de ver.

Cuando el programa se cierra…

Generalmente el sistema operativo, que sí que sabe lo que el proceso ha reservado y consumido, libera la memoria, y a veces puede invertir un rato, aunque a veces no aparezca toda la memoria como libre directamente, al cabo de unos minutos (como mucho) ya estará listo.

Si el sistema no reacciona…

Recuerdo, que si hemos reservado mucha, mucha memoria, el sistema dejará de responder, para ello podemos pulsar Alt+SysRq+F, y el programa morirá rápidamente (pero, pulsad estas teclas, sólo una vez, y esperar).

Foto: tao_zhyn (Flickr) Compartido con CC-by a 26/11/2011

Hace tiempo hablábamos de capturar señales, aunque en ocasiones, es necesario saber quién me envía esa señal, si por ejemplo nos envían un SIGINT o SIGTERM, tal vez queremos saber qué proceso nos quiere muerto y qué usuario lo ha invocado. O tal vez estamos esperando una señal de control (SIGUSR1, por ejemplo) por parte de un proceso cliente específico.

El problema es que por nuestro modo actual de direccionar señales (con signal(señal, funcion)) sólo comunicamos el número de señal que se ha recibido, sin más información.

Para capturar esta información necesitamos utilizar sigaction para establecer la función a la que llamaremos cuando llegue la señal, para utilizarla podemos utilizar el siguiente código:

Como vemos sigaction tiene 3 parámetros:

• La señal que queremos capturar
• Un registro de tipo struct sigaction
• La acción que se ejecutaba antes, por si queremos guardarla para restaurarla más tarde

Dentro del registro, tendremos como valores importantes (struct sigaction act):

• sact.sa_sigaction : que especifica la función que la llamaremos, esta función será del tipo void funcion(int, siginfo_t*, void*), donde el primer int recibirá la señal que nos han enviado (tal y como hacía la función que asignábamos con signal), el segundo parámetro será información asociada a la señal, y la tercera el contexto de ejecución.
• sact.sa_handler : será la función a la que se llama, es la misma que cuando hacemos signal(señal, funcion)
• sact.sa_flags : Es un conjunto de flags, si especificamos SA_SIGINFO, estaremos dando paso a la función especificada por sa_sigaction, si no utilizaremos sa_handler. Aunque esta variable vale para más cosas, para esta práctica nos vale con saber esto. (man sigaction para más info)
• sact.sa_mask

: Nos proporciona una máscara de las señales que serán bloquedas, podemos utilizar sigfillset() para rellenar toda la máscara automáticamente. Si queremos que unas se bloqueen y otras no podemos utilizar sigaddset() y sigdelset()

Ahora bien, la función que se llamará cuando venga una señal tendrá el prototipo que hemos visto antes con tres parámetros: la señal recibida, la información de la señal con un puntero a siginfo_t y el contexto de ejecución, que se pasará con un puntero a void, que por ahora no utilizaremos. La estructura que controla la información de la señal entre otros muchos datos nos facilitará lo siguiente:

• si_pid : PID que nos envía la señal (y esta acción da título al post)
• si_uid : Usuario que ejecuta el proceso que nos manda la señal
• si_errno : Algún error que haya causado la señal
• … para más información, man sigaction

Para preparar la sentencia tendremos que escribir varias líneas definiendo los valores del registro así como la llamada a la función sigaction(), por lo tanto podremos crear una función que tenga los parámetros más comunes a la hora de definir este tipo de acciones, así lo llamamos como a signal():

En esta función es importante poner bien el prototipo de la función como parámetro, eso lo comenté en un post anterior sobre callbacks

Ahora, vamos a dejar el código más bonito, este programa implementará el control de errores y nos permitirá salir cuando recibamos 5 SIGINT (pulsemos 5 veces control+C):

En esta ocasión el servidor LAMP a instalar corresponderá con Linux + Apache + MySQL + PHP, intentaré dejarlo todo funcionando.

Éste es el servidor local que suelo utilizar para mis proyectos web, de todas formas no me quiero meter en necesidades muy avanzadas, ni de seguridad (es un servidor local para hacer pruebas, desarrollar webs, y correr servicios locales; no un servidor de producción), si el servidor está cerrado al exterior, mejor. Esta guía dejará el servidor operativo, lo que hagamos con él, es cosa nuestra.

En este tutorial tocaré los siguientes puntos:

• Instalación de software
• apache2: Could not reliably determine the server’s fully qualified domain name, using 127.0.1.1 for ServerName
• Creando el directorio de trabajo
• Probando el servidor
• Permitir cambiar las opciones de directorios con .htaccess
• Configurar mod-rewrite
• Instalar phpMyAdmin

Instalación de software

En este punto, supongo que tenéis una máquina GNU/Linux instalada, si necesitas ayuda para instalar una distribución, puedes probar con este enlace.
Esta parte, será especial para los derivados de Debian o Ubuntu, ya que el nombre de los paquetes es especial para dicha distribución. Lo instalamos desde terminal:

$ sudo apt-get install libapache2-mod-php5 php5-gd libgd-tools php5-curl php5-mcrypt php-pear mysql-server php-mysql

Con esto se instalarán más paquetes y dependencias que serán necesarios para nuestro servidor, además, cuando se esté instalando el servidor MySQL nos preguntará qué contraseña queremos para root:

No tiene que ser la misma que root de nuestro sistema, será una clave para controlar todas las bases de datos del servidor.

apache2: Could not reliably determine the server’s fully qualified domain name, using 127.0.1.1 for ServerName

Si nada más instalar tu servidor web dice esto, pasar no pasa nada, pero molesta un poco que de un fallo, para ello tenemos que editar /etc/apache2/httpd.conf y escribir lo siguiente:

ServerName localhost

Reiniciamos el servidor y ya está todo correcto:

$ sudo service apache2 restart

Creando el directorio de trabajo

Yo utilizo esto para tener las webs alojadas en /home, ya que lo tengo montado en la partición más grande de mi disco duro. Aquí tenemos varias opciones:

• En el directorio personal de nuestro usuario principal (es rápido y no está mal si sólo nosotros usamos el ordenador). Por ejemplo /home/usuario/proyectos/www/
• Crear un directorio en /home; por ejemplo /home/servidor/www/
  • Tras ello, debemos darle privilegios de escritura al usuario con el que vamos a trabajar.
  • O por el contrario, si trabajarán varios usuarios, podemos crear un grupo (por ejemplo, desarrolloweb), dar privilegios de escritura al grupo y añadir todos los usuarios a ese grupo.
    

    $ sudo groupadd desarrolloweb
    $ sudo mkdir -p /home/servidor/www
    $ sudo chgrp -R desarrolloweb /home/servidor/www
    $ sudo gpasswd -M usuario1,usuario2,usuario3,…,usuarioN desarrolloweb

• Crear un usuario (desarrolloweb) y un grupo (desarrolloweb) y dar privilegios a los usuarios que vayan a acceder como en el apartado anterior.
• Utilizar el mismo usuario con el que se ejecuta apache (apache, httpd, www-data, depende del sistema, podemos mirar el archivo /etc/passwd para ver todos los usuarios). Para ese usuario crear un directorio en /home, asignar el grupo a desarrolloweb e introducir usuarios en ese grupo:
  

  $ sudo mkdir -p /home/servidor/www/
  $ sudo usermod -d /home/servidor/
  $ sudo chown -R www-data:desarrolloweb /home/servidor
  $ sudo gpasswd -M usuario1,usuario2,usuario3,…,usuarioN desarrolloweb

  Este último método puede sernos útil cuando nuestros scripts escriban en archivos dentro de nuestro árbol, siempre que esos directorios tengan a www-data como usuario

• Normalmente, nuestra instalación de apache creará también un grupo llamado www-data (o apache, o httpd, etc), por lo que podemos añadir a todos los usuarios, en lugar de a desarrolloweb a www-data.
• Se nos pueden ocurrir muchas más formas de organizarnos.

Nota: si optamos por alguna configuración de grupo, tenemos que dar permisos 775 a los directorios del servidor. Y cuando queramos que algún archivo sea modificado/creado por el servidor web debemos darle permiso al este servidor. Si los usuarios que pueden acceder pertenecen al mismo grupo que el servidor web (recordad, www-data, httpd, apache…) con dar permiso al grupo basta, si no, tendremos que modificar los permisos del fichero para permitir a otros la escritura (chmod o+w archivo). Ahora un truco, cuando estemos creando archivos desde terminal, con un usuario perteneciente a desarrolloweb podemos hacer lo siguiente:

$ newgrp desarrolloweb
$ umask 0002

Con esto conseguimos que todos los ficheros que creemos en la sesión pertenezcan al grupo desarrolloweb y tengan los permisos 664 (lectura y escritura para propietario y grupo y lectura para otros) y los directorios, 775 (lectura, escritura y ejecución (o entrada) para propietario y grupo, lectura y entrada para otros).

Una vez tenemos el directorio de trabajo creado, podemos crear enlaces a el dentro de los directorios personales de los usuarios que van a trabajar para que tengan un acceso más rápido, por ejemplo, para mi usuario, crearé un enlace a /home/gaspy/proyectos/www:

$ ln -s /home/servidorweb/www /home/gaspy/proyectos/www

Cambiando el directorio de trabajo en el servidor web

Una vez tenemos nuestro directorio de trabajo, tenemos que decirle a Apache que lo use, por defecto utilizará /var/www ; queremos utilizar nuestro directorio de trabajo. Los valores por defecto no los tocaremos, por si algún día queremos utilizarlos como plantilla ( y por si alguna actualización los re-escribe). El método que muestro es más o menos general, aunque tal vez dependiendo de la distribución varíe algún nombre de archivo:

$ cd /etc/apache2
$ sudo a2dissite 000-default

La utilidad a2dissite elimina el enlace 000-default (dentro de /etc/apache2/sites-enabled/) a sites-available/default, por lo que copiaremos ese último y crearemos otro enlace en sites-enabled para que sea nuestro sitio principal (ayudándonos de la utilidad a2ensite). Tanto a2dissite como a2ensite son dos scripts que nos facilitan un poco la vida a la hora de manejar esos enlaces.

$ sudo cp sites-available/default sites-available/trabajo
$ sudo a2ensite trabajo
$ sudo nano sites-available/trabajo

Ahora debemos modificar algunas líneas de ese documento relativas a la ruta de trabajo, sustituyendo donde ponga /var/www por /home/servidorweb/www dejándolas así:

DocumentRoot /home/servidorweb/www
<Directory /home/servidorweb/www/>
Options Indexes FollowSymLinks MultiViews
AllowOverride None
Order allow,deny
allow from all
</Directory>

Aunque más adelante modificaremos alguna línea más en este archivo (podemos hacerlo todo seguido, pero para este artículo prefiero indicarlo paso a paso), salvamos y salimos (en nano, Control-X).

Probando el servidor

Vamos a introducir un archivo index.php en /home/servidorweb/www/ para que se vea cuando accedemos al raíz de nuestro servidor. Sólo por hacer la prueba, puedes saltar este paso si quieres. El archivo contendrá (debéis sustituir UTF-8 por la codificación con la que creéis el archivo, y la zona horaria Europe/Madrid por la zona horaria donde estéis):

Para ver el resultado, si estáis en el mismo ordenador donde habéis instalado el servidor, acceded a http://localhost/ , si no, acceded a través de la IP de la máquina servidor, debería dar un mensaje como este:

Permitir cambiar las opciones de directorios con .htaccess

Es muy útil si vamos a utilizar mod_rewrite, contraseñas en directorios o modificar filtros, documentos de error, etc. aunque por defecto viene deshabilitada cualquier configuración que podamos hacer desde aquí. Para ello, debemos abrir el mismo archivo de antes /etc/apache2/sites-available/trabajo para edición (igual que antes, y cambiar la directiva AllowOverride de None a All (dentro de Directory /home/servidorweb/www), al final se quedaría así:

<Directory /home/servidorweb/www/>
Options Indexes FollowSymLinks MultiViews
AllowOverride All
Order allow,deny
allow from all
</Directory>

Seguramente haya otra etiqueta <Directory>, en este caso ““, con otra directiva AllowOverride que podemos dejar a None, esto es para cuando haya un archivo .htaccess en un nivel superior a nuestro directorio de trabajo, por ejemplo en /home/servidorweb; si ponemos la directiva a “All”, sí que se procesará ese archivo, aunque en este caso, si va a ser una configuración común a todo el servidor (ya que afectará a todos los subdirectorios que tengamos exportados) podemos ponerla en /etc/apache2/sites-available/trabajo.

Configurar mod-rewrite

$ sudo a2enmod rewrite

Ejecuta un script que habilita el módulo especificado. Para ver un listado de los módulos especificados podemos mirar en el directorio /etc/apache2/mods-available ; este script hará un enlace de un módulo en /etc/apache2/mods-enabled. Desde aquí podemos activar el módulo que queramos. Para desactivar ejecutamos como root a2dismod. De forma muy parecida a como hicimos con el sitio web.

Instalamos phpmyadmin

Podemos instalarlo automáticamente con nuestra distribución, por ejemplo en Debian/Ubuntu y derivados:

$ sudo apt-get install phpmyadmin

Nos pedirá la contraseña de la base de datos y listo.

Personalmente, no me gusta que mi distribución haga ciertos cambios y este es uno de ellos, me gusta hacer la instalación de phpMyAdmin de forma manual, así como la de ciertos scripts y utilidades del servidor… en ocasiones edito algún archivo de configuración por nfs y tengo un acceso directo a ellos, además, me gusta complicarme un poco la vida

Lo primero es descargarlo, de la web oficial. La última versión hoy es la 3.4.5 (bonito número) por tanto lo instalaremos. Primero creo un directorio para las utilidades de mi servidor local, y tras ello descomprimo ahí phpmyadmin; el archivo comprimido de phpMyAdmin se encuentra en /home/servidorweb/targz:

$ cd /home/servidorweb
$ mkdir util
$ cd util
$ tar xvzf ../targz/phpMyAdmin-3.4.5-all-languages.tar.gz

Se descomprimirá todo en el directorio phpMyAdmin-3.4.5-all-languages/ que renombraremos a pma (PhpMyAdmin), aunque el nombre es lo de menos, sólo queremos un acceso fácil:

$ mv phpMyAdmin-3.4.5-all-languages pma

A continuación vamos a dar acceso al servidor web al directorio /home/servidorweb/util/ ya que está fuera de /home/servidorweb/www/ que es el que tiene acceso desde web. Para ello creamos un nuevo archivo en /etc/apache2/conf.d/ llamado, por ejemplo utilidades.conf, y contendrá lo siguiente:

Alias /util/ “/home/servidorweb/util/”

<Directory “/home/servidorweb/util”>
AllowOverride None
Order allow,deny
Allow from all
</Directory>

Para ver los cambios recargamos la configuración del servidor:

$ sudo service apache2 reload

En este punto, si accedemos desde el navegador a nuestro servidor en la ruta donde hemos vinculado phpmyadmin, por ejemplo http://localhost/util/pma/ veremos:

Ya tenemos phpMyAdmin funcionando, aunque falta un pequeño detalle (no nos impide en cierto modo trabajar, pero ya que lo instalamos lo instalamos bien). phpMyAdmin tiene funciones avanzadas como la creación de PDFs, diseñador de bases de datos, historial y algunas cosas más y para ello necesita que creemos una base de datos e instalemos algunas tablas en ella, para ello, primero crearemos el usuario pma en nuestra base de datos, lo haremos desde el comando mysql:

$ mysql -u root -p

Enter password: [introducimos la contraseña, la primera que introdujimos al principio del tutorial]
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 104

mysql> CREATE USER ‘pma’@'localhost’ IDENTIFIED BY ‘axK12jMf’
Query OK, 0 rows affected (0.03 sec)
mysql> exit

La contraseña podemos generarla con pwgen, cuando terminemos de configurar esto, no la necesitaremos para nada.
Ahora cargamos en la base de datos las tablas de phpMyAdmin (las encontramos dentro del directorio de instalación):

$ mysql -u root -p < /home/servidorweb/util/pma/scripts/create-tables.sql

Ahora damos privilegios al usuario pma para la base de datos phpmyadmin:

$ mysql -u root -p
mysql> GRANT SELECT, INSERT, DELETE, UPDATE ON `phpmyadmin`.* TO ‘pma’@'localhost’;
mysql> exit

Para terminar de configurar debemos crear el fichero config.inc.php, aunque phpMyAdmin trae un fichero llamado config.sample.inc.php que nos puede servir de plantilla. Para ello:

$ cd /home/servidorweb/util/pma/
$ cp config.sample.inc.php config.inc.php

Y editamos el archivo. Podemos ir a http://localhost/util/pma/setup/ y hacer algunos ajustes, luego podemos copiar el archivo generado en config.inc.php o, de manera manual, editando el archivo, para ello, lo primero que debemos rellenar es la línea de blowfish_secret, será una frase secreta para la autentificación de tipo cookie de la aplicación; podemos poner una frase cualquiera, lo primero que se nos ocurra, el caso es que sea secreto, podemos generarlo si queremos con:

$ pwgen -yns 46 1

El tema es que se quede algo como:

Ahora, debemos rellenar las opciones del servidor MySQL, para ello (podemos copiar y pegar, aunque viene comentado en el archivo):

Arriba del todo, en la segunda línea, debemos cambiar el valor por la clave que le asignamos al usuario pma.
Por otra parte, si utilizamos la base de datos adicional (phpmyadmin), necesitamos utilizar la extensión mysqli de php en lugar de mysql (puede haber problemas si no lo hacemos):

Si queremos, podemos incluir servidores a la lista de autentificación inicial de phpMyAdmin, con lo que podremos acceder sin contraseña a nuestro servidor (como root o como el usuario que elijamos), puede ser un método un tanto inseguro, pero si sólo estamos nosotros y tenemos el servidor cerrado al exterior no hay problema. Para ello, debajo de la identificación del primer servidor (las líneas que hemos añadido), añadimos lo siguiente en config.inc.php:

En ocasiones, estamos desarrollando una aplicación, y ésta necesita que le pasemos como parámetro, por ejemplo, una contraseña. El gran peligro que esto tiene es que cualquier usuario, pidiendo un listado de procesos con ps podrá ver la contraseña.

Imaginemos que tenemos una aplicación (que hemos hecho nosotros) que conecta con un servidor, y dado que hemos hecho un script para automatizar el proceso, el nombre de usuario y contraseña los pasaremos como parámetro al ejecutable. Dicho proceso se llama “aplicacionsegura”, dicho programa lo hemos lanzado en un servidor y otros usuarios tendrán acceso a dicha máquina. Ahora uno de ellos ejecuta lo siguiente:

$ ps ax
….
10560 pts/3    S+     0:00 ./aplicacionsegura –user=usuario –passwd=micontraseña
…

¡Nuestro gozo en un pozo! Otro usuario ya tiene nuestra contraseña, y ha sido muy sencillo. Y además lo podremos ver (de hecho ps es lo que hace) viendo el archivo /proc/PID/cmdline. Aunque debemos ver qué opciones tenemos:

Modificar el parámetro passwd

Para ilustrar el ejemplo, vamos a fijar la posición de –passwd=xxxxx al segundo parámetro (la captura de parámetros no es objeto de este post). Lo primero que vamos a probar es introducir un terminador en las cadenas de los parámetros, Si la cadena empieza por ‘\0′ estará vacía:

Aunque tardaremos poco en darnos cuenta que da igual, por una parte, no podríamos borrar todos los rastros de información, ya que si escribimos en la posición 0 de la cadena “–passwd=micontraseña” un terminador, el resto de la cadena se quedará en memoria y podrá ser leída. De todas formas, la cadena parece que sólo tiene un espacio para ps, es más, el \0 le ha dado igual.

Probemos ahora escribiendo “HOLA” en la cadena de la contraseña (ahora sí pongo el código completo, test.c):

Ahora ejecutaremos lo siguiente:

$ gcc -o test test.c
$ ./test & # El programa test esperará una tecla para terminar, pero lo ejecutaremos de fondo, para que no se cierre.
$ ps ax
….
10809 pts/3 S+ 0:00 ./test –user=usuario –passwd=HOLA traseña
….
$ killall test # Para matar el proceso

Un efecto curioso, las cadenas de los parámetros no son NULL-terminated, de cara a /proc/PID/cmdline por lo que cuando ponemos un terminador, lo toma como un espacio. Y se ve parte del parámetro. Lo que sí podemos hacer es sustituir por asteriscos, tantos asteriscos como letras tenga el parámetro.

Ahora al ejecutar ps:

$ ps ax
…
10906 pts/3 S+ 0:00 ./test –user=******* –passwd=*************
…

Aunque esta forma revela en cierto modo la longitud de las contraseñas y el nombre de usuario, puede que no nos interese, que queramos eliminar el parámetro entero y que no se vea:

La manera rápida pero peligrosa y de andar por casa

El objetivo es escribir algo más largo que el último parámetro. Es decir, si el parámetro de contraseña tiene 22 letras, tenemos que escribir algo más grande, unas 23 letras, o cargarnos el terminador del segundo argumento (no son NULL-terminated, el kernel sabe dónde empieza y dónde termina la cadena, pero hay un NULL para comprobar que todo va bien).

En este caso podemos hacer:

y veremos cómo ps no nos dice nada, en principio no es demasiado elegante, nos estamos cargando un terminador, que nosotros podríamos necesitar, para lectura, y estamos escribiendo en una zona de memoria que no es nuestra, ya que el argumento tiene reservado un tamaño de memoria, y estamos escribiendo más de lo que debemos (podemos producir una violación de segmento).

Decirle al kernel que no queremos los parámetros

Parecida a la forma anterior, podemos hacer:

lo que no es intuitivo para nada, porque nos estamos cargando el terminador, que controla el paso de parámetros. De esta forma, no tendremos ningún parámetro. Tambén podemos hacer una forma general

De esta forma desaparecerán todos los argumentos de /proc/PID/cmdline ; sólo tendremos la ruta y el nombre del ejecutable, y nuestros datos, al menos por esta parte, estarán seguros.
Foto: marc falardeau (Flickr)

En ocasiones, nuestros programas requieren que un servicio o un programa esté en ejecución. Algunos servicios los podemos ubicar fácilmente, ya que /var/run ,  /dev/shm u otra ruta contienen un archivo con su PID (Identificador de proceso), otras servicios no figuran en ningún lado. También puede ser que estemos esperando que otro proceso termine y necesitamos averiguar su PID.

Para todo ello, debemos echar un ojo al contenido de /proc/, ahí encontramos, entre otras cosas, información sobre los procesos en ejecución del sistema. En principio lo que nos interesa es el nombre del ejecutable (es lo que estamos buscando), para ello, vamos a buscar dentro del directorio /proc/ todos los directorios que sean numéricos (esos que contendrán un PID), y leeremos el fichero /proc/[pid]/comm, que contiene la información del nombre del ejecutable. Eso sí, ese nombre tendrá una longitud limitada (marcada por la constante del kernel TASK_COMM_LEN, que suele valer 16 (con lo que los nombres tendrán como máximo 15 caracteres):

En este ejemplo si comentamos la línea 52 y en la línea 53 ponemos:

podemos obtener un listado completo de las tareas en ejecución (sólo por curiosear un poco). Aunque en este ejemplo tenemos un problema, mencionado antes, el número de caracteres del ejecutable, es decir, hay ejecutables con más de 15 caracteres, y tal vez queramos buscarlos. Con la solución actual estamos cortando los nombres (con strncmp()), es decir, sería lo mismo aplicacionconnombrelargo que aplicacionconnombrecorto, ya que sólo tenemos en cuenta los primeros 15 caracteres. Tiene que haber otra forma de sacar el nombre completo, y es a través del archivo /proc/[PID]/cmdline, es más, desde aquí podemos sacar la ruta del ejecutable y los parámetros con los que se llamó, tal y como vemos cuando ejecutamos:

$ ps x

Vamos a ver cómo podemos adaptar el código de antes para poder sacar toda esa información.

Ahora, obtenemos la información dependiendo del tipo especificado por outtype de tipo enum pnametype, e incluso si especificamos LONG, este tipo extraerá el nombre del archivo ejecutable despreciando la ruta del mismo. Para descargar los archivos de código, click aquí (2.3Kb)

Hasta ahora, aunque en la instalación especificamos que queríamos el sistema en idioma español, era sólo para la instalación y algunas aplicaciones que ya instalaban el soporte para varios idiomas. Esto es así porque la instalación no requería de conexión a Internet, y en el DVD de instalación no se incluían los idiomas adicionales. Por ello tendremos que instalarlos.

Este post será largo, quiero incluir detalles de muchas cosas, y pongo aquí el índice:

• Instalar paquetes de idioma para varias aplicaciones
• Configración de Linux Mint XFCE
• Instalar tipografías adicionales
• Complementos para el panel de XFCE
• Otras utilidades de XFCE
• Efectos de escritorio con Compiz
• Apéndice I: Configurando el plugin Mount devices

Instalar paquetes de idioma para varias aplicaciones

A partir de ahora, instalaremos los paquetes de idioma español para Firefox, Thunderbird, LibreOffice y páginas del manual (man):

$ sudo apt-get install firefox-l10n-es thunderbird-l10n-es libreoffice-l10n-es manpages-es

También encontramos paquetes para Chromium o para la plataforma KDESC y muchos más.

Si queremos instalar los soportes de ortografía de Firefox debemos dirigirnos a esta dirección y podremos descargarlo e instalarlo directamente en el navegador.

Configuración de Linux Mint XFCE

Este paquete no viene instalado de serie, aunque estaría bien; a primera vista puede ser parecido a el administrador de configuración de XFCE (menu/Settings o Configuración/Administrador de Configuración; ejecutable: xfce4-settings-manager), aunque tiene algunas cosas más. Nos permite configurar la impresora, dispositivos bluetooth, usuarios, gestor de paquetes, monitor de sistema, diagnóstico de disco, copias de seguridad, etc. En definitiva es un centro de control donde podemos acceder a todo lo que tenemos en menu/Settings o Configuración , pero de una forma organizada.

Cuenta además con un grupo llamado Personalizar que nos permite elegir qué aplicaciones introducimos ahí de forma que tengamos un acceso directo.

Para instalarlo,

$ sudo apt-get install mintconfig-xfce

Algo destacable acerca de esta aplicación y de los componentes que instala es que:

• Permite configurar el sistema para iniciar los efectos de escritorio
• Tiene herramientas para configurar recursos de red compartidos
• Editor de configuración avanzada de XFCE.
• Configuración de NDISwrapper (Controladores inalámbricos de Windows)
• Copia de seguridad de tu home (mintBackup)
• Bloqueador de dominios (mintnanny)
• Soluciones a problemas con tipografías en algunos monitores a un click.

Si te gusta personalizar tu ordenador, es conveniente tenerlo a mano.

Instalar tipografías adicionales

Las tipografías suelen ser una parte importante para todos aquellos que diseñamos, escribimos, compartimos… el tipo de letra en sí expresa ya parte del mensaje. He oído varias veces decir que “instalar tipos de letra en Linux es complicado y que no hay tantas opciones como en otros sistemas”, cuando los formatos para los tipos de letra son los mismos para todos. Aquí instalaremos casi 600 tipografías ttf (TrueType)  sin complicarnos mucho la vida. Y ahora deberemos pasar al menos un par de días mirando todas las fuentes instaladas (muchas de ellas son libres).

$ sudo apt-get install ttf-summersby ttf-ubuntu-title ttf-prociono ttf-liberation ttf-linux-libertine ttf-sjfonts ttf-okolaks ttf-opendin ttf-mplus ttf-georgewilliams ttf-femkeklaver ttf-engadget  ttf-dustin ttf-droid  ttf-breip  ttf-century-catalogue  ttf-comfortaa  ttf-baekmuk  ttf-ancient-fonts  ttf-adf-verana  ttf-aenigma  ttf-alee ttf-adf-baskervald  ttf-adf-libris ttf-bitstream-vera ttf-isabella ttf-xfree86-nonfree

Además, si alguien echa de menos los tipos de letra “de toda la vida” de Windows (Arial, Times New Roman, Verdana, Trebuchet), podemos instalarlos de la siguiente manera:

$ sudo apt-get install ttf-mscorefonts-installer

Complementos para el panel de XFCE

Los paneles pueden hacer mucho más de lo que hacen por defecto, por eso vamos a personalizarlos y a añadir complementos nuevos. Empecemos por el panel de arriba donde están los programas, la lista de escritorios y el botón de menú (arriba a la izquierda).

El primer paso, para añadir elementos es hacer click con el botón derecho en el panel > Panel > Añadir nuevos elementos:

Tras ello aparecerá una nueva ventana donde seleccionaremos el complemento a instalar, como primer complemento adicional escogeremos un control de volumen.

Vamos a instalar unos cuantos plugins, aunque muchos de ellos los dejo para que cada uno descubra los que más le gustan o le resulten más útiles:

$ sudo apt-get install xfce4-clipman xfce4-clipman-plugin xfce4-cpugraph-plugin xfce4-genmon-plugin xfce4-mount-plugin xfce4-notes-plugin xfce4-notes xfce4-systemload-plugin xfce4-smartbookmark-plugin xfce4-timer-plugin  xfce4-verve-plugin xfce4-wmdock-plugin xfce4-datetime-plugin

Los cambios que diré ahora son algunas propuestas que a mí me resultan útiles:

• Cambio del plugin por defecto de hora por el plugin “Fecha y hora”. Para ello debemos pulsar sobre el elemento actual de hora y elegimos “Quitar” del menú contextual. Luego añadir el elemento “Fecha y hora”, este elemento nos dará más información y, además, al hacer click con el botón izquierdo, nos mostrará un calendario.
  
• Notas de escritorio. Para ello añadimos el plugin “Notas”
  
• . Nos permite ver los dispositivos que tenemos montados y desmontarlos a un clic.
  Aunque la configuración que viene por defecto no me gusta demasiado, propongo una configuración más práctica.
• Clipman. Este complemento nos permite almacenar lo que vamos copiando en el portapapeles. Imagina que copiamos un texto, lo pegamos y seguimos trabajando, copiamos otro texto, y ahora necesitamos pegar el primer texto que copiamos. Este complemento nos ayuda a llevar a cabo esas acciones.
  Lo podemos ejecutar también como parte de la bandeja de sistema accediendo a menu/Settings o Configuración/Sesión e Inicio/Autoarranque de Aplicaciones y marcando Clipman.

Otras utilidades de XFCE

Ahora instalaremos algunas aplicaciones para XFCE que nos serán útiles en algunas circunstancias

• xfce4-volumed . Esta aplicación es muy útil para usuarios de portátiles o teclados multimedia, ya que nos permitirá modificar el volumen del sistema con las teclas específicas para ello.
  Lo instalamos de la siguiente manera:
  $ sudo apt-get install xfce4-volumed

  Linux Mint configura este paquete para que se arranque automáticamente al iniciar XFCE.

• orage . Es un gestor de calendario donde podemos anotar citas, eventos y tareas. Es muy sencillo, rápido y se integra bien con XFCE.
  Lo instalamos de la siguiente manera:
  $ sudo apt-get install orage
• xfswitch-plugin . Es otro plugin para el panel que nos permite cambiar la sesión gráfica de usuario o identificarnos como un usuario nuevo sin cerrar la sesión actual. Podremos cambiar entre sesiones con Control+Alt+F7/F8/F9…
  Lo instalamos de la siguiente manera:
  $ sudo apt-get install xfswitch-plugin
• epdfview . Es un visor de pdfs muy ligero. Tiene menos opciones que evince, pero para un visionado rápido nos vale.
• pcmanfm . Es un administrador de archivos muy ligero, con soporte para pestañas y acceso a sistemas de archivos remotos (ssh/ftp/…)
  Podemos utilizarlo en lugar de Thunar para abrir directorios si nos vamos a Menu/Settings o Configuración/Aplicaciones preferidas > Utilidades y ahí seleccionamos PCMan File Manager:
  

Efectos de escritorio con Compiz

Seguro que es una de las partes que más llama la atención, y una de esas cosas que utilizaremos para sorprender a las visitas enseñándoles un entorno gráfico del futuro. Aunque, además de tener un entorno gráfico más amigable, si tenemos una tarjeta gráfica decente (Ati/NVIDIA o incluso Intel), y más o menos nueva (por lo menos de 2004/2005), podemos disfrutar de un mejor rendimiento general del sistema y de un entorno mucho más fluído (ya que dejamos algunas tareas más para la GPU) y tendremos un valor añadido en algunos efectos.

Yo no soy muy partidario de efectos elaborados y lentos, aunque el cubo de escritorios es una excepción, aunque lo tengo configurado para que tarde menos de medio segundo. Aunque tenemos otros efectos útiles como por ejemplo hacer Zoom a la pantalla (muy útil para diseñadores en algunas ocaiones, ¿quién no se ha acercado tanto al monitor para saber si dos líneas son paralelas?), o por ejemplo una previsualización de la ventana al pasar el ratón por encima de la barra de tareas.

Para instalar:

$ sudo apt-get install compiz-gtk compiz compizconfig-settings-manager  compiz-fusion-plugins-extra compiz-fusion-plugins-main

Ahora podremos habilitar Compiz desde la configuración de Linux Mint (xfce4-mintconfig), seleccionando Xfce mintDesktop y dentro del nuevo diálogo, en la pestaña Compiz Fusion, habilitando Compiz Fusion.

Ahora, debemos ir a la configuración de Compiz, Compiz Config Settings Manager, o CCSM; podemos hacerlo ejecutando el comando ccsm, o desde la misma pantalla de configuración de Linux Mint pulsando en Configurar Compiz con CompizConfig.

A partir de aquí os dejo para configurar vuestros efectos de escritorio a medida.

Apéndice I: Configurando el plugin Mount Devices

Configurar esta extensión no es complicado. Si vimos la captura anterior, se mostraban todos los puntos de montaje (yo tengo muchas particiones, para /usr, /var, /boot, etc y no me interesa desmontarlas, es más, no quiero verlas ahí; por otra parte, puede que utilice recursos de red y sí que quiera desmontar estos. Empecemos haciendo clic con el botón derecho del ratón y seleccionando Propiedades:

Podemos mostrar un mensaje nada más desmontar el dispositivo, pero mejor desmarcamos esa casilla, ya que vamos a hacer algo más completo en la siguiente pestaña. También podemos seleccionar un icono, eso es a gusto del usuario.

En la siguiente pestaña, Commands, encontramos comandos personalizados a la hora de montar y desmontar volúmenes.

En este punto, marcaremos la casilla “Custom commands“, para indicar comandos para montar/desmontar unidades manualmente. Los parámetros de montaje (Execute after mounting y Mount command) los podemos dejar en blanco, ya que el montaje se reserva para todos los puntos especificados en /etc/fstab y no para los dispositivos que el sistema vaya descubriendo.

Aunque para Unmount command, yo tengo puesto lo siguiente:

pumount %d && notify-send “%d desmontado correctamente” || notify-send “Hubo un problema al desmontar %d”

Es necesario tener pmount instalado. Con esta línea podremos ver un mensaje como notificación ya haya tenido éxito o no la operación. Esta línea no valdrá para ubicaciones de red aunque podemos vincular la operación a un script más complejo.

Por último, en la pestaña File Systems, podemos indicar qué queremos mostrar y qué no queremos mostrar

En esta pestaña, podemos seleccionar la opción de  representar sistemas de archivos de red (Display network file systems), expulsar unidades de CD (Eject CD-drives) mostar sólo los puntos de montaje y no el dispositivo o el UUID, lo cual puede llegar a ser incómodo (Display mount points only), y por último excluir algunos sistemas de archivo (Exclude specified file systems), y es en esa opción donde escribimos separados por espacios los puntos de montaje separados por espacios que no queremos mostrar; en mi caso, son los puntos de montaje del sistema.