Cómo concatenar documentos pdf en linux

EL COMANDO pdftk:
Algunas veces es necesario unir dos archivos pdf en uno sólo. Para concatenar documentos pdf podemos hacer uso del comando pdftk de la siguiente manera. Supongamos que tenemos un par de archivos llamados, el primero Archivo1.pdf, y a continuación, un segundo archivo con el nombre Archivo2.pdf. Incluso podríamos tener 3, 4 o N archivos, y para concatenarlos basta usar el comando pdftk

pdftk Archivo1.pdf Archivo2.pdf .... ArchivoN.pdf cat output ArchivoFinal.pdf

Esta orden une los archivos y guarda el resultado con el nombre ArchivoFinal.pdf
Como ejemplo, este es un archivo pdf:
MeganFox
y el siguiente, también es un archivo pdf:
MeganFox2
y, después de concatenar, se obtiene:
ArchivoMegan
PARA INSTALAR EL COMANDO pdftk:
El comando pdftk no aparece como una utilidad básica del sistema, pero viene en repositorios, por lo menos en Ubuntu y Mandriva. Por lo tanto, primero hay que instalarlo.
En Ubuntu, y si uno es parte del grupo sudo, basta con escribir

sudo apt-get install pdftk

O en Mandriva, como root:

urpmi pdftk
Anuncios

Escribiendo y Ejecutando un Script Simple

Siempre que se tenga que ejecutar muchas veces un comando, o una serie de comandos, será útil escribir shell scripts. Los scripts son instrucciones aceptadas por la shell. Como existen varios tipos de shell, cada una de las cuales tiene características específicas, es necesario decir que este primer código será para bash, la shell por defecto en las distribuciones con kernel linux.
El primer script tiene que ser un Hola, Mundo! Lo principal es imprimir una linea de texto y saber cómo ejecutarlo.
Abrimos un archivo nuevo y lo llamamos HolaMundo.sh El nombre y la extensión son indiferentes; bien podemos ponerle Programa1 o MiPrimerScript. Sin embargo, un buen nombre y la extensión son bastante recomendables para organizar nuestros archivos. Podemos usar cualquier editor, pero para hacerlo al estilo Unix, vamos a usar vi:

vi HolaMundo.sh

El editor vi no inicia en un modo de inserción en el que podamos escribir directamente. Inicia más bien en el modo comandos. Basta con escribir i (insertar) para poder escribir. Vamos a teclear lo siguiente:

#!/bin/bash
# Esto es un comentario

echo "Hola, Mundo!"

Para salir y guardar, tecleamos la tecla de escape, y a continuación escribimos :wq (guardar y salir)

Vamos a revisar cada línea del script:

#!/bin/bash

La shell por defecto de las distribuciones linux es bash. Esa es la razón por la cual esta línea se agrega. Estamos indicando que el intérprete del script será bash. Esta línea debe añadirse al principio sin ningún espacio en blanco.

# Esto es un comentario

Los comentarios sirven para documentar el programa. Son pasados por alto por el intérprete y son necesarios porque ayudan al programador a saber qué hace el programa y qué hacen ciertas líneas. Los comentarios inician con el símbolo # y terminan con el siguiente salto de línea.

echo "Hola, Mundo!"

El comando echo reproduce literalmente lo que viene a continuación; en este caso el mensaje entre comillas “Hola, Mundo!”.
Cómo ejecutar el script:
Una vez escrito el script, es necesario ejecutarlo. Para ésto podemos hacer dos cosas:
1) Otorgarle permisos de ejecución al archivo.
Para esto basta escribir la siguiente línea en la consola

chmod +x HolaMundo.sh

y ya con ésto, es posible correrlo:

./HolaMundo.sh

Si ningún error ha ocurrido, entonces ya podrá ver el mensaje

Hola, Mundo!

De lo contrario, aparecerá un mensaje de error y será necesario editar el programa.
2) Llamando a bash:

bash HolaMundo.sh

Esta instrucción llama al intérprete bash y ejecuta automáticamente el script. De nuevo, si al escribirlo cometimos algún error, será necesario editarlo.

Ayuda a un Administrador Torpe: Por qué no presionar cualquier tecla.

¿Por qué no debería Homero oprimir cualquier tecla?


Ésta imagen de Homero Simpson como aprendiz de informático, que ya he usado en una entrada anterior me hizo pensar que seguir la recomendación del mensaje “press any key” podría no ser del todo buena. Después de todo, como bien dice Homero, no hay una tecla llamada “cualquiera”.
Ya que homero es un administrador torpe, podríamos intentar ayudarlo. La cuestión es:

Cuando una pantalla está en modo ahorrador de energía, o "durmiendo",
¿por qué no deberíamos despertarla con la tecla enter?

La razón simple para no hacerlo, es que debajo de una pantalla dormida puede haber cualquier cosa. Los de Linux Total, que de verdad que tienen buenos artículos, mencionan esta historia:

Mientras un colega se encontraba fuera de su lugar de trabajo, teclee en su 
terminal lo siguiente:

#> rm -rf *

... pero no presioné "Enter". Se trataba de una broma. Yo esperaba que al 
regresar y viera esa línea se asustara y después viera que se trataba de 
una broma y nos rieramos. Después presionaría "backspace" y nada pasaba.
Pero lo impensable pasó. La pantalla se puso a dormir con el protector y
cuando regresa presiona "Enter" unas cuantas veces ¡para despertarla! Se
perdieron tres días de trabajo y algunos posibles clientes nuevos. El costo
estimado de la broma resultó en unos 50000 dólares.

También podemos suponer que, mínimo, costó el despido del bromista. rm -rf es la instrucción utilizada para borrar directorios. rm borra archivos, las opciones -r significan de manera recursiva en el directorio de entrada especificado a continuación y f es “no preguntar”, es decir, la orden equivale más o menos a “borra todos los archivos del directorio que viene y no te preocupes si se trata de el directorio /etc/ o cualquier otro”, total, que para eso somos root, ¿o qué no?. De hecho rm -rf es una buena fuente de problemas (CentOS y otras distribuciones, no preguntan, aunque no se incluya la opción f). El asterísco a continuación indica cualquier cosa, y ese cualquier cosa no es más que todos los subdirectorios, con sus archivos y subdirectorios incluidos, del directorio actual. Así que un buen problema se puede armar al darle “Enter” a esta instrucción.
-Esto es un caso extremo, -pensará Homero- todo el tiempo miles de personas despiertan su pantalla a base de “Enters” y nunca les ha pasado nada. Esto es caer en niveles de paranoia. Sin embargo, los accidentes rara vez tienen una sola causa, generalmente son una combinación de malos hábitos que, a base de repetición, llegan a coincidir. Como dice una ley entrópica, si algo puede ir mal, irá mal. En particular yo prefiero despertar pantallas con la flecha de dirección hacia abajo.

Numerar la Salida de un Archivo

El comando pg no incluye una opción para numerar las líneas de salida de un archivo. El comando cat sí incluye las opciones -b y -n, las cuales presentan el archivo numerando los renglones no blancos y todos los renglones del archivo, respectivamente.
Aquí se presentan otras opciones:
EL COMANDO nl:
Vamos a suponer que tenemos el Archivo.txt

Puedo escribir los versos más tristes esta noche.
Escribir, por ejemplo: "La noche está estrellada,
y tiritan, azules, los astros, a lo lejos."
El viento de la noche gira en el cielo y canta.
Puedo escribir los versos más tristes esta noche.
Yo la quise, y a veces ella también me quiso.
En las noches como esta la tuve entre mis brazos.
La besé tantas veces bajo el cielo infinito.
Ella me quiso, a veces yo también la quería.
Cómo no haber amado sus grandes ojos fijos.
Puedo escribir los versos más tristes esta noche.
Pensar que no la tengo. Sentir que la he perdido.

y buscamos, con el comando grep la palabra cielo

grep -n cielo Archivo.txt

con lo cual obtenemos:

4:El viento de la noche gira en el cielo y canta.
8:La besé tantas veces bajo el cielo infinito.

Para ubicar mejor la palabra, necesitamos ver el archivo con los renglones numerados, para esto usamos el comando nl:

nl Archivo.txt

y obtenemos:

     1	Puedo escribir los versos más tristes esta noche.
     2	Escribir, por ejemplo: "La noche está estrellada,
     3	y tiritan, azules, los astros, a lo lejos."
     4	El viento de la noche gira en el cielo y canta.
     5	Puedo escribir los versos más tristes esta noche.
     6	Yo la quise, y a veces ella también me quiso.
     7	En las noches como esta la tuve entre mis brazos.
     8	La besé tantas veces bajo el cielo infinito.
     9	Ella me quiso, a veces yo también la quería.
    10	Cómo no haber amado sus grandes ojos fijos.
    11	Puedo escribir los versos más tristes esta noche.
    12	Pensar que no la tengo. Sentir que la he perdido.

USANDO AWK:
Otra forma es usando el comando awk

awk '{print NR, $0}' Archivo.txt

en Awk, NR hace referencia al número de renglón y $0 hace referencia a toda la línea.

1 Puedo escribir los versos más tristes esta noche.
2 Escribir, por ejemplo: "La noche está estrellada,
3 y tiritan, azules, los astros, a lo lejos."
4 El viento de la noche gira en el cielo y canta.
5 Puedo escribir los versos más tristes esta noche.
6 Yo la quise, y a veces ella también me quiso.
7 En las noches como esta la tuve entre mis brazos.
8 La besé tantas veces bajo el cielo infinito.
9 Ella me quiso, a veces yo también la quería.
10 Cómo no haber amado sus grandes ojos fijos.
11 Puedo escribir los versos más tristes esta noche.
12 Pensar que no la tengo. Sentir que la he perdido.

nl también se puede conectar por tuberías con el comando cat o pg para producir el mismo resultado. Desde luego, a la hora de editar archivos, el editor vi nos lleva de inmediato a cualquier renglón con :n

Cadena de Literales en Perl: Comillas Invertidas.

No es que sean un nuevo tipo de datos. En realidad las comillas invertidas ` hacen una llamada al sistema. Lo que aparezca dentro de ellas es ejecutado por el sistema, así que debemos usar órdenes que sean reconocibles por la shell. Por ejemplo, bien podríamos listar el contenido de un directorio con el comando dir. Podríamos, incluso crear un pequeño script que apague nuestra computadora:
APAGAR LA COMPUTADORA:

#!/usr/bin/perl
#Este script apaga la computadora
#necesita ser root para lograrlo

print `shutdown -h now`;

Vamos a revisar cada línea del programa:

#!/usr/bin/perl

Esta es la llamada al intérprete.

#Este script apaga la computadora
#necesita ser root para lograrlo

Estas dos líneas son un comentario. Se le avisa al usuario que sólo podrá apagar el sistema si es un superusuario.

print `shutdown -h now`;

Ésto es una llamada al sistema. Para comunicarnos con el sistema necesitamos escribir los comandos dentro de comillas invertidas:
`comandos `
El resultado del presente programa sería el mismo si no se incluye la instrucción print, es decir si sólo ponemos la esta línea sin print, igual hacemos la llamada a shutdown, sin embargo, es mejor hacerlo mediante print. Si usted no es root, entonces al ejecutar este programa verá un mensaje como este:

shutdown: Es necesario ser superusuario

ADVERTENCIA: si usted ejecuta este script y está trabajando como sudo, o como root, la computadora se apagará y puede perder información.
También podemos escribir un programa que presente su propio código como salida, por medio del comando cat:
UN PROGRAMA QUE IMPRIME SU PROPIO CÓDIGO FUENTE:

#!/usr/bin/perl
#Este programa imprime su propio codigo

print`cat Programa.pl`;

Vamos a revisar cada línea del programa:

#!/usr/bin/perl

Esta línea la deben de llevar todos los programas al principio

#Este programa imprime su propio codigo

Esto es documentación del programa. Sirve solamente para que su creador, o quien modifique esto, sepa de qué trata el código.

print`cat Programa.pl`;

Desde luego, para que esto funcione, el programa debe de guardarse con el nombre Programa.pl y debe de estar en el mismo directorio. De no estar en el mismo directorio, debe nombrarse la ruta completa.
La salida, como se puede comprobar, es el mismo código del programa. Aquí se hace uso del comando cat

UN PROGRAMA QUE SE BORRA A SÍ MISMO:

#!/usr/bin/perl
#Este programa se borra a si mismo

print`rm -f Programa.pl`;

Vamos a revisar cada línea del programa:

#!/usr/bin/perl

De nuevo, esto debe ir siempre al inicio de un programa en perl. Para ser más precisos, use which perl y escriba esa dirección después de #!

#Este programa se borra a si mismo

Este es un comentario, e indica de qué se trata el script.

print `rm -f Programa.pl`;

Ésta línea borra el script con la orden rm -f Para que funcione, en Programa.pl se debe escribir el nombre del archivo que se quiere borrar.
=================================================================================
EJERCICIOS:
* Escriba un programa que liste todos los archivos con terminación .pl que tiene en su directorio (tal vez le convenga usar el comodín asterísco)
* Escriba un programa en perl que se llame a sí mismo de manera infinita. Para ver que su programa se ejecuta, imprima cada vez el mensaje “Hola!”. En Unix los ciclos infinitos se terminan con la combinación de teclas Control + C
=================================================================================
ENTRADA ANTERIOR:
Cadena de Literales en Perl: Comillas Dobles

Buscando Patrones en un Archivo con el Comando grep. Tuberías.

EL COMANDO grep:
Supongamos que tenemos un archivo con una lista de nombres, digamos alumnos de una clase, y queremos encontrar a todos aquellos que se apelliden Cervantes.
Una forma fácil de hacerlo es con el comando grep:

grep Cervantes Archivo.dat

que produce la salida:

Mario Cervantes
Carmen Cervantes

grep desplegará las líneas que contienen Cervantes, incluso si es parte de una palabra más grande, como Cervantesaavedra.
La forma general del comando grep es la siguiente:

grep Patron Archivo1 Archivo2

Supongamos, por ejemplo, que no solamente tenemos un grupo de alumnos, sino 2, y los nombres de los alumnos están escritos en Archivo.txt y Archivo.dat, entonces la línea

grep Cervantes Archivo.dat Archivo.txt

produce

Archivo.txt:Mario Cervantes
Archivo.txt:Carmen Cervantes
Archivo.dat:Josefina Cervantes
Archivo.dat:Jose Luis Cervantes

que indica los nombres que incluyen Cervantes y dicen además de qué archivo viene. O, usando el comodín asterísco

grep Cervantes Archivo*

que produce el mismo resultado, si es que no hay otro(s) archivo(s) cuyo nombre empiece con la palabra Archivo que también contenga(n) la cadena Cervantes.
CONECTANDO COMANDOS POR MEDIO DE TUBERÍAS:
Si no indicamos algún archivo para grep, entonces toma los datos de la salida estándar. Por ejemplo. Supongamos que en el sistema hay muchos usuarios pero en particular queremos saber si el usuario elisa está logueado. Para saberlo podríamos usar una linea como esta:

who | grep elisa

y podríamos obtener algo como:

elisa pts/0        2012-06-22 21:38 (:0)
elisa pts/1        2012-06-22 22:14 (:0)
elisa pts/3        2012-06-22 23:07 (:0)
elisa pts/4        2012-06-23 00:09 (:0)

el comando who nos dice qué usuarios están en el sistema. La barra es una conexión o “tubería” entre who y grep. | toma la salida de who y la envía como entrada a grep. El comando grep entonces busca la cadena elisa dentro de la salida de who.
En este par de ejemplos, grep se ha usado como filtro. Debido a que who puede devolver decenas de líneas, es necesario filtrar esa información. El comando grep es un filtrador natural en Unix.
BUSCANDO UN PATRÓN SIN IMPORTAR MAYÚSCULAS O MINÚSCULAS:
Podría ocurrir que en alguno de los archivos en los que estamos buscando el apellido Cervantes, apareciera el apellido de una manera distinta. Digamos CERVANTES o cervantes; en este caso, con la sola instrucción grep Cervantes Archivo no se obtiene ningún resultado. Para buscar coincidencias de cadenas sin importar si las letras son mayúsculas o minúsculas, existe la opción -i en el comando grep:

grep -i Cervantes Archivo.dat

y obtenemos la salida

Josefina Cervantes
Jose Luis Cervantes
Fernando cervantes

que indica que en Archivo.dat había alguien con apellido Cervantes, que no se mostraba antes, porque la primera letra estaba en minúsculas.
BUSCANDO CADENAS CON ESPACIOS EN BLANCO
El comando grep también puede ser usado para encontrar expresiones que contengan espacios en blanco. Por ejemplo, vamos a suponer que deseamos encontrar en nuestra lista de alumnos en Archivo.dat a el alumno Elisa Griensen. Para hacer la búsqueda bastará colocar como patrón ese nombre entre comillas sencillas ‘ o comillas dobles “:

grep 'Elisa Griensen' -i Archivo.dat

En donde, puesto que ya conocemos a nuestro capturista de datos, hemos puesto la opción -i para indicarle a grep que no debe de tomar en cuenta diferencias entre mayúsculas y minúsculas. Esta opción puede ir antes o después del patrón. Al ejecutarlo podemos encontrar:

Elisa griensen

y por la salida, que indica el apellido griensen en minúsculas, sabemos que hemos hecho bien en incluir la opción -i.

INDICANDO EL NÚMERO DE LÍNEA DE LAS COINCIDENCIAS DEL PATRÓN
Si el archivo donde tenemos nuestra lista de estudiantes es muy grande, tal vez nos interesaría saber en qué línea exactamente está nuestra coincidencia. Por ejemplo Elisa Griensen. Para ésto usamos la opción -n del comando grep

grep 'Elisa Griensen' -in Archivo.dat

y obtenemos:

6:Elisa griensen

En la línea anterior usamos las opciones i y n como una combinación mediante -in
¿Y POR QUÉ SE LLAMA grep?
En editor de textos ed, para buscar un patrón en un archivo se usa la expresión g/re/p para buscar la expresión contenida entre las diagonales / / (expresión regular) e imprimirlas. De ahí el natural nombre de grep para el comando Unix que hace la misma tarea.

Cadena de Literales en Perl: Comillas Dobles.

Las cadenas de comillas dobles son un poco más completas que las cadenas de comillas sencillas. En particular es posible el uso de las secuencias de escape. Salvo estas secuencias, la función print imprime literalmente lo que se encuentra dentro de las comillas dobles, incluyendo saltos de línea, tabuladores y espacios en blanco. Para hacer una comparación, el programa anterior se puede escribir de la siguiente manera usando comillas dobles:

#!/usr/bin/perl
print "Su cuenta

Pan:\t\$34.45\n";
print "Fruta:\t\$45.00\n";
print "\t======\n";
print "\t\$79.45";

La ejecución de este programa imprime lo siguiente:

Su cuenta

Pan:	$34.45
Fruta:	$45.00
	======
	$79.45

================================================================================
Ahora vamos a revisar cada línea del programa:

#!/usr/bin/perl

Esta primera línea es un comentario. Los comentarios en Perl empiezan con el caracter # y terminan en el siguiente salto de línea. Pero este es un comentario especial, se incluye en todos los programas e indica la dirección del intérprete de Perl.

print "Su cuenta

Pan:\t\$34.45\n";

Estas tres líneas en realidad son una misma instrucción. Se trata de la función print. La estructura de ésta línea es:
print “cadena de caracteres”;
todo lo que aparece dentro de las comillas se imprime literalmente. Bueno, casi todo. Como se ha dicho, las secuencias de escape son caracteres especiales. En esta instrucción aparecen 2 de ellas: \t y \n. La primera es tabulador y la segunda indica salto de línea. Al terminar de imprimir, \n hace que el cursor quede justo al inicio de la siguiente línea. Todas las instrucciones print deben terminar con unpunto y coma. De lo contrario, la compilación del programa indicará error.

print "Fruta:\t\$45.00\n";

Esta es de nuevo una instrucción print. Aquí aparecen las secuencias de escape tabulador, \t, nueva línea, \n, y una nueva, \$, que imprime el signo de peso.

print "\t======\n";

En realidad toda la información que despliega este programa cabe en una instrucción print con comillas dobles. Sin embargo también es posible usar varias instrucciones print. Observe que cualquier instrucción print empieza a imprimir justo donde dejó el cursor la anterior.

print "\t\$79.45";

Esta línea marca el final del programa, todas las instrucciones deben de terminar con un punto y coma.
===============================================================================
ENTRADA ANTERIOR: Cadena de Literales en Perl: Comillas Sencillas
ENTRADA SIGUIENTE: Cadena de Literales en Perl: Comillas Invertidas

Cadena de Literales en Perl: Comillas Sencillas

Las literales de cadena en Perl son grupos de caracteres encerrados entre comillas, los cuales son tratados como un solo dato. En Perl existen tres tipos de comillas, las comillas sencillas ‘, las comillas dobles ” y las comillas invertidas`.
El siguiente programa sirve para presentar una literal de cadena encerrada entre comillas sencillas. Las comillas sencillas imprimen literalmente lo que contienen. No es válido aquí utilizar secuencias de escape como \n, ya que se imprimiría literalmente \n. Sin embargo, para escribir comillas sencillas sí es posible usar el carácter de escape \. Si quisiéramos imprimir algo como ‘Hola’, se tendría que usar la forma …\’Hola\’…

#!/usr/bin/perl
print 'Su cuenta

Pan:    $34.45
Fruta:  $45.00
        ======
        $79.45';

La ejecución de este programa es:

Su cuenta

Pan:    $34.45
Fruta:  $45.00
        ======
        $79.45

Observe que los espacios y líneas en blanco también se imprimen tal cual aparecen en el código del programa.
=================================================================================
Ahora vamos a revisar cada línea del programa:

#!/usr/bin/perl

Este comentario hace referencia a la ubicación del intérprete de perl, que se encuentra en /usr/bin/perl. En unix basta con escribir en la consola which perl para saber dónde está el intérprete. Copie esa dirección en la primera línea del programa después de #!

print 'Su cuenta

Pan:    $34.45
Fruta:  $45.00
        ======
        $79.45';

En realidad esta es una sola instrucción. La función print imprime lo que se muestra a continuación. Las comillas sencillas sirven para imprimir todo lo que viene a continuación, tal cual aparece, como se ve en la ejecución.

¿Cómo puedo saber si mi tarjeta de red está siendo detectada?

EL COMANDO lspci
El comando lspci lista todos los componentes tipo pci (Peripheral Component Interconnec) como son las tarjetas de red, tarjetas de sonido o tarjetas de televisión. En la siguiente imagen se muestra en dónde se conectan dichas tarjetas.

Slots (ranuras de inserción) de los componentes pci en una motherboard.


Para ver cada uno de los componentes basta con utilizar el comando lspci.

lspci

DETECTAR LA TARJETA DE RED
Sin embargo, si queremos encontrar específicamente un componente, digamos la tarjeta de red, basta usar la siguiente línea:

lspci | grep -r Ethernet

que en mi computadora presenta:

00:07.0 Bridge: nVidia Corporation MCP61 Ethernet (rev a2)

Si al ejecutar esta línea no aparece ningún resultado, entonces no tenemos tarjeta de red o la tarjeta no está detectada.
DETECTAR LA TARJETA DE SONIDO
O para detectar la tarjeta de audio:

lspci | grep -r Audio

Y si al ejecutar este par de comandos no aparece ningún resultado, entonces la tarjeta de sonido no está detectada.
EL COMANDO dmesg
Es posible que algunas distribuciones linux, o versiones distintas de Unix, no tengan disponible el comando lspci. Sin embargo, común a todos los Unix es el comando dmesg, que muestra el contenido de el hardware. Una llamada simple a dmesg bastará para detectar la tarjeta de red; sin embargo, la información enviada será mucha. Es necesario hacer un filtrado con el comando grep:

dmesg | grep eth

y debería aparecer una línea. Si de nuevo no obtenemos resultado, la tarjeta no está siendo detectada. En algunos casos sólo bastará ajustar bien la tarjeta en la ranura, ya que después de un leve golpe es común que se desconecte.

Los Niveles de Ejecución en Linux

Los niveles de ejecución de Unix o runleves, en inglés, indican el modo en el que el sistema será iniciado. Los niveles son indicados mediante los números del 0 al 6. En la mayoría de los Unix y distribuciones Linux (aunque no podría decir que en todas) el nivel de ejecución son los siguientes:
EL ARCHIVO /etc/inittab:
0 indica halt o apagado de la máquina.
1 Indica monousuario.
2 Indica modo multiusuario sin soporte de red.
3 Indica modo multiusuario completo con soporte de red.
4 No usado, con esta opción el administrador puede personalizar el inicio para cargar algún servicio.
5 Indica multiusuario completo con inicio gráfico (X11) (Aunque en Solaris indica shutdown)
6 Indica shutdown y reboot: Se apaga inmediatamente la máquina para reinicio.

Los modos específicos para una distribución particular se encuentran en el archivo /etc/inittab
En mi máquina, con Mandriva, una sección de ese archivo es la siguiente:

# Default runlevel. The runlevels used by Mandriva Linux are:
#   0 - halt (Do NOT set initdefault to this)
#   1 - Single user mode
#   2 - Multiuser, without NFS (The same as 3, if you do not have networking)
#   3 - Full multiuser mode
#   4 - unused
#   5 - X11
#   6 - reboot (Do NOT set initdefault to this)
# 
id:5:initdefault:

Las líneas precedidas por el sígno numeral # son comentarios. En los comentarios se indica cuáles son los runleves de mandriva, los cuales coinciden con los presentadas aquí. Al final de los comentarios, en color rojo, aparece la línea:

id:5:initdefault:

Ésto quiere decir que cuando el sistema arranca, lo hace en el modo 5, que, como hemos visto, indica multiusuario completo (con red y modo gráfico). Observe que en los comentarios de los modos 0 y 6 aparece un par de recomendaciones importantes: NO establezca el valor default de init en este número. ¿Por qué no?
Un administrador (root) puede editar el archivo /etc/inittab como mejor convenga al usuario, sin embargo también tiene el poder de establecerlo en 0 ó en 6. Si se establece en 6, algo que hice como experimento en mi Mandriva, la próxima vez que la máquina se encienda, se leerá el modo 6, shutdown y reboot, y se hará exactamente eso. De hecho se crea un ciclo infinito de reinicios que puede ser desconcertante para el usuario. Algo similar pasa al establecer el modo de ejecución en 0, cada vez que se enciende la computadora, inmediatamente se apaga. La manera de cambiar esto es entrar en modo recover y editar de nuevo el archivo /etc/inittab.
Pero si no deben establecerse, ¿Por qué están ahí? La razón es que otros usuarios pueden requerirlos realmente.
EL COMANDO init:
Aparte de editar el archivo /etc/inittab, el administrador puede cambiar en cualquier momento el valor del nivel de ejecución con el comando init. Una instrucción como la siguiente:

# init 3

cambia a nivel de ejecución 3. Si hace esto dejará de tener una pantalla gráfica y aparecerá una terminal y es probable que pierda la información que no tenga guardada. Para regresar al modo gráfico es necesario establecer de nuevo a 5 (o 2 si se usa Ubuntu, ver más abajo). El comando init no altera el contenido del archivo /etc/inittab.
Y la instrucción

# init 0

apaga la computadora inmediatamente. Los comandos halt y shutdown llaman a init para apagar el sistema.
PARA VER EL NIVEL DE EJECUCIÓN ACTUAL:
¿Cómo podemos saber cuál es el nivel de ejecución actual del sistema?
Con el comando who y la opción -r

$ who -r

se obtiene

`run-level' 5 2012-06-16 11:08

También con el comando runlevel. La instrucción

runlevel

produce

N 5

N indica que no se ha cambiado el runlevel con el comando init. Si se hubiera cambiado antes, aparecería un número indicando en nivel alterior, 5, indica el nivel actual.
EN UBUNTU:
Para no variar, Ubuntu es distinto. El archivo /etc/inittab fue sustituído a partir de la versión 6.10 por /etc/upstart, el cual ahora también ha cambiado. Y los niveles de ejecución son los siguientes:

0 - shutdown
1 - modo monousuario
2 - modo gráfico monousuario
6 - reboot

Así que si uso el comando runlevel en mi Ubuntu 11.04 natty aparece

N 2

FUENTES:
Las fuentes en internet se pueden encontrar en mi delicious