Certificación LPI 102

Certificación LPI 102 - Base de Conocimiento http://www2.linuxparatodos.net/web/comunidad/base-de-conocimiento...
Inicio » Certificación LPI »
Certificación LPI 102

Etiquetas: lpi
Tabla de Contenidos [-]
1 Shell, Scripting y Manejo de datos

1.1 Personalizando y conociendo el shell
1.1.1 Archivos de configuracion de BASH
1.1.2 Fichero ~/inputrc
1.1.3 Diferencias entre ~/.bash_profile , ~/.bashrc y /etc/profile, /etc/bashrc
1.1.4 Variables de entorno
1.1.5 Como establecer la variable PATH
1.1.6 Variables locales y globales de Shell
1.1.7 Alias para el Shell Bash
1.1.8 Funciones de Shell Bash
1.2 Personalizar o escribir scripts simples
1.2.1 Sentencia if
1.2.2 Sentencia for
1.2.3 Sentencia while y until
1.2.4 Sentencia case
1.2.5 Sentencia select
1.3 Manejo de datos en MySQL
1.3.1 Conectarse y desconectarse del servidor
1.3.2 Conectarse y desconectarse del servidor
1.3.3 Crear y utilizar una base de datos
2 Instalar y configurar X Window System
2.1 Sobre X Window Systemn
2.1.1 Instalando X Window System
2.2 Configurando el entorno X Window System
2.2.1 Especificaciones del monitor
2.2.2 Chip y cantidad de memoria de la tarjeta grafica
2.2.3 Especificaciones del mouse
2.2.4 Especificaciones del teclado
2.3 Fichero xorg.conf
2.3.1 Seccion “Files”
2.3.2 Seccion “Modules”
2.3.3 Seccion “InputDevice”
2.3.4 Seccion “Device”
2.3.5 Seccion “Monitor”
2.3.6 Seccion “Screen”
2.3.7 Seccion “ServerLayaout”
3 Tareas Administrativas
3.1 Administrando cuentas de usuario, grupos y ficheros del sistema
3.1.1 Fichero /etc/passwd
3.1.2 Fichero /etc/shadow
3.1.3 Administración de cuentas de usuario
3.1.4 Administración de grupos
3.1.5 Fichero /etc/group
3.1.6 Fichero /etc/gshadow
3.1.7 pwconv y pwunconv
3.1.8 grpconv y grpunconv
3.2 Automatizar tareas de administración del sistema mediante la programación de scripts de trabajo
3.2.1 Sobre CRON
3.2.2 El crontab de root
3.2.3 Directorios predefinidos: hourly, daily, weekly y monthly
3.2.4 Crontab del sistema
3.2.5 Log de cron
3.3 Administrando la hora del equipo
3.3.1 Reloj de tiempo bajo linux
3.3.2 Programas para controlar el reloj del sistema
3.3.3 Ajustes de tiempo y de las zonas horarias
3.3.4 Ajuste de la hora en Linux
1 de 63 24/07/2010 11:53 p.m.

3.3.5 Comando hwclock

3.3.6 Comando date
4 Servicios Esenciales del Sistema
4.1 Mail Transfer Agent Basico
4.1.1 Protocolo SMTP
4.1.2 Protocolo POP3
4.1.3 Protocolo IMAP
4.1.4 Sobre Sendmail
4.1.5 Sobre Postfix
4.1.6 Sobre Exim
4.1.7 Sobre Qmail
4.2 Administrar impresoras e impresiones
4.2.1 Como imprimir en Linux
4.2.2 En que consiste el sistema de impresion CUPS
4.2.3 Instalar una impresora local con CUPS
4.2.4 Compartir nuestra impresora
5 Fundamentos de Red
5.1 Fundamentos de TCP/IP
5.1.1 Sobre TCP/IP
5.1.2 Desarrollo de TCP/IP
5.1.3 Niveles en la pila TCP/IP
5.2 Protocolo TCP
5.2.1 Establecimiento de la conexion
5.2.2 Transferencia de datos
5.2.3 Tamaño de ventana TCP
5.2.4 Escalado de ventana
5.2.5 Fin de la conexion
5.2.6 Puertos TCP
5.3 Protocolo UDP
5.3.1 Puertos TCP
5.4 Diferencias entre TCP y UDP
5.5 Tabla de Puertos TCP y UDP
5.6 Direcciones IP
5.6.1 Direcciones IPv4
5.6.2 Mascara de una direccion IP
5.6.3 Creacion de Subredes
5.6.4 IP dinamica
5.6.5 IP fija
5.6.6 Direcciones IPv6
5.7 Fichero /etc/services
5.8 FTP
5.9 Telnet
5.10 Ping
5.11 Dig
5.12 Traceroute
5.12.1 Funcionamiento
5.12.2 Configuracion de los parametros de Red
6 Configuracion de la interfaz de red
7 Tareas de Administracion de Seguridad
7.1 El Protocolo SSH
7.2 Acerca de OpenSSH
7.3 Instalando OpenSSH
7.3.1 Archivos de configuración de OpenSSH
7.3.2 Archivos de configuración del lado del servidor
7.3.3 Archivos de configuración del lado del cliente
7.3.4 Configuración de fichero sshd_config
7.4 Iniciar, detener o reiniciar el servidor openSSH
7.5 Anexando el servicio de SSH al arranque del servidor
7.6 Aprendiendo a utilizar openSSH
8 Copiar u obtener archivos o carpetas desde un equipo remoto
8.0.1 Copiando ficheros a través de SCP (Shell Secure Copy)
8.0.2 Subir o enviar archivos o carpetas a un equipo remoto
2 de 63 24/07/2010 11:53 p.m.

Shell, Scripting y Manejo de datos
Personalizando y conociendo el shell
El shell es un interprete de comandos para la interaccion entre el usuario y el hardware del equipo. Existen diferentes variantes del SHELL, de las
cuales las mas conocidas son el bash, el csh o zsh. El mas utilizado debido a sus grandes cualidades es el bash. El kernel o nucleo del sistema es el
responsable de la comuncacion entre los programas, las instrucciones de bajo nivel y el hardware del sistema. Este capítulo explica cómo
personalizar su sistema modificando sus archivos de inicialización y estableciendo las variables de entorno más comunes
Archivos de configuracion de BASH

Los archivos de inicialización encargados de la configuración del sistema dependen del shell que el administrador del sistema haya especificado
como shell predeterminado cuando instaló el sistema. El Shell Bourne es el shell predeterminado para la mayoria de los sistemas operativos
GNU/LINUX, pero también puede usar el C shell o el Korn Shell . Cada uno de estos shell dispone de su propio archivo o archivos de inicialización.
Si no estás seguro de que shell es el shell predeterminado de su equipo ejecute el siguiente comando:
[BASH]# echo $SHELL

/bin/bash
Observe la salida del comando. Si es
/bin/bashSu shell de entrada sera el Shell Bourne

/bin/csh Su shell de entrada sera el shell C
/bin/ksh Su shell de entrada sera el shell Korn
Sin tener en cuenta el shell que esté usando, cuando entra por primera vez en el sistema, éste procesa generalmente el archivo perfil: /etc/profile.
Usualmente, el administrador del sistema es el dueño de este archivo, y los usuarios lo pueden leer pero no escribir en él. Después de que el sistema
ejecute el perfil del sistema, este procesa el perfil del usuario contenido en el fichero ~/.bash_profile. El perfil del usuario es uno o varios archivos
de inicialización que definen el entorno de trabajo. Por ejemplo, si javier se encuentra en el entorno fedora su sistema comprobará dicho archivo o
grupo de archivos cada vez que empiece una nueva Herramienta del shell o una ventana de la Herramienta de comandos. Según que shell
predeterminado esté establecido, su perfil de usuario será uno de los siguientes:
.bash_profile (para los shell Bourne y Korn)

.login y .cshrc (para el shell C)
Su fichero o ficheros de perfil de usuario están situados en su directorio de usuario y le permiten configurar su entorno de trabajo según sus
preferencias.
Fichero /etc/profile
Este fichero contiene la configuracion del sistema y se ejecuta durante el inicio de cada sesion, contiene la definicion de las variables globales para
todos los usuarios.
Fichero /etc/bashrc
Fichero con las funciones y los alias comunes que sera invocado a travez del fichero ~/bashrc de cada usuario.
Ficheros ~/.bash_profile , ~/.bash_logout y ~/.bashrc
Existen tres ficheros en el directorio de cada usuario los cuales tienen un significado especial para el shell Bash. Estos ficheros permiten al usuario
configurar el entorno de su cuenta automaticamente cuando entra en el sistema, cuando arranca un subshell o ejecutar comandos cuando sale del
sistema. Los nombres de estos ficheros son ~/.bash_profile, ~/.bashrc y ~/.bash_logout. Si ninguno de estos ficheros existe en el directorio del
usuario, /etc/profile es utilizado por el sistema como fichero de configuracion de bash.
~/.bash_profile
Este fichero es el mas importante de los tres. Es leido y los comandos incluidos en el, ejecutados, cada vez que el usuario entra en el sistema.
Cualquier cambio hecho en este fichero no tendra efecto hasta que salgamos y entremos en el sistema de nuevo. Bash permite dos sinonimos para
este fichero, .bash_login (derivado del C shell) y .profile (derivado del Bourne y Korn shell). Si .bash_profile no existe, el sistema buscara primero
.bash_login y luego .profile. Solamente uno de estos ficheros es leido, en el caso que existan simultaneamente.
~/.bashrc
Es leido cuando el usuario arranca un subshell, escribiendo por ejemplo bash en la linea de comandos. Esto nos permite ejecutar diferentes
comandos para la entrada al sistema o para la ejecucion de un subshell.
~/.bash_logout
Es el fichero leido por Bash, cuando salimos del sistema. Podemos definir, por ejemplo que se borren los ficheros temporales creados en nuestra
ultima sesion o registrar el tiempo que hemos estado utilizando el sistema. Si .bash_logout no existe, ningun comando sera ejcutado a nuestra salida.
Fichero ~/inputrc
3 de 63 24/07/2010 11:53 p.m.

Define las opciones de entrada del teclado. Para eliminar el sonido de error se agrega la siguiente linea al final del fichero
set bell-style none
Su fichero de configuracion global es el fichero
/etc/inputrc
Diferencias entre ~/.bash_profile , ~/.bashrc y /etc/profile, /etc/bashrc
Solo existe una sola copia de los archivos /etc/profile y /etc/bashrc.

Cada usuario tiene su propia copia de los archivos .bashrc y .bash_profile. (Estos archivos se encuentran en el directorio personal de cada
usuario.
Los archivos /etc/profile y /etc/bashrc afectan a todos los usuarios. Por tanto son gestionados por root
Como cada usuario tiene su propia copia de los archivos .bashrc y .bash_profile, su copia le pertenece y se la puede autogestionar
Variables de entorno
El sistema establece el entorno de sistema mediante un conjunto de especificaciones definidas en los archivos de inicialización. Si desea modificar
temporalmente su entorno para la sesión actual de trabajo puede escribir comandos directamente en su BASH. Sin embargo, si desea modificar su
entorno de trabajo de un modo más permanente, puede almacenar variables de entorno “permanentes” en los archivos .bash_profile, .bash_login, o
.cshrc.
Para mostrar las variables de entorno establecidas actualmente asignadas en su sistema teclee lo siguiente :
[BASH]# env
HISTORY=100
HOME=/home/hack
HZ=100
LOGNAME=hack
MAIL=/var/spool/mail/hack
MANSECTS=\1:1m:1c:1f:1s:1b:2:\3:3c:3i:3n:3m:3k:3g:3e:3x11:3xt:3
w:3b:9:4:5:7:8
PATH=/usr/bin
SHELL=/bin/bash
TERM=xterm
TZ=EST5EDT
A continuacion tenemos la lista de variables reservadas por el interprete de comandos mas comunes. Todas ellas tienen un significado especial para
el mismo, algunas de ellas solo se pueden leer, a otras se le asignan ciertos valores automaticamente y algunas pierden su significado si le
cambiamos los valores que tienen por defecto. Muchas de dichas variables pueden estar ya incluidas en su perfil de usuario. Como ya se mencionó
anteriormente en su archivo de perfil de usuario (.bash_profile para los shell Bourne y Korn, y .cshrc para el shell C).
Especifica los directorios que se han de buscar cuando se escribe un único nombre de directorio sin un nombre de ruta de
CDPATH
acceso completo.
Define la ruta de acceso absoluta de su directorio raíz. El sistema utiliza esta información para determinar que el directorio cambie
HOME
cuando escriba el comando cd sin argumentos.
Una lista de caracteres para separar campos; usado cuando el interprete de comandos separa palabras como parte de una
IFS
expansion.
Si este parametro tiene un fichero definido y la variable MAILPATH no esta definida, bash informa al usuario de la llegada de
MAIL
correo al fichero especificado.
Una lista de ficheros separada por comas, en los cuales el interprete de comandos comprueba periodicamente de la llegada de
MAILPATH
correo.
PATH Una lista de directorios, separados por comas, en los cuales el interprete de comandos busca por comandos
PS1 Prompt principal. El valor por defecto es “'\s-\v\$ '
PS2 El prompt secundario. El valor por defecto es '> '
BASH La ruta de acceso completa usada para ejecutar la instancia actual de bash
Si esta variable esta definida cuando bash es llamado para ejecutar un script, su valor es expandido y usado como el nombre del
BASH_ENV
fichero leido antes de ejecutar el script.
BASH_VERSIONEl numero de version de bash usada
EUID El identificador numerico de usuario del usuario actual
GROUPS Una matriz que contiene la lista de los grupos a que pertenece el usuario actual
HISTFILESIZE El numero maximo de lineas contenidas en la historia de comandos, por defecto 500
HOSTNAME El nombre de maquina actual
HOSTTYPE Cadena describiendo la maquina que esta ejecutando Bash
MACHTYPE Cadena describiendo el tipo de sistema que esta ejecutando Bash
OLDPWD Directorio previo definido por el comando 'cd'
4 de 63 24/07/2010 11:53 p.m.

OSTYPE Cadena describiendo el sistema operativo que esta ejecutando Bash

PPID El numero de proceso del proceso padre del interprete de comandos
PS3 El valor de esta variable se usa como 'prompt'
PWD Directorio actual definido por el comando 'cd'
SECONDS Numero de segundos desde que Bash fue arrancado
SHELLOPTS Lista con opciones de Bash activadas
UID El valor numerico real del usuario actual
Como establecer la variable PATH

La variable de entorno PATH se usa para ubicar comandos dentro de la jerarquía de directorios de GNU/LINUX. Al fijar PATH se crea un conjunto de
directorios fijos que el sistema buscará siempre que un usuario. escriba el nombre de un comando.
Por ejemplo, si no tiene establecida ninguna variable PATH y quiere copiar un archivo, tendrá que introducir el nombre de ruta de acceso completo
para el comando, /usr/bin/cp. Sin embargo, si ha establecido la variable PATH para incluir el directorio /usr/bin, podrá simplemente escribir cp y el
sistema ejecutará siempre el comando. Esto es debido a que su sistema busca el comando cp en todos los directorios nombrados en la variable
PATH y lo ejecuta cuando lo encuentra. Para los shell Bourne y Korn, la variable PATH se especifica en el archivo .bash_profile de su directorio
personal utilizando la siguiente sintaxis:
PATH=/usr/bin:/home/bin
Variables locales y globales de Shell

Estas variables pueden ser variables locales y son definidas solo en el BASH local. Tu puedes pasar estas variables de locales a globales
exportandolas a tu entorno de desarrollo
Ejemplo:
[BASH]# saludo='Linux Para Todos'

[BASH]# echo $saludo
Linux Para Todos
[BASH]# bash
[BASH]# exit
exit
Como podemos observar asignamos a la variable “saludo” la cadena “Linux Para Todos” y luego mostramos su contenido. Seguido a ello invocamos
una segunda terminal y nuevamente imprimimos el contenido de la variable “saludo”, la cual no es mostrada debido a que es una variable local y no
global. Para solucionar este problema se debe exportar la variable local lo cual hara que la variable se convierta en variable global.
Ejemplo:
[BASH]# saludo='Linux Para Todos'

[BASH]# export saludo
[BASH]# bash
Linux Para Todos
[BASH]# exit
exit
El comando “export” convierte la variable local a global, para excluir la variable recien exportada use el comando “unset”
Ejemplo:
[BASH]# unset saludo
Alias para el Shell Bash

El comando alias permite al usuario crear atajos a los comandos mas implementados.
Ejemplo:
[BASH]# ls
amsn_received Documents Objetivos.png
RPM-Como.pdf bin kernelfedora.pdf
El comando anterior tiene la funcion de listar el contenido de un directorio, suponga que usted quisiera implementar este comando para ademas de
listar el contenido le arroje datos mas relevantes como por ejemplo, permisos de ejecucion, numero de enlaces, fecha de creacion y tamaño, para
ello se implementan los alias de comandos.
5 de 63 24/07/2010 11:53 p.m.

Ejemplo:
[BASH]# alias ls='ls -l'

[BASH]# ls
drwx------ 2 hack users 4096 jun 29 09:46 amsn_received
drwxr-xr-x 2 hack users 4096 jun 9 05:01 bin
drwxr-xr-x 2 hack users 4096 jun 9 05:01 Documents
-rwxr-xr-x 1 hack users 64472 jun 1 17:23 Objetivos.png
-rwxr-xr-x 1 hack users 78002 jun 5 15:25 RPM-Como.pdf
-rw-r--r-- 1 hack users 1439863 jun 16 10:38 kernelfedora.pdf
Para eliminar los alias asignados use el comando “unalias”
[BASH]# unalias ls
Funciones de Shell Bash

Las funciones son muy perecidas a los alias pero estas admiten una gama mas amplia de instrucciones para su ejecución. Las funciones se
construyen mediante la siguiente sintaxis
unction nombreDeLafuncion() {listaDeComandos;}
Donde
function Orden que invoca al comando function , es opcional

nombreDeLaFuncion() El nombre de la funcion
listaDeComandos El cuerpo de la funcion
Ejemplo:Construyendo una funcion
[BASH]# function listado() { pwd; ls;}
La funcion anteriormente definida se usa de la siguiente manera:
[BASH]# function
/home/valdo/lpic/general-linux-2/notes
CVS _whizzy_gl2.notes.fmt
_whizzy_gl2.notes.pag
Ejemplos validos en la declaracion de funciones
[BASH]# function look() { pwd; ls;}
[BASH]# function look { pwd; ls; }
[BASH]# $ look() { pwd; ls;}
[BASH]# look()
> {
> pwd;
> ls;
> }
Ejemplos invalidos en la declaracion de funciones
[BASH]# function look() pwd; ls;
[BASH]# look() { pwd; ls }
[BASH]# function look() {pwd; ls;}
Personalizar o escribir scripts simples
En este capitulo estudiaremos la forma de crear sencillos scripts mediante la implementacion de sentencias de ontrol. Estas construcciones nos
ayudan a controlar la ejecucion de un script y a obtener diversos resultados dependiendo de las condiciones que se cumplan o no cuando
ejecutamos el script.
En Bash existen estas construcciones para controlar el flujo de ejecucion de un script:
6 de 63 24/07/2010 11:53 p.m.

if/else: Ejecuta una serie de comandos dependiendo si una cierta condicion se cumple o no.
for: Ejecuta una serie de comandos un numero determinado de veces.
while: Ejecuta una seria de comandos mientras que una determinada condicion sea cumpla.
until: Ejecuta una serie de comandos hasta que una determinada condicion se cumpla.
case: Ejecuta una o varias listas de comandos dependiendo del valor de una variable.
select: Permite seleccionar al usuario una opcion de una lista de opciones en un menu.
La mayoria de condiciones utilizadas con estas construcciones son comparaciones de cadenas alfanumericas o numericas, valores de terminacion
de comandos y comprobaciones de atributos de ficheros. Antes de seguir viendo como estas construcciones se pueden utilizar, vamos a ver como
las condiciones se pueden definir.
Comparaciones de cadenas alfanumericas
Operador Significado
cadena1 = cadena2 cadena1 es igual a cadena2
cadena1 != cadena2cadena1 no es igual a cadena2
cadena1 < cadena2 cadena1 es menor que cadena2
cadena1 > cadena 2cadena1 es mayor que cadena 2
-n cadena1 cadena1 no es igual al valor nulo (longitud mayor que 0)
-z cadena1 cadena1 tiene un valor nulo (longitud 0)
Comparacion de valores numericos
x -lt y x menor que y
x -le y x menor o igual que y
x -eq y x igual que y
x -ge y x mayor o igual que y
x -gt y x mayor que y
x -ne y x no igual que y
Comparaciones de atributos de fichero
-d fichero Fichero existe y es un directorio
-e fichero Fichero existe
-f fichero Fichero existe y es un fichero regular
-r fichero Tienes permiso de lectura en fichero
-s fichero Fichero existe y no esta vacio
-w fichero Tienes permiso de escritura en fichero
-x fichero Tienes permiso de ejecucion en fichero
-O fichero Eres el dueño del fichero
-G fichero El grupo del fichero es igual al tuyo
fichero1 -nt fichero2fichero1 es mas reciente que fichero2
fichero1 -ot fichero2fichero1 es mas antiguo que fichero2
Sentencia if
La sentencia if es un condicional simple, tal vez la hayas visto antes en algunos otros lenguajes de programacion.
Su sintaxis es la siguiente:
if cmd
then
cmd1
cmd2
cmdn
elif cmd3
then
cmd4
else
cmd5
cmd6
cmdm
fi
La sentencia if trabaja de la siguiente forma: En caso que el comando cmd haya sido ejecutado con éxito, los comandos del bloque del then (cmd1,
cmd2 y cmdn) serán ejecutados, en caso contrario, los comandos ejecutados serán los del bloque opcional elif el cual verifica los comandos del
7 de 63 24/07/2010 11:53 p.m.

bloque del then (cmd3) los cuales seran ejecutados, en caso contrario sera pasado al siguiente bloque, el else (cmd3, cmd4 y cmdm), terminando
con un fi.
Ejemplo
#!/bin/bash
echo ' Adivina el valor numerico de la variable'
read A
if [ $A = 1 ]
then
echo "Acertaste"
exit 0
elif [ $A = 2 ]
then
echo "Muy cerca"
else
echo "Lejosss...."
fi
exit 0
Sentencia for
El bucle for en Bash es un poco distinto a los bucles for tradicionales de otros lenguajes como C o Java, sino que se parece más al bucle for each
de otros lenguajes, ya que aquí no se repite un número fijo de veces, sino que se procesan las palabras de una frase una a una. Su sintaxis es la
siguiente:
for var [in lista]

do

Sentencias que usan $var

done
Si se omite in lista, se recorre el contenido de $@, pero aunque vayamos a recorrer esta variable, en este tutorial la indicaremos explícitamente por
claridad. Por ejemplo si queremos recorrer una lista de planetas podemos hacer:
for planeta in Mercury Venus Terra Marte Jupiter Saturno

do
echo $planeta # Imprime cada planeta en una línea
done
La lista del bucle for puede contener comodines. Por ejemplo, el siguiente bucle muestra información detallada de todos los ficheros en el directorio
actual:
for fichero in *
do
ls -l "$fichero"
done
Sentencia while y until

La sintaxis del comando while es la siguiente:
while comando
do

done
La sintaxis del comando until es la siguiente:
until comando
do

done
En este caso el comando también puede ser una condición encerrada entre . La única diferencia entre while y until es que while se ejecuta mientras
que el código de terminación del comando sea exitoso, es decir 0, mientras que until se ejecuta hasta que el código de terminación sea exitoso,
según esto until se puede interpretar como ejecutar varias veces un comando hasta que tenga exito.
8 de 63 24/07/2010 11:53 p.m.

Ejemplo
#!/bin/bash
# Script que muestra los directorios de PATH
path=$PATH
while [ $path ]; do
echo ${path%%:*}
if [ ${path#*:} = $path ]; then
path=
else
path=${path#*:}
fi
done
Sentencia case
Mientras que esta sentencia en lenguajes como C o Java se usa para comprobar el valor de una variable simple, como un entero o un carácter, en
Bash esta sentencia permite realizar una comparación de patrones con la cadena a examinar.
Su sintaxis es la siguiente:
case cadena in
patron1)
Sentencias ;;
patron2)
Sentencias ;;

esac
Cada patrón puede estar formado por varios patrones separados por el carácter |. Si cadena cumple alguno de los patrones, se ejecutan sus
correspondientes sentencias (las cuales se separan por ;) hasta ;;.
Ejemplo:
/bin/bash
# Script que convierte ficheros de imagen al formato .jpg
for fichero in "$@"
do
fichero_ppm=${fichero%.*}.ppm
case $fichero in
*.jpg) exit 0;;
*.tga) tgatoppm $fichero > $fichero_ppm;;
*.xpm) xpmtoppm $fichero > $fichero_ppm;;
*.pcx) pcxtoppm $fichero > $fichero_ppm;;
*.tif) tifftopnm $fichero > $fichero_ppm;;
*.gif) figtoppm $fichero > $fichero_ppm;;
*.pnm|*.ppm) ;;
*) echo "Formato .${fichero##*.} no soportado"
exit 1;;
esac
fichero_salida=${fichero_ppm%.ppm}.jpg
pnmtojpeg $fichero_ppm > $fichero_salida
if ! [ $fichero = $fichero_ppm ]; then
rm $fichero_ppm
fidone
Sentencia select
La sentencia select nos permite generar fácilmente un menú simple. Su sintaxis es la siguiente:
select variable [in lista]

do
Sentencias que usan $variable
done
Vemos que tiene la misma sintaxis que el bucle for, excepto por la palabra select en vez de for. La sentencia genera un menú con los elementos de
lista, donde asigna un número a cada elemento, y pide al usuario que introduzca un número. El valor elegido se almacena en variable, y el número
elegido en la variable REPLY. Una vez elegida una opción por parte del usuario, se ejecuta el cuerpo de la sentencia y el proceso se repite en un
9 de 63 24/07/2010 11:53 p.m.

bucle infinito. Aunque el bucle de select es infinito (lo cual nos permite volver a pedir una opción cuantas veces haga falta), el bucle se puede
abandonar usando la sentencia break. La sentencia break, al igual que en C y Java, se usa para abandonar un bucle, y se puede usar en el caso,
tanto de select, como de los bucles for, while y until. Pero a diferencia de C y Java no sirve para abandonar la sentencia case, sino que ésta se
abandona usando los dos puntos comas ;;. El prompt que usa la función es el definido en la variable de entorno PS3, y es habitual cambiar este
prompt antes de ejecutar select para que muestre al usuario un mensaje más descriptivo. Por defecto el valor de PS3 es #?, lo cual no es un prompt
que suela gustar especialmente a los usuarios.
Manejo de datos en MySQL
Conectarse y desconectarse del servidor

Para conectarse al servidor, generalmente se le porporcionará a mysql un nombre de usuario y una contraseña. Si el servidor se está ejecutando en
un ordenador distinto a donde está estableciendo la conexión, también se deberá especificar el nombre de host. Consulte con su administrador para
saber los parámetros de conexión (nombre de usuario, contraseña y host) que debe emplear. Una vez que conozca los parámetros apropiados,
debería poder conectarse de este modo:
[BASH]# mysql -h host -u user -p

Enter password: ********
host y user representan el nombre del ordenador donde se está ejecutando el servidor de bases de datos MySQL y el nombre de usuario de la
cuenta que se usará para conectarse. Reemplácelos por los valores apropiados para elcaso. Los asteriscos (********) representan la contraseña,
debe ingresarse cuando mysql muestra Enter password:.
Si todo funciona bien, se verá una información de ingreso seguida por el prompt mysql>:
[BASH]# mysql -h host -u user -p

Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 25338 to server version: 5.0.9-beta-standard
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
mysql>
El prompt anuncia que mysql está listo para procesar comandos. Algunas instalaciones de MySQL permiten conectarse como usuario anónimo (sin
nombre) si el servidor se está ejecutando en el ordenador local. Si esto sucede en su caso, deberia poder conectarse al servidor ejecutando mysql
sin ningún parámetro:
[BASH]# mysql
Después de haberse conectado, puede desconectarse en cualquier momento escribiendo QUIT (o \q) en el prompt mysql>:
mysql> QUIT
Bye
En Unix, también puede desconectarse presionando Control-D. La mayoría de los ejemplos en las secciones siguientes asumen que ya se ha
conectado al servidor. Por eso muestran el prompt mysql>.
Conectarse y desconectarse del servidor

Cerciórese de haberse conectado al servidor, tal como se describe en la sección anterior. Esto en sí mismo no selecciona ninguna base de datos
para trabajar. En este punto es más importante aprender un poco más acerca de cómo realizar consultas que ir directamente a crear tablas, cargar
datos, y recuperarlos. Esta sección describe los principios básicos del ingreso de comandos, empleando varias consultas que puede realizar para
familiarizarse con la forma en que funciona mysql. Aquí tiene un comando simple que ordena al servidor que muestre su número de versión y la
fecha actual. Ingréselo a continuación del prompt mysql> y presione Enter:
mysql> SELECT VERSION(), CURRENT_DATE;

+----------------+--------------+
| VERSION() | CURRENT_DATE |
+----------------+--------------+
| 5.0.7-beta-Max | 2005-07-11 |
+----------------+--------------+
1 row in set (0.01 sec)
mysql>
Esta consulta le muestra varias cosas acerca de mysql:
Un comando normalmente consiste en una sentencia SQL seguida de punto y coma. (Hay excepciones donde el punto y coma puede
omitirse. QUIT, mencionado anteriormente, es una de ellas. Luego conocerá otras.)
Cuando ingresa un comando, mysql lo envía al servidor para ser ejecutado e imprime los resultados. A continuación muestra de nuevo el
prompt mysql> para informarle que está listo para otro comando.
10 de 63 24/07/2010 11:53 p.m.

mysql imprime los resultados de la consulta en forma tabulada (filas y columnas). La primera fila contiene etiquetas para las columnas. Las
filas siguientes son los resultados de la consulta. Generalmente, el nombre de cada columna es el nombre del campo que trae desde la base
de datos. Si está trayendo el valor de una expresión, en lugar del contenido de un campo o columna de una tabla (como en el ejemplo
anterior), mysql etiqueta la columna usando el texto de la expresión.
mysql informa cuántas filas fueron devueltas y cuánto tiempo le tomó ejecutarse a la consulta, lo cual da una idea aproximada del rendimiento
del servidor. Estos valores son imprecisos porque representan tiempo de reloj corriente (no tiempo de CPU), y además porque están
afectados por factores como la carga del servidor o la latencia de red. (Para simplificar los ejemplos de este capitulo, a partir de ahora no se
mostrará la línea “rows in set”.)
Las palabras clave pueden ingresarse en cualquier combinación de minúsculas y mayúsculas. Las siguientes consultas son equivalentes:
mysql> SELECT VERSION(), CURRENT_DATE;

mysql> select version(), current_date;
mysql> SeLeCt vErSiOn(), current_DATE;
Aqui tiene otra consulta que demuestra que mysql puede usarse como calculadora:
mysql> SELECT SIN(PI()/4), (4+1)*5;

+------------------+---------+
| SIN(PI()/4) | (4+1)*5 |
+------------------+---------+
| 0.70710678118655 | 25 |
+------------------+---------+
Las consultas mostradas hasta ahora han sido relativamente cortas, sentencias de una sola línea. Se puede inclusive ingresar múltiples sentencias
en una misma línea. Solamente deben separarse con punto y coma:
mysql> SELECT VERSION(); SELECT NOW();

+----------------+
| VERSION() |
+----------------+
| 5.0.7-beta-Max |
+----------------+
+---------------------+
| NOW() |
+---------------------+
| 2005-07-11 17:59:36 |
+---------------------+
No es necesario que un comando sea ingresado en una sola línea, de ese modo, comandos extensos que requieren varias lineas no son un
problema. mysql determina cuando una sentencia ha llegado a l final observando si termina en un punto y coma, no si se llegó al final de la línea
física. (En otras palabras, mysql acepta un formato libre para las entradas: recolecta lineas pero no las ejecuta hasta que encuentra el punto y
coma.)
Aqui tiene una sentencia de múltiples líneas:
mysql> SELECT
-> USER()
-> ,
-> CURRENT_DATE;
+---------------+--------------+
| USER() | CURRENT_DATE |
+---------------+--------------+
| jon@localhost | 2005-07-11 |
+---------------+--------------+
Observe en este ejemplo que el prompt cambia de mysql> a -> después que se ha ingresado la primera línea de una consulta de múltiples líneas.
Esta es la forma en que mysql advierte que no se ha completado la sentencia y aún espera por el resto. El prompt es un aliado, puesto que
suministra información valiosa. Si se emplea, siempre se sabrá lo que mysql está esperando.
Si durante el ingreso de un comando decide que no quiere ejecutarlo, cancélelo tipeando \c:
mysql> SELECT
11 de 63 24/07/2010 11:53 p.m.

-> USER()
-> \c
mysql>
Una vez más observe el prompt. Cambia a mysql> después de que ingresa \c, informándole que mysql está listo para un nuevo comando. La
siguiente tabla muestra cada uno de los indicadores que podrá ver y sintetiza lo que dicen acerca del estado en que se encuentra mysql:
Prompt Significado
mysql> Listo para un nuevo comando.
-> Esperando la siguiente línea en un comando de múltiples líneas
'> Esperando la siguiente línea, se encuentra abierta una cadena que comienza con apostrofo (').
"> Esperando la siguiente línea, se encuentra abierta una cadena que comienza con comillas dobles ('"').
`> Esperando la siguiente línea, se encuentra abierta una cadena que comienza con tilde ('`').
/*> Esperando la siguiente línea, se encuentra abierto un comentario que comienza con /*.
El prompt /*> fue introducido en la serie 5.0 a partir de MySQL 5.0.6. Es frecuente que se origine una sentencia de múltiples lineas cuando
accidentalmente le da entrada a un comando de una sola línea pero olvida terminarlo con punto y coma. En ese caso, mysql aguarda por más
caracteres:
mysql> SELECT USER()

->
Si esto le ocurre (considera que ha ingresado una sentencia completa pero solamente obtiene un prompt ->), la mayoría de las veces es porque
mysql está esperando por el punto y coma. Si no advierte lo que el indicador trata de decirle, podría demorar un buen tiempo en hacer lo que
necesita. Ingrese un punto y coma para completar la sentencia, y mysql la ejecutará:
mysql> SELECT USER()

-> ;
+--------------------+
| USER() |
+--------------------+
| joesmith@localhost |
+--------------------+
Los prompts '> y "> aparecen durante el ingreso de cadenas. Puede escribir cadenas delimitadas por ' o '"' (por ejemplo, 'hola' o "adios"), y mysql
le permite ingresar cadenas divididas en múltiples líneas. Cuando ve un prompt '> o "> significa que ha comenzado a ingresar una cadena
comenzando con ' o '"' pero no ha ingresado el correspondiente caracter de terminación. A menudo esto significa que inadvertidamente omitió este
carácter. Por ejemplo:
mysql> SELECT * FROM my_table WHERE name = 'Smith AND age < 30;
'>
Si ingresa esta sentencia SELECT, presiona ENTER y espera por el resultado, nada ocurrirá. En lugar de asombrarse por el tiempo que consume la
consulta, note lo que el prompt '> le está diciendo. Indica que mysql espera por el final de una cadena inconclusa. (¿Ve el error en la sentencia? La
cadena 'Smith no tiene el apóstrofo de cierre.) ¿Qué hacer llegado a este punto? Lo más simple es cancelar el comando. No obstante, no puede
simplemente tipear \c en este caso, ¡porque mysql interpretará que es parte de la cadena que está ingresando!. En lugar de eso, tipee el caracter de
cierre que falta y entonces ingrese \c.>:
mysql> SELECT * FROM my_table WHERE name = 'Smith AND age < 30;
'> '\c
mysql>
El prompt cambia de nuevo a mysql>, informando que mysql está listo para un nuevo comando. El prompt `> es similar a '> y "> , pero informa que
está pendiente de completar un identificador delimitado por tildes. Es importante conocer el significado de estos indicadores, ya que si por error se
ingresa una cadena incompleta, todo lo que se ingrese posteriormente será aparentemente ignorado por mysql — incluyendo el comando QUIT. Esto
puede ser sumamente desconcertante, en particular si no se conoce lo que debe hacer para terminar la línea y cancelar el comando.
Crear y utilizar una base de datos

Una vez que se sabe la forma de ingresar comandos, es el momento de acceder a una base de datos. Suponga que en su hogar posee varias
mascotas y desea registrar distintos tipos de información sobre ellas. Puede hacerlo si crea tablas para almacenar sus datos e introduce en ellas la
información deseada. Entonces, podrá responder una variedad de preguntas acerca de sus mascotas recuperando datos desde las tablas. Esta
sección le muestra como:
Crear una base de datos

Crear una tabla
Introducir datos en la tabla
Recuperar datos desde la tabla de varias maneras
12 de 63 24/07/2010 11:53 p.m.

Emplear múltiples tablas
La base de datos menagerie (en inglés significa "colección de animales") se ha hecho deliberadamente simple, pero no es difícil imaginar
situaciones del mundo real donde podría usarse un tipo similar de base de datos. Por ejemplo, para un granjero que desee hacer el seguimiento de
su hacienda, o para los registros de los pacientes de un veterinario. En el sitio web de MySQL pueden descargarse archivos de texto con datos de
ejemplo y algunas de las sentencias empleadas en las siguientes secciones.
Mediante la sentencia SHOW se encuentran las bases de datos que existen actualmente en el servidor:
mysql> SHOW DATABASES;

+----------+
| Database |
+----------+
| mysql |
| test |
| tmp |
+----------+
Probablemente la lista obtenida sea distinta en su ordenador, pero es casi seguro que tendrá las bases de datos mysql y test. La base de datos
mysql es necesaria porque es la que describe los privilegios de acceso de los usuarios. La base de datos test se provee para que los usuarios hagan
pruebas. Tenga en cuenta que si no tiene el privilegio SHOW DATABASES, no podrá ver todas las bases de datos que hay en el servidor.
Si la base de datos test existe, intente acceder a ella:
mysql> USE test

Database changed
Advierta que, al igual que QUIT, USE no necesita que ponga un punto y coma al final (aunque puede hacerlo si lo desea). La sentencia USE tiene
otra particularidad: debe escribirse en una sola linea.
Puede colocar los ejemplos siguientes en la base de datos test, si tiene acceso a ella, pero si trabaja en un ambiente compartido, lo que deposite allí
puede ser fácilmente borrado por alguien más que tenga el acceso. Por este motivo, debería pedirle a su administrador permiso para usar una base
de datos propia. Suponga que quiere llamarla menagerie. El administrador necesitará ejecutar un comando como este:
mysql> GRANT ALL ON menagerie.* TO 'su_nombre_mysql'@'su_host_cliente';
Donde su_nombre_mysql es el nombre de usuario que se le asignó, y su_host_cliente es el host u ordenador desde donde se conectará.
Crear y utilizar una base de datos
Si el administrador crea su base de datos en el mismo momento que le otorga privilegios, puede comenzar a utilizarla, de lo contrario necesitará
crearla:
mysql> CREATE DATABASE menagerie;
En ambientes Unix, los nombres de las bases de datos son case sensitive (al contrario que las palabras clave), de modo que siempre debe referirse
a su base de datos como menagerie, y no Menagerie, MENAGERIE, o una variante similar. Esto también se aplica a los nombres de tablas.Esta
restricción no existe en Windows, aunque puede utilizar el mismo esquema de mayúsculas cuando se refiera a bases de datos y tablas en una
consulta dada. Al crear una base de datos, ésta no se selecciona para su uso, debe hacerlo explicitamente. Para convertir a menagerie en la base
de datos actual, use este comando:
mysql> USE menagerie

Database changed
Las bases de datos sólo necesitan ser creadas una sola vez, pero deben ser seleccionadas cada vez que se inicia una sesión de mysql. Puede
hacerse a través del comando USE como se muestra en el ejemplo, o puede indicar la base de datos en la linea de comandos al ejecutar mysql.
Simplemente debe indicar el nombre de la base de datos a continuación de los parámetros que necesite ingresar. Por ejemplo:
shell> mysql -h host -u user -p menagerie

Advierta en el comando anterior que menagerie no es la contraseña. Si se quisiera suministrar la contraseña en la linea de comandos, después de la
opción -p, debe hacerse sin dejar espacios en blanco (por ejemplo, -pmypassword, no -p mypassword). De todos modos, colocar la contraseña en la
linea de comandos no es recomendable porque lo expone a la vista de otros usuarios.
Crear una tabla
La creación de la base de datos ha sido una tarea sencilla, pero hasta ahora permanece vacía, como le muestra SHOW TABLES:
mysql> SHOW TABLES;
13 de 63 24/07/2010 11:53 p.m.

Empty set (0.00 sec)
La parte difícil es decidir cómo debería ser la estructura de su base de datos: qué tablas necesitará, y qué columnas habrá en cada tabla. Querrá
una tabla para contener un registro por cada mascota. Esta tabla puede llamarse pet, y debería contener, como mínimo, el nombre de cada animal.
Dado que el nombre no es muy relevante por sí mismo, tendría que tener más información. Por ejemplo, si más de una persona en su familia tendrá
mascotas, querrá listar también el dueño de cada animal. Y algunos otros datos descriptivos básicos, como especie y sexo. ¿Qué hacer con la
edad? Podría ser de interés, pero no es un buen dato para almacenar en una base de datos. La edad cambia a medida que pasa el tiempo, lo cual
significa que debería actualizar la base de datos a menudo. En lugar de esto, es mejor almacenar un valor fijo, como la fecha de nacimiento. De este
modo, cada vez que requiera saber la edad, podrá calcularla como la diferencia entre la fecha de nacimiento y la fecha actual. MySQL provee
funciones para realizar cálculos con fechas, por lo que no es dificultoso. Almacenar la fecha de nacimiento en lugar de la edad tiene otras ventajas:
Puede usar la base de datos para tareas como generar recordatorios para los próximos cumpleaños de mascotas. (Si piensa que este tipo de
consultas no es importante, considere que es lo mismo que haría en un contexto de base de datos de negocios para identificar aquellos
clientes a los que habrá que enviar una tarjeta por su cumpleaños, para conseguir ese toque personal con la asistencia del ordenador).
Puede calcular edades en relación a otras fechas además de la actual. Por ejemplo, almacenar la fecha de muerte de una mascota le
posibilita calcular la edad que tenía a ese momento.
Probablemente pensará en otros tipos de información que resultarían útiles dentro de la tabla pet pero los identificados hasta ahora son suficientes:
name (nombre), owner (propietario), species (especie), sex (sexo), birth (nacimiento) y death (muerte).
Debe usar la sentencia CREATE TABLE para especificar la estructura de una tabla:
mysql> CREATE TABLE pet (name VARCHAR(20), owner VARCHAR(20),

-> species VARCHAR(20), sex CHAR(1), birth DATE, death DATE);
El tipo de dato VARCHAR es una buena elección para las columnas name, owner, y species porque los datos que allí se almacenan no son de
longitud uniforme. En realidad no es necesario que todas estas columnas tengan la misma longitud ni que ésta sea 20. En MySQL 5.0.3 y versiones
posteriores, normalmente se puede adoptar cualquier longitud entre 1 y 65535, según lo que se crea más razonable. (Nota: Anteriormente a MySQL
5.0.3, el límite de longitud era 255.) Si en el futuro debiera aumentar la longitud de estos campos, MySQL tiene la sentencia ALTER TABLE. Hay
varios tipos de datos que podrían usarse para representar el sexo en los registros de animales, tal como 'm' y 'f', o 'male' (masculino) y 'female'
(femenino). Lo más simple es usar los caracteres 'm' y 'f'. Es obvio el uso del tipo de dato DATE para las columnas birth y death.
Luego de crear una tabla, SHOW TABLES debería producir una salida:
mysql> SHOW TABLES;

+---------------------+
| Tables in menagerie |
+---------------------+
| pet |
+---------------------+
Para verificar que la tabla ha sido creada en la forma esperada, utilice la sentencia DESCRIBE:
mysql> DESCRIBE pet;

+---------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| name | varchar(20) | YES | | NULL | |
| owner | varchar(20) | YES | | NULL | |
| species | varchar(20) | YES | | NULL | |
| sex | char(1) | YES | | NULL | |
| birth | date | YES | | NULL | |
| death | date | YES | | NULL | |
+---------+-------------+------+-----+---------+-------+
DESCRIBE puede ser utilizada en cualquier momento, por ejemplo, si olvida los nombres o el tipo de dato de las columnas de la tabla.
Cargar datos a una tabla
Luego de crear la tabla, necesitará completarla con datos. Para esto, le serán de utilidad las sentencias LOAD DATA e INSERT. Suponga que los
registros de mascotas fueran como los mostrados a continuación. (Observe que MySQL espera que las fechas tengan el formato 'AAAA-MM-DD',
esto puede ser diferente a lo que acostumbra utilizar).
name owner speciessex birth death

Fluffy Harold cat f 1993-02-04
Claws Gwen cat m 1994-03-17
Buffy Harold dog f 1989-05-13
Fang Benny dog m 1990-08-27
14 de 63 24/07/2010 11:53 p.m.

Bowser Diane dog m 1979-08-311995-07-29

Chirpy Gwen bird f 1998-09-11
Whistler Gwen bird 1997-12-09
Slim Benny snake m 1996-04-29
Dado que está comenzando con una tabla vacía, una forma fácil de completarla es creando un fichero de texto que contenga una línea por cada
animal, y luego insertando el contenido del fichero en la tabla mediante una sola sentencia. Para esto, debería crear un fichero de texto llamado
pet.txt, conteniendo un registro por linea, con cada valor separado por un carácter de tabulación, y dispuestos en el orden en el cual se
especificaron las columnas en la sentencia CREATE TABLE. Para valores ausentes (como sexo desconocido o fechas de muerte de animales con
vida), puede usar valores NULL. Para representar estos valores en el archivo de texto, utilice \N (barra diagonal y N mayúscula). Por ejemplo, el
registro de Whistler se vería del modo siguiente (el espacio en blanco entre cada valor es un solo carácter de tabulación):
name owner speciessexbirth death

Whistler Gwen bird \N 1997-12-09\N
Para cargar el fichero pet.txt dentro de la tabla pet, utilice este comando:
mysql> LOAD DATA LOCAL INFILE '/path/pet.txt' INTO TABLE pet;
Si trabaja en Windows, con un editor que emplea \r\n (retorno de carro + nueva linea) como caracteres de fin de línea, debería usar:
mysql> LOAD DATA LOCAL INFILE '/path/pet.txt' INTO TABLE pet

-> LINES TERMINATED BY '\r\n';
(En un ordenador Apple bajo OS X, probablemente quiera utilizar LINES TERMINATED BY '\r'.) Opcionalmente puede especificar en la sentencia
LOAD DATA los caracteres que actuarán como separador de campo y fin de línea, pero los valores por defecto son tabulación y nueva línea. Estos
son suficientes para que la sentencia lea correctamente el fichero pet.txt Cuando lo que desea es agregar nuevos registros de a uno por vez, la
sentencia INSERT resulta de utilidad. De esta sencilla manera, se suministran valores para cada columna, dispuestos en el orden en el cual se
especificaron las columnas en la sentencia CREATE TABLE statement. Suponga que Diane obtiene un nuevo hamster llamado "Puffball". Se podría
agregar un nuevo registro, usando la sentencia INSERT de este modo:
mysql> INSERT INTO pet

-> VALUES ('Puffball','Diane','hamster','f','1999-03-30',NULL);
Observe que las cadenas alfanuméricas y las fechas son representados como cadenas delimitadas por apóstrofos. También, con INSERT, se
pueden insertar valores NULL directamente, para indicar un valor ausente. No se debe utilizar \N como se hace con LOAD DATA. A partir de este
ejemplo queda demostrado que lleva mucho más trabajo realizar una carga inicial de registros empleando varias sentencias INSERT que si se hace
mediante la sentencia LOAD DATA.
Extraer informacion de una tabla
La sentencia SELECT es utilizada para traer información desde una tabla. La sintaxis general de esta sentencia es:
mysql> INSERT INTO pet

-> VALUES ('Puffball','Diane','hamster','f','1999-03-30',NULL);
seleccionar_esto es lo que se quiere ver. Puede ser una lista de columnas, o * para indicar “todas las columnas.” desde_tabla indica la tabla donde
están los datos a recuperar. La cláusula WHERE clause is optional. es opcional. Si está presente, condiciones representa las condiciones que cada
registro debe cumplir para retornar como resultado.
Seleccionar todos los datos======
La forma más simple de SELECT recupera todo lo que hay en la tabla:
mysql> SELECT * FROM pet;

+----------+--------+---------+------+------------+------------+
| name | owner | species | sex | birth | death |
+----------+--------+---------+------+------------+------------+
| Fluffy | Harold | cat | f | 1993-02-04 | NULL |
| Claws | Gwen | cat | m | 1994-03-17 | NULL |
| Buffy | Harold | dog | f | 1989-05-13 | NULL |
| Fang | Benny | dog | m | 1990-08-27 | NULL |
| Bowser | Diane | dog | m | 1979-08-31 | 1995-07-29 |
| Chirpy | Gwen | bird | f | 1998-09-11 | NULL |
| Whistler | Gwen | bird | NULL | 1997-12-09 | NULL |
| Slim | Benny | snake | m | 1996-04-29 | NULL |
| Puffball | Diane | hamster | f | 1999-03-30 | NULL |
+----------+--------+---------+------+------------+------------+
15 de 63 24/07/2010 11:53 p.m.

Esta forma de SELECT es útil si se quiere revisar la tabla completa, por ejemplo, despues de haberla cargado con un conjunto de datos inicial. Por
ejemplo, puede ocurrir que la fecha de nacimiento de Bowser no parezca correcta. Consultando los papeles de pedigri, se descubre que el año
correcto de nacimiento es 1989, no 1979.
Existen al menos dos formas de solucionarlo:
Editando el fichero pet.txt para corregir el error, vaciando la tabla y volviendola a llenar con los datos. Para esto se usan las sentencias
DELETE y LOAD DATA:
mysql> DELETE FROM pet;

mysql> LOAD DATA LOCAL INFILE 'pet.txt' INTO TABLE pet;
No obstante, si opta por esto, deberá volver a cargar el registro de Puffball.
Corrigiendo únicamente el registro erróneo. Para esto se usa la sentencia UPDATE:
mysql> UPDATE pet SET birth = '1989-08-31' WHERE name = 'Bowser';
UPDATE modifica solo el registro en cuestión y no requiere que se vuelva a llenar la tabla.
Seleccionar registros especificos======
Como se ha visto en la sección anterior, es fácil recuperar una tabla en su totalidad. Sólo debe omitir la cláusula WHERE en la sentencia SELECT.
Pero, generalmente, no se desea ver la tabla completa, especialmente cuando alcanza un gran tamaño. En cambio, usualmente, se tiene interés en
obtener una respuesta para una consulta en particular, en cuyo caso se especifican algunas restricciones para la información que se traerá. A
continuación se verán algunas consultas que responden preguntas acerca de las mascotas. Se pueden seleccionar sólo algunos registros de la tabla.
Por ejemplo, si quisiera verificar los cambios realizados sobre la fecha de nacimiento de Bowser, seleccione el registro de Bowser de esta manera:
mysql> SELECT * FROM pet WHERE name = 'Bowser';

+--------+-------+---------+------+------------+------------+
+--------+-------+---------+------+------------+------------+
+--------+-------+---------+------+------------+------------+
salida confirma que el año fue correctamente registrado como 1989, ya no es 1979. Normalmente, las comparaciones de cadenas no son case
sensitive, por eso puede escribir el nombre como 'bowser', 'BOWSER', etc. El resultado de la consulta será el mismo. Se pueden indicar condiciones
a cumplir por cualquier columna, no solamente por name. Por ejemplo, si quisiera saber qué animales han nacido luego de 1998, necesita evaluar la
columna birth:
mysql> SELECT * FROM pet WHERE birth > '1998-1-1';

+----------+-------+---------+------+------------+-------+
+----------+-------+---------+------+------------+-------+
| Puffball | Diane | hamster | f | 1999-03-30 | NULL |
+----------+-------+---------+------+------------+-------+
Se pueden combinar condiciones, por ejemplo para localizar perros hembra:
mysql> SELECT * FROM pet WHERE species = 'dog' AND sex = 'f';
+-------+--------+---------+------+------------+-------+
+-------+--------+---------+------+------------+-------+
+-------+--------+---------+------+------------+-------+
La consulta anterior emplea el operador lógico AND. También existe el operador OR:
mysql> SELECT * FROM pet WHERE species = 'snake' OR species = 'bird';

+----------+-------+---------+------+------------+-------+
+----------+-------+---------+------+------------+-------+
| Slim | Benny | snake | m | 1996-04-29 | NULL |
+----------+-------+---------+------+------------+-------+
16 de 63 24/07/2010 11:53 p.m.

AND and OR pueden ser combinadas, si bien AND tiene mayor precedencia que OR. Si utiliza ambos operadores, es buena idea emplear paréntesis
para indicar explicitamente la forma en que las condiciones deben agruparse:
mysql> SELECT * FROM pet WHERE (species = 'cat' AND sex = 'm')
-> OR (species = 'dog' AND sex = 'f');
+-------+--------+---------+------+------------+-------+
+-------+--------+---------+------+------------+-------+
Seleccionar columnas concretas======
Si no se quieren ver filas completas, solo hace falta indicar las columnas en las que se está interesado, separadas por comas. Por ejemplo, si desea
saber cuándo nació cada animal, seleccione las columnas name y birth:
mysql> SELECT name, birth FROM pet;

+----------+------------+
| name | birth |
+----------+------------+
| Fluffy | 1993-02-04 |
| Claws | 1994-03-17 |
| Buffy | 1989-05-13 |
| Fang | 1990-08-27 |
| Bowser | 1989-08-31 |
| Chirpy | 1998-09-11 |
| Whistler | 1997-12-09 |
| Slim | 1996-04-29 |
| Puffball | 1999-03-30 |
+----------+------------+
Para saber quien posee mascotas, utilice esta consulta:
mysql> SELECT owner FROM pet;

+--------+
| owner |
+--------+
| Harold |
| Gwen |
| Harold |
| Benny |
| Diane |
| Gwen |
| Gwen |
| Benny |
| Diane |
+--------+
Observe que esta sentencia retorna el campo owner de cada registro, y algunos de ellos aparecen más de una vez. Para reducir la salida, recupere
solamente una vez cada registro repetido, agregando la palabra clave DISTINCT:
mysql> SELECT DISTINCT owner FROM pet;

+--------+
| owner |
+--------+
| Benny |
| Diane |
| Gwen |
| Harold |
+--------+
Puede emplearse una clásula WHERE para combinar la selección de ciertas filas y de ciertas columnas. Por ejemplo, para obtener únicamente la
fecha de nacimiento de perros y gatos, ejecute esta consulta:
mysql> SELECT name, species, birth FROM pet
17 de 63 24/07/2010 11:53 p.m.

-> WHERE species = 'dog' OR species = 'cat';

+--------+---------+------------+
| name | species | birth |
+--------+---------+------------+
| Fluffy | cat | 1993-02-04 |
| Claws | cat | 1994-03-17 |
| Buffy | dog | 1989-05-13 |
| Fang | dog | 1990-08-27 |
| Bowser | dog | 1989-08-31 |
+--------+---------+------------+
Ordenar registros====== Quizá advirtió, en los ejemplos anteriores, que las filas resultantes se mostraron sin ningún orden en particular. A menudo
es más fácil examinar la salida de una consulta cuando las filas se ordenan de algún modo significativo. Para ordenar un resultado, se usa la clásula
ORDER BY.
Aqui tiene las fechas de cumpleaños de los animales, ordenadas por fecha:
mysql> SELECT name, birth FROM pet ORDER BY birth;

+----------+------------+
| name | birth |
+----------+------------+
| Buffy | 1989-05-13 |
| Bowser | 1989-08-31 |
| Fang | 1990-08-27 |
| Fluffy | 1993-02-04 |
| Claws | 1994-03-17 |
| Slim | 1996-04-29 |
| Whistler | 1997-12-09 |
| Chirpy | 1998-09-11 |
| Puffball | 1999-03-30 |
+----------+------------+
Por lo general, cuando se trata de columnas de tipo carácter, la ordenación, — al igual que otras operaciones de comparación — no es
case-sensitive. Significa que el orden permanece indefinido para las columnas que son idénticas excepto por sus mayúsculas y minúsculas. Puede
no obstante forzar a que una columna se ordene en forma sensible a mayúsculas empleando el modificador BINARY: ORDER BY BINARY columna.
El sentido de ordenación, por defecto, es ascendente, con los valores más pequeños primero. Para ordenar en sentido inverso (descendente),
agregue la palabra clave DESC luego del nombre de la columna por la que ordena:
mysql> SELECT name, birth FROM pet ORDER BY birth DESC;

+----------+------------+
| name | birth |
+----------+------------+
| Puffball | 1999-03-30 |
| Chirpy | 1998-09-11 |
| Whistler | 1997-12-09 |
| Slim | 1996-04-29 |
| Claws | 1994-03-17 |
| Fluffy | 1993-02-04 |
| Fang | 1990-08-27 |
| Bowser | 1989-08-31 |
| Buffy | 1989-05-13 |
+----------+------------+
Puede ordenar basándose en varias columnas, y cada columna en un sentido diferente. Por ejemplo, para ordenar por tipo de animal en sentido
ascendente y, dentro de cada tipo, ordenar por nacimiento en sentido descendente (los animales más jóvenes primero) utilice la siguiente consulta:
mysql> SELECT name, species, birth FROM pet

-> ORDER BY species, birth DESC;
+----------+---------+------------+
| name | species | birth |
+----------+---------+------------+
| Chirpy | bird | 1998-09-11 |
| Whistler | bird | 1997-12-09 |
| Claws | cat | 1994-03-17 |
| Fluffy | cat | 1993-02-04 |
18 de 63 24/07/2010 11:53 p.m.

| Fang | dog | 1990-08-27 |

| Bowser | dog | 1989-08-31 |
| Buffy | dog | 1989-05-13 |
| Puffball | hamster | 1999-03-30 |
| Slim | snake | 1996-04-29 |
+----------+---------+------------+
Advierta que la palabra clave DESC se aplica sobre la columna inmediatamente anterior (birth); no afecta el sentido de ordenación de la columna
species.
Calculos sobre fechas====== MySQL provee varias funciones que se aplican a cálculos entre fechas, por ejemplo, para calcular edades u obtener
partes de una fecha. Para determinar cuántos años de edad tiene cada mascota, hay que calcular la diferencia entre el año de la fecha actual y el
de la fecha de nacimiento, y luego restar 1 al resultado si el dia y mes actuales son anteriores al día y mes indicados por la fecha de nacimiento. La
siguiente consulta devuelve, para cada mascota, el nombre, la fecha de nacimiento, la fecha actual, y la edad en años.
mysql> SELECT name, birth, CURDATE(),

-> (YEAR(CURDATE())-YEAR(birth))
-> - (RIGHT(CURDATE(),5)<RIGHT(birth,5))
-> AS age
-> FROM pet;
+----------+------------+------------+------+
| name | birth | CURDATE() | age |
+----------+------------+------------+------+
| Fluffy | 1993-02-04 | 2003-08-19 | 10 |
| Claws | 1994-03-17 | 2003-08-19 | 9 |
| Buffy | 1989-05-13 | 2003-08-19 | 14 |
| Fang | 1990-08-27 | 2003-08-19 | 12 |
| Bowser | 1989-08-31 | 2003-08-19 | 13 |
| Chirpy | 1998-09-11 | 2003-08-19 | 4 |
134
Curso (tutorial) de MySQL
| Whistler | 1997-12-09 | 2003-08-19 | 5 |
| Slim | 1996-04-29 | 2003-08-19 | 7 |
| Puffball | 1999-03-30 | 2003-08-19 | 4 |
+----------+------------+------------+------+
En el ejemplo anterior, YEAR() trae la parte correspondiente al año de una fecha, y RIGHT() trae los 5 primeros caracteres contando desde la
derecha, que representan la parte MM-DD de la fecha. La porción de la expresión que compara los valores MM-DD devuelve 1 o 0, lo cual se
corresponde con la diferencia de 1 año a restar de la edad si el dia de la fecha devuelto por CURDATE() ocurre antes que la fecha de nacimiento
birth. La expresión completa es un tanto confusa para usar como encabezado, por lo que se emplea un alias (age) para que el encabezado sea más
comprensible. La consulta funciona bien, pero los resultados podrían revisarse más fácilmente si las filas se presentaran en algún orden. Esto puede
hacerse agregando la cláusula ORDER BY name para ordenar por nombre la salida:

-> AS age
-> FROM pet ORDER BY name;
+----------+------------+------------+------+
+----------+------------+------------+------+
| Bowser | 1989-08-31 | 2003-08-19 | 13 |
| Buffy | 1989-05-13 | 2003-08-19 | 14 |
| Chirpy | 1998-09-11 | 2003-08-19 | 4 |
| Claws | 1994-03-17 | 2003-08-19 | 9 |
| Fang | 1990-08-27 | 2003-08-19 | 12 |
| Fluffy | 1993-02-04 | 2003-08-19 | 10 |
| Puffball | 1999-03-30 | 2003-08-19 | 4 |
| Slim | 1996-04-29 | 2003-08-19 | 7 |
| Whistler | 1997-12-09 | 2003-08-19 | 5 |
+----------+------------+------------+------+
Para ordenar la salida por edad (age) en lugar de por nombre (name), solo hay que utilizar una cláusula ORDER BY diferente:
19 de 63 24/07/2010 11:53 p.m.

-> AS age
-> FROM pet ORDER BY age;
+----------+------------+------------+------+
+----------+------------+------------+------+
| Chirpy | 1998-09-11 | 2003-08-19 | 4 |
| Puffball | 1999-03-30 | 2003-08-19 | 4 |
| Whistler | 1997-12-09 | 2003-08-19 | 5 |
| Slim | 1996-04-29 | 2003-08-19 | 7 |
| Claws | 1994-03-17 | 2003-08-19 | 9 |
| Fluffy | 1993-02-04 | 2003-08-19 | 10 |
| Fang | 1990-08-27 | 2003-08-19 | 12 |
| Bowser | 1989-08-31 | 2003-08-19 | 13 |
| Buffy | 1989-05-13 | 2003-08-19 | 14 |
+----------+------------+------------+------+
Una consulta similar se utiliza para determinar la edad a la fecha de muerte de los animales. Se determinan los animales que han muerto verificando
si el valor de la columna death es NULL. Entonces, para todos los valores no NULL calcula la diferencia entre las fechas de muerte (death) y
nacimiento (birth):
mysql> SELECT name, birth, death,

-> (YEAR(death)-YEAR(birth)) - (RIGHT(death,5)<RIGHT(birth,5))
-> AS age
-> FROM pet WHERE death IS NOT NULL ORDER BY age;
+--------+------------+------------+------+
| name | birth | death | age |
+--------+------------+------------+------+
| Bowser | 1989-08-31 | 1995-07-29 | 5 |
+--------+------------+------------+------+
La consulta utiliza la expresión death IS NOT NULL en lugar de death <> NULL porque NULL es un valor especial, que no puede ser comparado
mediante los operadores lógicos habituales . ¿Qué tal si se quisiera saber qué animales cumplen años el próximo mes? Para esta clase de cálculos,
el año y el día son irrelevantes; simplemente se desea extraer de la columna birth la parte correspondiente al mes. MySQL cuenta con varias
funciones para extraer partes de fechas, como YEAR(), MONTH(), y DAYOFMONTH(). MONTH() es la función apropiada para este caso. Para verla
en funcionamiento, ejecute una consulta que muestra tanto el valor de birth como el de MONTH(birth):
mysql> SELECT name, birth, MONTH(birth) FROM pet;

+----------+------------+--------------+
| name | birth | MONTH(birth) |
+----------+------------+--------------+
| Fluffy | 1993-02-04 | 2 |
| Claws | 1994-03-17 | 3 |
| Buffy | 1989-05-13 | 5 |
| Fang | 1990-08-27 | 8 |
| Bowser | 1989-08-31 | 8 |
| Chirpy | 1998-09-11 | 9 |
| Whistler | 1997-12-09 | 12 |
| Slim | 1996-04-29 | 4 |
| Puffball | 1999-03-30 | 3 |
+----------+------------+--------------+
Encontrar los animales que cumplen años el mes siguiente es también sencillo. Suponga que el mes actual es abril. De modo que su número es 4, y
se buscan los animales nacidos en Mayo (mes 5), de esta forma:
mysql> SELECT name, birth FROM pet WHERE MONTH(birth) = 5;

+-------+------------+
| name | birth |
+-------+------------+
| Buffy | 1989-05-13 |
+-------+------------+
Esto se complica ligeramente cuando el mes actual es Diciembre. No se puede simplemente sumarle 1 al número del mes (12) y buscar animales
nacidos en el mes 13, porque no existe tal mes. En lugar de eso, se debe buscar por animales nacidos en Enero (mes 1). Se puede incluso escribir
la consulta de forma que funcione sin importar cual es el mes actual. Así, no se necesitará indicar un mes en particular en la consulta. DATE_ADD()
20 de 63 24/07/2010 11:53 p.m.

sirve para sumar un intervalo de tiempo a una fecha dada. Si se adiciona un mes al valor de CURDATE(), y se extrae el mes mediante MONTH(), el
resultado será el mes en el que se buscarán cumpleaños:
mysql> SELECT name, birth FROM pet

-> WHERE MONTH(birth) = MONTH(DATE_ADD(CURDATE(),INTERVAL 1 MONTH));
Una manera alternativa de alcanzar el mismo resultado es sumar 1 al mes actual para obtener el mes siguiente (después de emplear la función
módulo (MOD) para dejar el número de mes en 0 si resultara ser 12:
mysql> SELECT name, birth FROM pet

-> WHERE MONTH(birth) = MOD(MONTH(CURDATE()), 12) + 1;
Advierta que MONTH devuelve un número entre 1 and 12. Y MOD(algun_valor,12) devuelve un número entre 0 y 11. La suma debe ser realizada
luego de MOD(), en otro caso se estaría pasando de Noviembre (11) to Enero (1).
Trabajar con valores NULL======
El valor NULL puede resultar un poco desconcertante hasta que se comienza a utilizar. Conceptualmente, NULL significa valor inexistente o
desconocido, y es tratado de forma diferente a otros valores. Para verificar que un valor es NULL, no se pueden emplear operadores de
comparación aritmética como =, <, o <>. Para comprobar esto, intente la siguiente consulta:
mysql> SELECT 1 = NULL, 1 <> NULL, 1 < NULL, 1 > NULL;

+----------+-----------+----------+----------+
| 1 = NULL | 1 <> NULL | 1 < NULL | 1 > NULL |
+----------+-----------+----------+----------+
| NULL | NULL | NULL | NULL |
+----------+-----------+----------+----------+
Claramente, no se obtienen valores significtivos a partir de estas comparaciones. Use en su lugar los operadores IS NULL y IS NOT NULL:
mysql> SELECT 1 IS NULL, 1 IS NOT NULL;

+-----------+---------------+
| 1 IS NULL | 1 IS NOT NULL |
+-----------+---------------+
| 0 | 1 |
+-----------+---------------+
Observe que en MySQL, 0 o NULL se intepretan como falso, y cualquier otro valor, como verdadero. El valor por defecto para una operación
booleana es 1. Este tratamiento especial de NULL es debido a que, en la sección anterior, fue necesario determinar qué animales ya no estaban
vivos utilizando death IS NOT NULL en lugar de death <> NULL. Dos valores NULL son considerados iguales por la cláusula GROUP BY. Cuando se
realiza un ORDER BY, los valores NULL se presentan en primer lugar si se emplea ORDER BY ... ASC, y al final si se ordena con ORDER BY ...
DESC. Un error muy común cuando se trabaja con valores NULL es asumir que es imposible insertar un valor cero o una cadena vacía en una
columna definida como NOT NULL, pero no es así. Los mencionados son efectivamente valores, mientras que NULL significa "no hay un valor".
Puede comprobar esto fácilmente empleando IS NOT NULL como se muestra aquí:
mysql> SELECT 0 IS NULL, 0 IS NOT NULL, '' IS NULL, '' IS NOT NULL;
+-----------+---------------+------------+----------------+
| 0 IS NULL | 0 IS NOT NULL | '' IS NULL | '' IS NOT NULL |
+-----------+---------------+------------+----------------+
| 0 | 1 | 0 | 1 |
+-----------+---------------+------------+----------------+
Por lo tanto, es totalmente posible insertar cadenas vacias o ceros en columnas marcadas como NOT NULL, ya que son valores NOT NULL
Coincidencias de patrones======
MySQL posee capacidades estándar para utilizar patrones así como también una forma de patrones basada en expresiones regulares extendidas
similares a las que se encuentran en utilidades de UNIX, como ser vi, grep, y sed. Los patrones SQL permiten emplear el caracter '_' para
representar coincidencia con un carácter individual y '%' En MySQL, por defecto, los patrones SQL no son case-sensitive. Abajo se muestran
algunos ejemplos. Advierta que no se emplean los operadores = o <> para trabajar con patrones SQL, en lugar de eso se usan los operadores de
comparación LIKE o NOT LIKE.
Para encontrar nombres que comiencen con 'b':
mysql> SELECT * FROM pet WHERE name LIKE 'b%';

+--------+--------+---------+------+------------+------------+
+--------+--------+---------+------+------------+------------+
21 de 63 24/07/2010 11:53 p.m.


+--------+--------+---------+------+------------+------------+
Para encontrar nombres que terminen con 'fy':
mysql> SELECT * FROM pet WHERE name LIKE '%fy';

+--------+--------+---------+------+------------+-------+
+--------+--------+---------+------+------------+-------+
+--------+--------+---------+------+------------+-------+
Para encontrar nombres que contengan 'w':
mysql> SELECT * FROM pet WHERE name LIKE '%w%';

+----------+-------+---------+------+------------+------------+
+----------+-------+---------+------+------------+------------+
+----------+-------+---------+------+------------+------------+
Para encontrar nombres que contengan exactamente 5 caracteres, use 5 veces el caracter patrón '_':
mysql> SELECT * FROM pet WHERE name LIKE '_____';

+-------+--------+---------+------+------------+-------+
+-------+--------+---------+------+------------+-------+
+-------+--------+---------+------+------------+-------+
Los otros patrones que pueden emplearse con MySQL usan expresiones regulares extendidas. Cuando busque coincidencias con este tipo de
patrones, use los operadores REGEXP y NOT REGEXP (o bien los sinónimos RLIKE y NOT RLIKE).
Algunas características de las expresiones regulares extendidas:
'.' detecta coincidencia con cualquier carácter individual.
Una clase de carácter '[...]' detecta coincidencia con cualquier caracter entre los corchetes. Por ejemplo, 'abc' coincidirá con 'a', 'b', o 'c'.
Para hacer referencia a un rango de caracteres, use un guión. 'a-z' detecta coincidencia con cualquier letra, mientras que '0-9' lo hace con
cualquier dígito.
'*' detecta coincidencia con cero o más apariciones de los caracteres que lo preceden. Por ejemplo, 'x*' detecta cualquier número de
caracteres 'x', '0-9*' detecta cualquier cantidad de dígitos, y '.*' coincidirá con cualquier número de cualquier carác ter.
REGEXP tendrá éxito si el patrón suministrado encuentra coincidencia en cualquier parte del valor examinado (esto difiere de LIKE en que
este último solo tiene éxito si el patrón concuerda con todo el valor).
Para lograr que un patrón detecte coincidencias solamente al principio o al final del valor examinado, utilice '^' al principio o '$' al final del
patrón.
Para demostrar el funcionamiento de las expresiones regulares extendidas, las consultas con LIKE expuestas anteriormente se han reescrito
utilizando REGEXP. Para hallar nombres que comiencen con 'b', use '^' para buscar coincidencia al principio del valor:
mysql> SELECT * FROM pet WHERE name REGEXP '^b';

+--------+--------+---------+------+------------+------------+
+--------+--------+---------+------+------------+------------+
+--------+--------+---------+------+------------+------------+
En MySQL 5.0, si realmente quiere forzar a que la comparación realizada por REGEXP sea case sensitive, utilice la palabra clave BINARY para
convertir a una de las cadenas en una cadena binaria. Esta consulta solamente encontrará coincidencia con 'b' minúsculas al comienzo de un
nombre:
22 de 63 24/07/2010 11:53 p.m.

mysql> SELECT * FROM pet WHERE name REGEXP BINARY '^b';
Para hallar nombres finalizados en 'fy', emplee '$' para buscar la coincidencia en el final del nombre:
mysql> SELECT * FROM pet WHERE name REGEXP 'fy$';

+--------+--------+---------+------+------------+-------+
+--------+--------+---------+------+------------+-------+
+--------+--------+---------+------+------------+-------+
Para encontrar nombres conteniendo una 'w', utilice esta consulta:
mysql> SELECT * FROM pet WHERE name REGEXP 'w';

+----------+-------+---------+------+------------+------------+
+----------+-------+---------+------+------------+------------+
+----------+-------+---------+------+------------+------------+
Debido a que un patrón de expresión regular encuentra coincidencia sin importar el lugar del valor donde se produce, en la consulta previa no es
necesario colocar un comodín a cada lado del patrón para obtener coincidencia en cualquier parte del valor, como hubiera sucedido de utilizar un
patrón SQL Para hallar nombres conteniendo exactamente cinco caracteres, use '^' y '$' para obligar a que la coincidencia deba estar al principio y
al final del nombre, y cinco instancias de '.' entre ellas.
mysql> SELECT * FROM pet WHERE name REGEXP '^.....$';

+-------+--------+---------+------+------------+-------+
+-------+--------+---------+------+------------+-------+
+-------+--------+---------+------+------------+-------+
La consulta anterior también se podría haber escrito empleando el operador '{n}' “repetir-n-veces”:
mysql> SELECT * FROM pet WHERE name REGEXP '^.{5}$';

+-------+--------+---------+------+------------+-------+
+-------+--------+---------+------+------------+-------+
+-------+--------+---------+------+------------+-------+
Contar registros====== Una pregunta frecuente que deben responder las bases de datos es: “¿qué tan a menudo aparece en la tabla un cierto tipo
de dato?” Por ejemplo, se podría querer averiguar la cantidad de mascotas de que se dispone, o cuantas mascotas tiene cada propietario, o varios
otros recuentos sobre los animales. Contar la cantidad total de animales es la misma pregunta que “¿cuántos registros hay en la tabla pet?”, ya que
hay un registro por mascota. COUNT(*) cuenta el número de filas, por ello, la consulta para contar animales luce así:
mysql> SELECT COUNT(*) FROM pet;

+----------+
| COUNT(*) |
+----------+
| 9 |
+----------+
Anteriormente se recuperaban los nombres de la gente que poseía mascotas. Se puede usar COUNT() para hallar cuantas mascotas tiene cada
propietario:
mysql> SELECT owner, COUNT(*) FROM pet GROUP BY owner;

+--------+----------+
| owner | COUNT(*) |
+--------+----------+
| Benny | 2 |
23 de 63 24/07/2010 11:53 p.m.

| Diane | 2 |
| Gwen | 3 |
| Harold | 2 |
+--------+----------+
Observe el uso de GROUP BY para agrupar todos los registros de cada propietario. Sin dicha cláusula, todo lo que se hubiera obtenido sería un
mensaje de error:
mysql> SELECT owner, COUNT(*) FROM pet;

ERROR 1140 (42000): Mixing of GROUP columns (MIN(),MAX(),COUNT(),...)
with no GROUP columns is illegal if there is no GROUP BY clause
COUNT() y GROUP BY son útiles para presentar datos en varias formas. Los siguientes ejemplos muestran diferentes operaciones: Cantidad de
animales por especies:
mysql> SELECT species, COUNT(*) FROM pet GROUP BY species;

+---------+----------+
| species | COUNT(*) |
+---------+----------+
| bird | 2 |
| cat | 2 |
| dog | 3 |
| hamster | 1 |
| snake | 1 |
+---------+----------+
Cantidad de animales por sexo:
mysql> SELECT sex, COUNT(*) FROM pet GROUP BY sex;

+------+----------+
| sex | COUNT(*) |
+------+----------+
| NULL | 1 |
| f | 4 |
| m | 4 |
+------+----------+
(En esta salida, NULL indica "sexo desconocido") Cantidad de animales por combinación de especies y sexo:
mysql> SELECT species, sex, COUNT(*) FROM pet GROUP BY species, sex;
+---------+------+----------+
| species | sex | COUNT(*) |
+---------+------+----------+
| bird | NULL | 1 |
| bird | f | 1 |
| cat | f | 1 |
| cat | m | 1 |
| dog | f | 1 |
| dog | m | 2 |
| hamster | f | 1 |
| snake | m | 1 |
+---------+------+----------+
y gatos de esta manera:
mysql> SELECT species, sex, COUNT(*) FROM pet

-> WHERE species = 'dog' OR species = 'cat'
-> GROUP BY species, sex;
+---------+------+----------+
+---------+------+----------+
| cat | f | 1 |
| cat | m | 1 |
| dog | f | 1 |
| dog | m | 2 |
+---------+------+----------+
24 de 63 24/07/2010 11:53 p.m.

O si desea la cantidad de animales de cada sexo contando solamente los que tienen sexo conocido:
mysql> SELECT species, sex, COUNT(*) FROM pet

-> WHERE sex IS NOT NULL
-> GROUP BY species, sex;
+---------+------+----------+
+---------+------+----------+
| bird | f | 1 |
| cat | f | 1 |
| cat | m | 1 |
| dog | f | 1 |
| dog | m | 2 |
| hamster | f | 1 |
| snake | m | 1 |
+---------+------+----------+
Utilizar mas de una tabla======
La tabla pet mantiene el registro de las mascotas que se poseen. Si quisiera registrar otros datos acerca de ellas, como eventos de su vida tales
como visitas al veterinario o nacimiento de crías, necesitaría otra tabla. ¿Cómo debería ser esta tabla? Se necesita:
Un campo con el nombre de la mascota para saber a quien pertenece cada evento registrado.
La fecha en que ocurrió el evento.
Un campo con la descripción del evento.
Un campo con el tipo de evento, a fin de poder clasificarlo.
Teniendo en cuenta estas consideraciones, la sentencia CREATE TABLE para la tabla event ("eventos", en inglés) podría ser así:
mysql> CREATE TABLE event (name VARCHAR(20), date DATE,

-> type VARCHAR(15), remark VARCHAR(255));
Como se hizo con la tabla pet, es más fácil realizar la carga inicial de datos si se crea un archivo de texto delimitado con tabulaciones que contenga
la información a agregar:
name date type remark

Fluffy 15/05/95 litter 4 kittens, 3 female, 1 male
Buffy 1993-06-23litter 5 puppies, 2 female, 3 male
Buffy 1994-06-19litter 3 puppies, 3 female
Chirpy 1999-03-21vet needed beak straightened
Slim 1997-08-03vet broken rib
Bowser 1991-10-12kernnel
Fang 1991-10-12kernnel
Fang 28/08/98 birthday Gave him a new chew toy
Claws 1998-03-17birthday Gave him a new flea collar
Whistler 1998-12-09birthday First birthday
Los registros se cargan así:
mysql> LOAD DATA LOCAL INFILE 'event.txt' INTO TABLE event;
Con base en lo que se ha aprendido a partir de las consultas efectuadas sobre la tabla pet, se debería poder recuperar registros de la tabla event;
los principios son los mismos. Pero en un momento dado la tabla event por sí sola es insuficiente para responder las preguntas que pueden
formularse. Suponga que se desea saber a qué edad tuvo sus crías cada mascota. Anteriormente se aprendió a calcular edades a partir de dos
fechas. La fecha en que la mascota tuvo sus crias está en la tabla event, pero para calcular su edad, se necesita su fecha de nacimiento, la cual
está localizada en la tabla pet. Esto significa que la consulta requiere ambas tablas:
mysql> SELECT pet.name,

-> (YEAR(date)-YEAR(birth)) - (RIGHT(date,5)<RIGHT(birth,5)) AS age,
-> remark
-> FROM pet, event
-> WHERE pet.name = event.name AND event.type = 'litter';
+--------+------+-----------------------------+
| name | age | remark |
+--------+------+-----------------------------+
| Fluffy | 2 | 4 kittens, 3 female, 1 male |
| Buffy | 4 | 5 puppies, 2 female, 3 male |
25 de 63 24/07/2010 11:53 p.m.

| Buffy | 5 | 3 puppies, 3 female |

+--------+------+-----------------------------+
Hay varias cosas para observar en esta consulta:
La cláusula FROM menciona dos tablas porque la consulta necesita traer datos de ambas
Cuando se combina (también se denomina join -unión, en inglés-) información desde múltiples tablas, se necesita indicar qué registro de una
tabla se combinará con qué registro de la otra. Esto es sencillo porque ambas tablas tienen una columna name. La consulta emplea la cláusula
WHERE para hacer coincidir registros de las dos tablas basándose en el valor de name.
Dado que la columna name aparece en ambas tablas, se debe especificar a cuál tabla pertenece la columna al hacer referencia a ella. Esto
se hace anteponiendo el nombre de la tabla al nombre de la columna.
No es necesario tener dos tablas diferentes para establecer una unión. A veces es útil combinar una tabla consigo misma, si se desea comparar
entre sí registros de una misma tabla. Por ejemplo, para formar parejas de mascotas para reproducción, podría unir la tabla pet consigo misma para
generar pares de animales macho y hembra de la misma especie:
mysql> SELECT p1.name, p1.sex, p2.name, p2.sex, p1.species

-> FROM pet AS p1, pet AS p2
-> WHERE p1.species = p2.species AND p1.sex = 'f' AND p2.sex = 'm';
+--------+------+--------+------+---------+
| name | sex | name | sex | species |
+--------+------+--------+------+---------+
| Fluffy | f | Claws | m | cat |
| Buffy | f | Fang | m | dog |
| Buffy | f | Bowser | m | dog |
En la consulta anterior se especificaron alias para la tabla con el fin de indicar a qué instancia de la tabla pertenece cada columna referenciada.
Instalar y configurar X Window System
Sobre X Window Systemn
El sistema de ventanas X (en inglés X Window System) fue desarrollado a mediados de los años 1980 en el MIT para dotar de una interfaz gráfica a
los sistemas Unix. Este protocolo permite la interacción gráfica en red entre un usuario y una o más computadoras haciendo transparente la red para
éste. Generalmente se refiere a la versión 11 de este protocolo, X11, el que está en uso actualmente. X es el encargado de mostrar la información
gráfica y es totalmente independiente del sistema operativo. El sistema de ventanas X distribuye el procesamiento de aplicaciones especificando
enlaces cliente-servidor. El servidor provee servicios para acceder a la pantalla, teclado y ratón, mientras que los clientes son las aplicaciones que
utilizan estos recursos para interacción con el usuario. De este modo mientras el servidor se ejecuta de manera local, las aplicaciones pueden
ejecutarse remotamente desde otras máquinas, proporcionando así el concepto de transparencia de red. Debido a este esquema cliente-servidor, se
puede decir que X se comporta como una terminal gráfica virtual. El hecho que exista un estándar definido para X permite que se desarrollen
servidores X para distintos sistemas operativos y plataformas, lo que hace que el código sea muy portable. Por ejemplo. permite tener clientes X
ejecutándose en un potente servidor UNIX mientras los resultados son visualizados en una PC de escritorio con cualquier otro sistema operativo
funcionando. La comunicación entre el cliente X y el servidor se realiza por medio de un protocolo conocido como Xprotocol (Protocolo base del
sistema X Window), que consiste en una serie de bytes interpretados como comandos básicos para generar ventanas, posicionarlas, o controlar
eventos. Los clientes X acceden al Xprotocol mediante el uso de una biblioteca llamada Xlib, que evita al programador de clientes X tener que lidiar
con el código binario del Xprotocol. Sin embargo, los aspectos de decoración de ventana y manejos de ventanas no están definidos en esta
biblioteca. X NO ES UN gestor de ventanas, necesita de uno para controlar el manejo de ventanas. Esto trae la ventaja de que permite al usuario
instalar el administrador de ventanas que más le agrade, e incluso tener varios instalados eligiendo el más apropiado a la hora de acceder a X.
También trae la ventaja de que hace de X estrictamente un sistema gráfico, de tal modo que un cliente X podría estar enviando un gráfico a una
pantalla, a una impresora o a cualquier otro hardware sin darse cuenta, flexibilizando la salida gráfica. Por otro lado, la desventaja que trae el hecho
de no tener un único gestor de ventanas es que los programadores de clientes X que desean hacer uso de los recursos de los gestores de ventanas
(botones, barras de deslizamientos, etc) deben elegir un gestor de ventanas específico para programar y contar que el usuario tenga por los menos
las bibliotecas de dicho gestor de ventanas instalado. Las bibliotecas de los gestores de ventanas se conocen como "Toolkits", el estándar X provee
sólo de un conjunto de herramientas básicas llamadas Xintrisics que permiten a los programadores de los gestores de ventanas armar sus Toolkits
sobre éstas.
Instalando X Window System

La forma de instalar el sistema de ventanas x window en su equipo sera de la siguiente manera:
Para sistemas operativos de la familia Red Hat teclee lo siguiente:
[BASH] # yum install xorg-x11
Para sistemas operativos de la familia Debian teclee lo siguiente:
[BASH] # apt-get install x-window-system
26 de 63 24/07/2010 11:53 p.m.

Configurando el entorno X Window System
Lo primero que tenemos que hacer es recopilar la información necesaria, para la correcta configuración del servidor gráfico Xorg
La información mínima necesaria es la siguiente:
Especificaciones del monitor

Chip y cantidad de memoria de la tarjeta gráfica (vídeo)
Especificaciones del ratón
Especificaciones del teclado
Especificaciones del monitor

Usaremos las especificaciones del monitor para determinar la resolución y frecuencia de refresco a la que funcionara. Dichas especificaciones
vienen en la documentación del monitor, o bien la obtenemos desde la web del fabricante.
Necesitamos tres rangos muy importantes:
Frecuencia de refresco horizontal

Frecuencia de refresco vertical
Resolución máxima.
Con esta información sabemos como hemos de configurar nuestro monitor para no dañarlo o quemarlo.
Chip y cantidad de memoria de la tarjeta grafica

El chip de la tarjeta gráfica también llamada tarjeta de vídeo, define que controlador utilizaremos para que funcione correctamente.
La memoria de la tarjeta gráfica determina la resolución máxima y la profundidad de color máxima con la que el sistema puede trabajar.
Especificaciones del mouse

Las especificaciones del ratón son muy fáciles, basta con observar dicho ratón para saber:
El tipo de conector: USB, PS2, Serial, etc...

El numero de botones: 1, 2, 3, 4, etc...
Si tiene rueda y cuantas tiene: 1, 2
Especificaciones del teclado

Las especificaciones del teclado al igual que las del ratón, con observar dicho teclado conocemos la información:
El tipo de conector: USB o PS2

Que mapa de caracteres que usa: QWERTY, AZERTY, etc..
El numero de teclas: 101, 102, 104, 105 o microsoft
Fichero xorg.conf
La configuración del servidor gráfico xorg se encuentra en el fichero xorg.conf, en la siguiente ruta:
/etc/X11
Y se encuentra dividido en las siguientes secciones:
Section "Files" Ruta o path de los archivos

Section "Modules" Carga módulos dinámicos
Section "InputDevice" Descripción de los dispositivos periféricos
Section "Device" Descripción de los dispositivos gráficos
Section "Monitor" Descripción del monitor
Section "Screen" Configuración de la pantalla
Section "ServerLayout"Esquema global
Cada sección comienza con la instrucción Section seguido del nombre de la "sección entre comillas" las opciones, driver, etc.. y terminada con
EndSection.
Seccion “Files”
Esta sección define la ruta de archivos necesarios para levantar el servidor X.
Define la ruta de los tipos de letras en las entradas " FontPath"

Especifica la ubicación de la base de dartos de colores RGB "RgbPath"
Ejemplo:
Section “Files”
RgbPath “/usr/lib/X11/rgb”
EndSection
27 de 63 24/07/2010 11:53 p.m.

Seccion “Modules”
La sección Module especifica que módulos cargará el servidor gráfico X, dichos módulos añaden funcionalidad adicional al servidor X.
Section “Module”
Load “dbe”
Load “extmod”
Load “type1”
Load “freetype”
Load “glx”
EndSection
Seccion “InputDevice”
Cada sección InputDevice configura un dispositivo de entrada para el servidor X. Los sistemas Xorg tienen mínimo dos secciones InputDevice:
Un Mouse
Un Teclado
Configuracion tipica de un mouse
Ejemplo:
Section “InputDevice”
Identifier “Mouse0”
Driver “mouse”
Option “Protocol” “Auto”
Option “Device” “/dev/psaux”
Option “Emulate3Buttons” “no”
Option “ZaxisMapping” “4 5”
EndSection
Identifier: Especifica un nombre para esta sección
Driver: Especifica el controlador que debe cargar para el correcto funcionamiento del ratón. "mouse": soporta cuatro tipos de mouse:
Serial
Bus
PS/2
USB
Option: Especifica las opciones necesarias pertinentes al dispositivo
Para un mouse, las opciones son las siguientes:
Protocol: Indica el protocolo define el tipo de mouse que tenemos
"ImPS/2"
"ExplorerPS/2"
"MouseMan"
"Microsoft"
"Mousesystems"
"IntelliMouse"
"ThinkingMouse"
"ThinkingMousePS/2"
"NetScrollPS/2"
"NetMousePS/2"
"GlidePoint"
"GlidePointPS/2"
"MouseManPlusPS/2"
NOTA:
Los mouse seriales antiguos de dos o tres botones estan normalmente soportados por el protocolo "Microsoft" o "MouseMan"
Los mouse seriales con rueda los soporta el protocolo "IntelliMouse"
Los mouse PS/2 los soporta el protocolo "ImPS/2"
El protocolo "auto" se usa siempre que este es capaz de detectar el mouse.
CorePointer: Indica que el ratón definido es el mouse principal
Device: Indica la ubicación del dispositivo físico (donde se encuentra conectado), las opciones son las siguientes:
28 de 63 24/07/2010 11:53 p.m.

/dev/input/mice (conectado al puerto USB)

/dev/psaux (conectado al puerto PS/2)
/dev/ttyS0 (conectado al puerto Serial 0)
/dev/ttyS1 (conectado al puerto Serial 1)
Emulate3Buttoms: Especifica si un mouse de dos botones se comporte como uno de tres botones, cuando se presionen ambos botones
simultáneamente.
ZAxisMapping: Especifica que funcione la rueda que incorpora el mouse.
Configuracion tipica de un teclado
Ejemplo:
Section “InputDevice”
Identifier “Generic Keyboard”
Driver “kbd”
Option “CoreKeyboard”
Option “XkbRules” “xorg”
Option “XkbModel” “pc105”
Option “XkbLayout” “es”
EndSection
Identifier: Especifica un nombre para esta sección.
Driver: Especifica el controlador que debe cargar para el correcto funcionamiento del teclado.
Option: Especifica las opciones necesarias pertinentes al dispositivo
Para un teclado las opciones son las siguientes:
CoreKeyboard: Especifica que es el teclado principal
XkbModel: Especifica el tipo de teclado. Los valores mas comunes son:
"pc101"
"pc102"
"pc104"
"pc105"
"microsoft"
XkbLayout: Especifica el lenguaje que usaremos, "es" (español), "us" (ingles)
Seccion “Device”
Esta sección es la que define y configura la tarjeta gráfica (vídeo)
Ejemplo:
Section “Device”
Identifier “Device0”
Driver “nvidia”
VendorName “NVIDIA Corporation”
Option “RenderAccel” “true”
Option “AllowGLXWithCompisite” “true”
Option “dpms”
EndSection
Driver: Especifica el controlador que debe cargar para el correcto funcionamiento del vídeo.
VendorName: Este parámetro es opcional, especifica el fabricante de la tarjeta de vídeo.
BusID: Este parámetro es opcional, especifica el bus en el que se encuentra conectada la tarjeta gráfica, Esta opción únicamente es necesaria para
sistema con múltiples tarjetas gráficas.
Screen: Este parámetro es opcional, especifica que conector del monitor en la tarjeta gráfica configura la sección Device. Esta opción en muy útil
solamente para tarjetas con múltiples conectores.
Si dos monitores o mas son conectados en diferentes conectores en la misma tarjeta gráfica, deben existir en xorg.conf secciones Device separadas
y cada una de estas secciones debe tener un valor Screen diferente.
29 de 63 24/07/2010 11:53 p.m.

Los valores para la entrada Screen debe ser enteros. El primer conector de la tarjeta de vídeo tiene el valor 0. El valor para cada conector adicional
incrementa este valor en uno.
Option "nombre_opción": Este parámetro es opcional. Reemplace "nombre_opción" con una de las opciones listadas para esta sección en la pagina
man de xorg.conf
Una de las opciones mas habituales es "dpms" (Display Power Management Signalling), se usa para activar el estado de ahorro de energía del
monitor.
Seccion “Monitor”
Esta sección es la que define y configura los parámetro del monitor
Ejemplo:
Section “Monitor”
Identifier “Acer X203W”
Option “DPMS”
HorizSync 30-83
VertRefresh “55-75”
EndSection
Identifier: Especifica un nombre para esta sección. Puede existir varias secciones "Monitor" en el archivo xorg.conf, cada una con diferente
identificación (Identifier), esto es causado porque disponemos de dos o mas monitores conectados al ordenador.
HorizSync: Especifica la frecuencia de barrido horizontal del monitor, expresado en kHz. Puede ser una frecuencia fija (30.5), multiples frecuencias
fijas (30.5, 35.8), un rango (30-110), o varios rangos (15-25, 30-64)
VertRefresh: Especifica la frecuencia de barrido vertical del monitor, expresado en Hz, los valores son iguales a la opción HorizSync.
Seccion “Screen”
Esta sección es la que va a definir la pantalla, vinculando una tarjeta gráfica (Device) con la sección "Monitor" Ejemplo:
Section “Screen”
Identifier “Default Screen”
Device “nvidia geforce mx400”
Monitor “AcerX203W”
DefaultDepth 24
Options “AddARGBGLXvVisuals” “True”
Subseccion “Display”
Depth 1
Modes “1600x1050” ”1200x1024” ”1024x768” ”800x600” “640X400”
Depth 4
Modes “1600x1050” ”1200x1024” ”1024x768” ”800x600” “640X400”
Depth 8
Modes “1600x1050” ”1200x1024” ”1024x768” ”800x600” “640X400”
Depth 15
Modes “1600x1050” ”1200x1024” ”1024x768” ”800x600” “640X400”
Depth 16
Modes “1600x1050” ”1200x1024” ”1024x768” ”800x600” “640X400”
Depth 24
Modes “1600x1050” ”1200x1024” ”1024x768” ”800x600” “640X400”
EndSection
Identifier: Especifica un nombre unico para esta sección
Device: Especifica el nombre de una sección "Device" existente en el fichero xorg.conf
Monitor: Especifica el nombre único de una sección "Monitor" existente en fichero xorg.conf
Observación: las entradas "Device y Monitor" tienen que tener el mismo valor que la entrada "Identifier" de las secciones "Device" y "Monitor". De
esta manera se entrelazan las configuraciones de las diferentes secciones.
DefaultDepth: Especifica la profundidad de color por defecto en bits.
SubSection "Display": Especifica los modos disponibles de la pantalla para una profundidad de color en particular.
30 de 63 24/07/2010 11:53 p.m.

Observación: Una sección "Screen" puede tener múltiples subsecciones "Display", pero debe existir al menos una para la profundidad de color
especificada en la entrada "DefaultDepth"
Depth: Especifica la profundidad de color de la subsección, los valores posibles son: 1, 4, 8, 15, 16 y 24 bits
Modes: Especifica las resoluciones que podremos visualizar según nuestro monitor. Puede especificarse una sola resolución "1680x1050" (si
sabemos que nuestro monitor la soporta), o un listado de estas: "1680x1050" "1280x1024" "1024x768" "800x600" "640x480". Por defecto se usa la
primera en la lista, siempre que este soportada por nuestro monitor, si no se usa la siguiente, y asi hasta la ultima resolución que tengamos listada.
Nota: Dependiendo de nuestro monitor y tarjeta grafica (si son de gama "media baja" o inferior), puede darse los siguientes casos:
* A mayor profundidad de color "24 bits" obtenemos menor resolución "800x600" * A menor profundidad de color "8 bits" obtenemos mayor
resolución "1680x1050"
Option "nombre de opción": Especifica parámetros extras para la sección. Reemplace "nombre de opción" con una opción valida listada para esta
sección en la pagina man de xorg.conf
Seccion “ServerLayaout”
Esta sección es la que vincula los dispositivos de entrada y salida que controla el servidor xorg.
Como mínimo, esta sección debe especificar un dispositivo de salida (monitor) y al menos dos de entrada ( un teclado y un ratón)
En Particular esta sección junta todos los identificadores "Identifier" de cada sección.
Section “ServerLayout”
Identifier “Default Layout”
Screen “Default Screen”
InputDevice “Generic Layout”
InputDevice “Configured Mouse”
EndSection
Screen: Especifica el nombre de la sección "Screen" a ser usado por el servidor xorg. Pueden estar presente más de una opción "Screen"
Tareas Administrativas
Administrando cuentas de usuario, grupos y ficheros del sistema
En este capitulo abodaremos temas como son la creacion, eliminacion, suspencion y cambio en las cuentas de usuario del sistema, tambien
aprenderemos a crear y eliminar grupos, y por ultimo estudiaremos la manera de cambiar el grupo al cual pertenece un usuario y anexarlo a otro.
Comenzaremos hablando de los ficheros directamente relacionados con las cuentas de los usuarios y la funcion que estos desempeñan.
Fichero /etc/passwd
Este fichero almancena datos sobre las cuentas de usuario del sistema, dichos datos se encuentran organizados linea a linea, de las cuales cada
una corresponde a un usuario. Tambien puede encontrar en este fichero algunos servicios del sistema como son , el servidor web o el de correo.
Cada una de estas lineas se encuentra formada por 7 campos los cuales se encuentran separadpos por el operador
Los campos de los cuales hablamos son conformados por los siguientes parametros
UserName X UserID GroupID UserInfo HomeDir Shell

1 23 4 5 6 7
El segundo campo es comunmente conocido como el campo de password y se encuentra directamente ligado a la contraseña del usuario. Este
campo puede adoptar 3 parametros posibles, estos parametros son:
x La letra 'x' indica que el password del usuario se encuentra cifrado y ligado directamente al fichero /etc/shadow
Los parametros * o ! indican que el usuario no podra loearse en el sistema, esta opcion es comunmente asignada a usuarios que hacen uso de
*o!
servicios como FTP o correo
vacioSi se encontrace este campo vacio significa entonces que el usuario no tiene asignada ninguna contraseña
Un ejemplo del fichero /etc/passwd se muestra a continuacion:
Usuario.-Nombre de la cuenta con la que el usuario se logeara para acceder al sistema Password.-Contraseña asignada al usuario
UID.-Identificador del Usuario GID.-Identificador que indica a cual grupo pertenece el usuario Informacion Adicional.-Informacion detallada del
usuario Home del Usuario.-Directorio de trabajo del usuario Shell.-Interprete de comandos asignado al usuario
Fichero /etc/shadow
Este este fichero almacena las contraseñas cifradas de cada usuario del sistema, estos datos se encuentran organizados linea a linea, de las cuales
cada una corresponde a un usuario. Cada una de estas lineas se encuentra formada por 9 campos los cuales se encuentran separados por el
operador
31 de 63 24/07/2010 11:53 p.m.

Estos 9 campos se encuentran conformados por los siguientes parametros
CampoDescripcion Comentario
1 Login del Usuario
Vacio= Sin password * o ! = No permite
2 Contraseña cifrada
logeo en sistema
Días transcurridos desde el 1/ene/1970 hasta la fecha en que la contraseña fue cambiada por última
3 Nunca vacio
vez.
4 Número de días que deben transcurrir hasta que la contraseña se pueda volver a cambiar. 0= Siempre permite cambio
Número de días tras los cuales hay que cambiar la contraseña. (-1 significa nunca). A partir de este
5 Normalmente son 10000 dias
dato se obtiene la fecha de expiración de la contraseña.
Número de días antes de la expiración de la contraseña en que se le avisará al usuario al inicio de la
6 Vacio=Sin advertencia
sesión
7 Días después de la expiración en que la contraseña se inhabilitara, si es que no se cambio. vacio=Nunca inactivo
8 Fecha de caducidad de la cuenta. Se expresa en días transcurridos desde el 1/Enero/1970 vacio=Nunca sera deshabilitado
9 Reservado para uso futuro
Administración de cuentas de usuario

Las cuentas de usuario estan localizadas en el fichero /etc/passwd, las contraseñas cifradas de los usuarios son asignadas al fichero /etc/shadow.
Cuando una nueva cuenta de usuario es creada (usando el comando useradd) por default toma la plantilla (opcion -m) /etc/skel para generar el
entorno de trabajo del usuario.
useradd
Para generar una cuenta de usuario haremos uso del comando useradd que a su vez debera seguir la siguiente estructura :
[BASH]# useradd [opciones] nombreDelUsuario
OpcionesDescripcion
-b El nombre de usuario sera añadido a la ruta donde sera ubicada su carpeta de trabajo
-d El nombre de usuario no sera añadido a la ruta donde sera ubicada su carpeta de trabajo
Se usa para especificar la fecha en la cual expira la cuenta. Debe especificarse en el siguiente formato Año-Mes-Dia.
Ejemplos
-e a) -e 20100506
b) -e 20081224
c) -e 20090214
-f Numero de dias antes de que la contraseña expire, antes de que la cuenta sea deshabilitada
-g El nombre del grupo o gid asignado a un nuevo usuario
Grupo secundario al cual puede ser asignado un usuario
Ejemplos
-G a) -G desarrolloJava
b) -G ventasMedicas
c) -G soportePHP
-u Identificador o uid que sera asignado al usuario, por defecto Linux asignara UID's a partir del numero 500
-m Copia el contenido de la carpeta /etc/skel a la carpeta del usuario recien creado.
-s Interperete de comandos SHELL que sera asignado al usuario, entre las opciones disponibles estan:
usermod
El comando usermod modifica los parametros de acceso asignados a una cuenta existente del sistema.
Sintaxis:
[BASH]# useradd nombreDelUsuario [-c comment] [-d home_dir [ -m]]

[-e expire_date] [-f inactive_time]
[-g initial_group] [-G group[,...]]
[-l login_name] [-p passwd]
[-s shell] [-u uid [ -o]] [-L|-U]
OpcionesDescripcion
-c Añade o modifica el comentario, campo 5 de /etc/passwd
-d Modifica el directorio de trabajo o home del usuario, campo 6 de /etc/passwd
-e Cambia o establece la fecha de expiración de la cuenta, formato AAAA-MM-DD, campo 8 de /etc/shadow
32 de 63 24/07/2010 11:53 p.m.

-g Cambia el número de grupo principal del usuario (GID), campo 4 de /etc/passwd

-G Establece otros grupos a los que puede pertenecer el usuario, separados por comas.
-i Cambia el login o nombre del usuario, campo 1 de /etc/passwd y de /etc/shadow
-L Bloque la cuenta del usuario, no permitiendolé que ingrese al sistema. No borra ni cambia nada del usuario, solo lo deshabilita.
-s Cambia el shell por defecto del usuario cuando ingrese al sistema.
-u Cambia el UID del usuario.
-U Desbloquea una cuenta previamente bloqueada con la opción -L.
Si quiseramos cambiar el nombre de usuario de ’carita’ a ’carlita’:
[BASH]# usermod -l carlita carita
Casi seguro también cambiará el nombre del directorio de inicio o HOME en /home, pero si no fuera así, entonces:
[BASH]# usermod -d /home/carlita carlita
Otros cambios o modificaciones en la misma cuenta:
[BASH]# usermod -c "supervisor de area" -s /bin/ksh -g 505 carlita
Lo anterior modifica el comentario de la cuenta, su shell por defecto que ahora sera Korn shell y su grupo principal de usuario quedó establecido al
GID 505 y todo esto se aplicó al usuario ’sego’ que como se observa debe ser el último argumento del comando.
userdel El comando userdel remueve un usuario del sistema. Sintaxis:
[BASH]# userdel -r nombreDelUsuario
OpcionesDescripcion
Este parametro indica al sistema que sera eliminada la carpeta de trabajo del usuario. Si se usara el comando userdel sin el parametro -r
-r
solo eliminara al usuario del sistema
La opción -f es igual que la opción -r, elimina todo lo del usuario, cuenta, directorios y archivos del usuario, pero además lo hace sin
-f importar si el usuario esta actualmente en el sistema trabajando. Es una opción muy radical, además de que podría causar inestabilidad
en el sistema, asi que hay que usarla solo en casos muy extremos.
passwd
El comando passwd se utiliza para cambiar contraseñas. Cuando se emplea el comando passwd sin opciones, se cambia la contraseña del usuario
que lo invocó. Con el comando passwd primero se exigirá la contraseña vigente y luego se pedirá dos veces la nueva para prevenir cualquier error.
La utilización del comando passwd con los parámetros usuario y contraseña sólo es posible para root. Si se utiliza sólo el parámetro usuario cuando
se hace uso de este comando, entonces root puede cambiar la contraseña para ese usuario.
Los caracteres admitidos para las contraseñas son los siguientes:
# * , . ; : _ - + ! $ % & / | ? { [ ( ) ] }
Sintaxis:
[BASH]# passwd [Opciones] nombreDelUsuario
Opciones:
OpcionesDescripcion
-e Esta opcion forzara al usuario a cambiar su contraseña en su siguiente login al sistema
-l Con esta opcion, el administrador del sistema puede inhabilitar la cuenta de algun usuario especifico
-u Con esta opcion, el administrador del sistema puede deshabilitar la cuenta de algun usuario especifico
-n Mínimo número de días antes de poder cambiar
-x Máximo número de días de validez; luego pide cambiar
-f Cambia el nombre completo del usuario
-s Cambia el SHELL del usuario
chage
Se usa para listar o cambiar el tiempo en el que expira una contraseña de usuario
Sintaxis:
[BASH]# change [opciones] nombreDelUsuario
Opciones
33 de 63 24/07/2010 11:53 p.m.

OpcionesDescripcion
-d dias Cuenta el número de días (desde 01-01-1970) transcurridos desde que cambió la contraseña por última vez
-E fecha Modifica la fecha en que la cuenta del usuario expirará y será bloqueada
-l dias Modifica cuantos días puede permanecer una cuenta con una contraseña expirada antes de ser bloqueada
-M dias Modifica el número máximo de días durante los que es válida la contraseña de usuario. Pasados los días, el usuario deberá de modificarla
-m dias Modifica el número mínimo de días entre cambio de contraseña
-W dias Modifica el número de días que se avisará al usuario antes de cambiar la contraseña
newusers La mayoría de las veces que vamos a crear un nuevo usuario utilizamos el comando useradd pero cuando tenemos una red de muchos
usuarios o tenemos que crear o actualizar multiples usuarios en un servidor se hace útil poderlo hacer desde una lista, para esto podemos utilizar el
comando newusers. El comando newusers toma un archivo de texto plano que debe tener el mismo formato que el de el archivo /etc/passwd de
nuestro sistema. Al ejecutar el comando y darle como parámetro la ruta al archivo de texto creará los usuarios no existentes y actualizará los que ya
existen, así mismo si no existe la carpeta /home/nobreDelUsuario la creará por nosotros. Para hacer uso de este comando haremos lo siguiente:
Primero creamos el archivo de texto con los usuarios:
[BASH]# touch /root/batch-nuevos-usuarios.txt
[BASH]# chmod 0600 /root/batch-nuevos-usuarios.txt
Es importante que este archivo sólo pueda ser leido por root (por eso el chmod 0600) ya que las claves en este archivo estarán en texto plano. Ahora
editamos el archivo
[BASH]# vim /root/batch-nuevos-usuarios.txt
Y ahora agregamos la lista de usuarios, recuerden que debe tener el mismo formato que /etc/passwd:
usuario1:password:1001:513:Cuenta Mercadeo:/home/usuario1:/bin/bash
usuario2:password:1002:513:Usuario Ventas:/home/usuario2:/bin/bash
pepe:password:1110:501:Cuenta Invitado:/home/guest:/bin/menu
Agreguen cuantos usuarios quieran, igualmente pueden agregar los usuarios que quieran actualizar. (muy util para hacer un reset de password
masivo).
Por último ejecutamos el comando:
[BASH]# newusers /root/batch-nuevos-usuarios.txt
Fichero /etc/login.defs
En el archivo de configuración /etc/login.defs están definidas las variables que controlan los aspectos de la creación de usuarios y de los campos de
shadow usadas por defecto. Algunos de los aspectos que controlan estas variables son:
Número máximo de días que una contraseña es válida PASS_MAX_DAYS

El número mínimo de caracteres en la contraseña PASS_MIN_LEN
Valor mínimo para usuarios normales cuando se usa useradd UID_MIN
El valor umask por defecto UMASK
Si el comando useradd debe crear el directorio home por defecto CREATE_HOME
Basta con leer este archivo para conocer el resto de las variables que son autodescriptivas y ajustarlas al gusto. Recúerdese que se usaran
principalmente al momento de crear o modificar usuarios con los comandos useradd y usermod.
Otros comandos de inicio de sesión del usuario
Opciones Descripcion
id -ng [usuario] Muestra el grupo actual al cual pertenece el usuario.
groups [usuario]Muestra todos los grupos al cual pertenece el usuario
id -nu [usuario] Muestra el nombre del usuario logeado
echo $user Muestra el usuario actual
id -u Muestra el ID del usuario actual
users Muestra los usuarios logeados localmente en el sistema
who Muestra los usuarios logeados localmente en el sistema
w Muestra los usuarios logeados localmente en el sistema
finger -l usuario Muestra los usuarios logeados local o remotamente en el sistema
lastlog Muestra los ultimos accesos al sistema. La lista incluye inicios, apagados y logeos
Administración de grupos
groupadd
34 de 63 24/07/2010 11:53 p.m.

Para dar de alta grupos de trabajo en el sistema usaremos el comando groupadd el cual debera ser aplicado segun la siguiente sintaxis:
[BASH]# groupadd [opciones] nombreDelGrupo
Opciones:
OpcionesDescripcion
Define mediante un valor numerico el ID del grupo, este numero
-g
no puede ser uno negativo
Un grupo del sistema es aquel que tiene un numero de identidad (GID) de
-r Define un grupo del sistema.
grupo por debajo del numero 500
Este particular GID es utilizado por los servicios del sistema como un servidor web o de correo|
-f Forza al sistema a crear el grupo aunque este ya exista.
-oAsigna un ID existente a un grupo
groupmod
El comando groupmod permite modificar el nombre o GID de un grupo. Sintaxis:
[BASH]# groupmod [-g nuevo-gid] [-n nuevoNombre] nombreDelGrupo
Opciones:
OpcionesDescripcion
-g Esta opcion cambia el GID de un grupo existente en el sistema
-n Esta opcion sirve para cambiar el nombre de un grupo existente por otro
groupdel
El comando groupdel elimina un grupo del sistema Sintaxis:
[BASH]# groupdel nombreDelGrupo
gpasswd
Permite administrar los grupos,se puede utilizar para añadir y eliminar usuarios, señalar un administrador e indicar una contrasela para el grupo.
NOTA: Las contraseñas de grupo solo son necesarias su un usuario que no es miembro del mismo quisiera anexarse al grupo y convertirlo en uno
de sus grupos efectivos, para ello debera proporcioonar la contraseña del grupo
Sintaxis:
[BASH]# gpasswd opciones [nombreDelGrupo]
Opciones para el administrador del sistema
-R Hace que el grupo sea reservado para miembros
-A usuario,, grupo Señala como administrador de un grupo particular a un usuario del grupo
-M usuario,, grupoAñade miembros a un grupo
-r grupo Elimina la contraseña del grupo
Opciones para el administrador del grupo
-a usuario,, grupoSe añade permanentemente un usuario a un grupo
-d usuario,, grupoSe borra permanentemente a un usuario del grupo
-r grupo Elimina la contraseña del grupo
grpck
El comando grpck revisa un grupo de sistema Sintaxis:
[BASH]# grpck nombreDelGrupo
Fichero /etc/group
Este archivo guarda la relación de los grupos a los que pertenecen los usuarios del sistema, contiene una línea para cada usuario con tres o cuatro
campos por usuario: Ejemplo:
El campo 1 indica el usuario.

El campo 2 ‘x’ indica la contraseña del grupo, que no existe, si hubiera se mostraría un ‘hash’ encriptado.
35 de 63 24/07/2010 11:53 p.m.

El campo 3 es el Group ID (GID) o identificación del grupo.

El campo 4 es opcional e indica la lista de grupos a los que pertenece el usuario
Actualmente al crear al usuario con useradd se crea también automáticamente su grupo principal de trabajo GID, con el mismo nombre del usuario.
Es decir, si se añade el usuario ’paola’ también se crea el /etc/group el grupo ’paola’.
Fichero /etc/gshadow
Este fichero almacena las contraseñas cifradas de los grupos,los administradores de cada grupo y los usuarios que pertenecen a cada grupo,
contiene una linea para cada grupo con cuatros campos por grupo: Ejemplo:
NombreDelGrupoContraseña o !listaDeAdministradoreslistaDeMiembros
Cada uno de estos campos separado por el identificador : La lista de administradores y miembros de un grupo deben estar separados mediante el
identificador
pwconv y pwunconv
El comportamiento por defecto de todas las distros modernas de GNU/Linux es activar la protección extendida del archivo /etc/shadow, que (se
insiste) oculta efectivamente el ‘hash’ cifrado de la contraseña de
/etc/passwd
Pero si por alguna bizarra y extraña situación de compatibilidad se requiriera tener las contraseñas cifradas en el mismo archivo de /etc/passwd se
usaría el comando pwunconv:
[BASH]# more /etc/passwd

root:x:0:0:root:/root:/bin/bash
hack:x:501:500:Hack Beastie:/home/hack:/bin/bash
La 'x' en el campo 2 indica que se hace uso de /etc/shadow como mencionamos anteriormente.
[BASH]# more /etc/shadow

root:ghy675gjuXCc12r5gt78uuu6R:10568:0:99999:7:7:-1::
hack:rfgf886DG778sDFFDRRu78asd:10568:0:-1:9:-1:-1::
[BASH]#pwunconv
[BASH]# more /etc/passwd

root:ghy675gjuXCc12r5gt78uuu6R:0:0:root:/root:/bin/bash
sergio:rfgf886DG778sDFFDRRu78asd:501:500:Hack Beastie:/home/hack:/bin/bash
En cualquier momento es posible reactivar la protección de shadow:
[BASH]# pwconv
[BASH]# ls -l /etc/passwd /etc/shadow
-rw-r--r-- 1 root root 1106 2007-07-08 01:07 /etc/passwd
-r-------- 1 root root 699 2009-07-08 01:07 /etc/shadow
Se vuelve a crear el archivo shadow, además nótese los permisos tan restrictivos (400) que tiene este archivo, haciendo sumamente difícil que
cualquier usuario que no sea root lo lea.
grpconv y grpunconv
Estos comandos funcionan de la misma manera que pwconv y pwunconv, solo que aplicados a los ficheros
/etc/group
/etc/gshadow
Automatizar tareas de administración del sistema mediante la programación de scripts de trabajo
Sobre CRON
Cron es un administrador o planificador de tareas de segundo plano. Es un demonio que ejecuta procesos, programas o scripts, a intervalos
regulares programados. Por ejemplo podemos instruirlo para ejecutar un script cada cinco minutos, una copia de seguridad diaria, o una exportacion
semanal de la base de datos. Las horas a las que deben ejecutarse dichos procesos se indican en el fichero crontab correspondiente al usuario. En
el sistema operativo Unix, cron es un administrador regular de procesos en segundo plano (demonio) que ejecuta procesos o scripts a intervalos
regulares (por ejemplo, cada minuto, de semana o mes). Los procesos que deben ejecutarse y la hora en la que deben hacerlo se especifican en el
archivo crontab correspondiente.
En este modulo veremos como:
36 de 63 24/07/2010 11:53 p.m.

Añadir tareas al crontab de root

Añadir tareas enlazadas cada hora, diarias, semanales y mensuales
Añadir tareas al crontab del sistema
El crontab de root
El fichero crontab de root se guarda en /var/spool/cron/crontabs/root, pero nunca editaremos los ficheros de cron directamente. Para editar el
crontab (fichero donde se guardan las tareas programadas) de root, utilizaremos siempre la utilidad crontab. Concretamente utilizaremos la orden
crontab -e
[BASH]# crontab -e
Utilizaremos siempre esta orden en lugar de ir a buscar el fichero con un editor de texto ya que asi nos garantizamos que estamos editando un
fichero auxiliar en exclusiva, y evitaremos problemas de concurrencia con otros administradores. Probablemente crontab nos presentara un fichero
vacio o bien con la siguiente lınea de cabeceras:
# m h dom mon dow command
Esta linea simplemente nos servira de guion para escribir debajo de ella nuestras tareas. Como se puede ver nos esta indicando el formato, primero
los minutos, luego la hora, el dia del mes, el mes y el dia de la semana, es decir:
# minutos horas diaDelMes mes1-12 diaDeLaSemana1-7 comandoAEjecutar
No obstante añadiremos unas lineas al principio, dandole algunas variables de entorno de nuestro interes, por ejemplo:
SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin/:/bin/:/usr/sbin:/usr/bin
MAILITO=sistemas@factor.com
Las variables:
SHELL Indicaremos con que interprete deberemos ejecutar los comandos

PATH Estableceremos el camino de busqueda de comandos que debera seguir el sistema.
Definiremos a que correo iran los avisos en caso de algo vaya mal al ejecutar una de las tareas. Estas variables no son estrictamente
MAILTO
necesarias, solo son para ajustarlas si queremos.
Listando el crontab
Para obtener un listado de las tareas programadas de root, ejecute lo siguiente:
[BASH]# crontab -l
Evidentemente no saldran tareas si todavia no hemos programado ninguna.
Programando tareas
Para programar una tarea utilizaremos la orden crontab -e. Por ejemplo para programar una tarea que a las 19h genere un mensaje en un log,
escribiremos lo siguiente:
[BASH]# crontab -e
SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
0 19 * * * echo "Son las 19h." >> /var/log/mi-cron.log
Si quisieramos que se ejecutase a las 19:30h pero solo los lunes pondriamos:

30 19 * * 1 echo "Son las 19:30h. del lunes." >> /var/log/mi-cron.log
Y si quisieramos que se ejecute a las 19:30 del dia 1 de diciembre

30 19 1 12 * echo "Son las 19:30h. del 1 de diciembre." >> /var/log/mi-cron.log
¿Que pasa si queremos que se ejecute a las 19 y 19:30? Se puede poner mas de un valor en cada campo, separandolos por comas:
37 de 63 24/07/2010 11:53 p.m.

0,30 19 * * * echo "Son las 19 o las 19:30h. No estoy seguro." >> /var/log/mi-cron.log
¿Y para ejecutarlo cada 5 minutos? Se podria poner “5,10,15,20,25” pero hay una abreviatura, asi “*/min”

*/5 * * * * echo "Han pasado cinco minutos." >> /var/log/mi-cron.log
Directorios predefinidos: hourly, daily, weekly y monthly

Los sistemas UNIX modernos vienen con unos directorios predefinidos para que cron los lee y ejecute lo que hay dentro en los intervalos que su
nombre indica:
/etc/cron.daily
/etc/cron.hourly
/etc/cron.weekly
/etc/cron.monthly
Dichos directorios se suelen utilizar para enlazar guiones que deban ser llamados en el intervalo correspondiente al directorio, sin argumentos. Por
ejemplo, si creamos un guion de bash y lo guardamos en /root/bin, le damos permisos de ejecucion, y lo enlazamos en /etc/cron.hourly, cron lo
ejecutar ́ cada hora:
[BASH]# chmod +x /root/bin/miScript.sh

[BASH]# ln -s /root/bin/miScript.sh /etc/cron.hourly/
Crontab del sistema

El archivo de cron de sistema es /etc/crontab. Si ponemos tareas en dicho archivo seran ejecutadas igualmente, pero no es recomendable. Este
crontab se deja para que lo maneje la distribucion y sus programas. Es igual que el crontab de root, salvo que en este podemos especificar con que
usuario se ejecuta cada cosa, y cron hara una suplantacion previa a la ejecucion.
Un /etc/crontab tıpico es:
[BASH]# cat /etc/crontab

# etc/crontab: system-wide crontab
# Unlike any other crontab you don’t have to run the ‘crontab’
# command to install the new version when you edit this file
# and files in /etc/cron.d. These files also have username fields,
# that none of the other crontabs do.
SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
# m h dom mon dow user command
17 * * * * root cd / && run-parts --report /etc/cron.hourly
25 6 * * * root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )
47 6 * * 7 root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.weekly )
52 6 1 * * root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.monthly )
#
Log de cron
En Debian 5 Lenny el log de cron viene desactivado por defecto. Para activarlo tendremos que editar el fichero /etc/default/cron y eliminar la
almohadilla (#) del principio de la linea EXTRA_OPTS="-L 2" dejando el fichero asi:
# cat /etc/default/cron
# Cron configuration options
# Uncomment this option for LSB name support in /etc/cron.d/
#LSBNAMES=’-l’
# Whether to read the system’s default environment files (if present)
# This will make cron set a proper charset for the mails it sends
# Comment this or set it to something other than ’yes’ to prevent
# cron from reading it.
READ_ENV="yes"
# Extra options for cron, see cron(8)
# For example, set a higher log level to audit cron’s work
EXTRA_OPTS="-L 2"
De esta forma conseguiremos que cron vaya dejando un rastro en /var/log/syslog que podremos observar, por ejemplo, asi:
[BASH]# tail -f /var/log/syslog
38 de 63 24/07/2010 11:53 p.m.

Administrando la hora del equipo
En este capitulo aprenderemos a configuar la hora del sistema mediante el uso de servidores de tiempo NTP.
Reloj de tiempo bajo linux
Linux utiliza dos relojes:
Reloj de Hardware
Reloj de Software
Un equipo personal tiene un reloj de hardware alimentado por una batería. Esa batería asegura que el reloj continúe trabajando aún cuando la
computadora se encuentre sin suministro eléctrico. El reloj de hardware puede ser modificado (o definido) desde la pantalla de configuración de la
BIOS o desde cualquier sistema operativo. El kernel Linux mantiene la fecha y hora de manera independiente al reloj de hardware. Durante el inicio
de un sistema Linux, el kernel configura su propio reloj de software accediendo a la fecha y hora mantenida por el reloj de hardware. Luego, ambos
relojes trabajan independientemente. Linux mantiene su propio reloj debido a que leer el reloj de hardware constantemente es lento y complicado. El
reloj del kernel siempre muestra la hora universal, por lo que no necesita conocer como utilizar usos horarios. La simplicidad de este modo de
trabajar proporciona alta confiabilidad y facilita actualizar la información de la zona horaria. Cada proceso realiza las conversiones de zona horaria
de manera independiente. El reloj de hardware puede estar en formato de hora local u hora universal. Usualmente es mejor que el reloj de hardware
mantenga la hora universal, porque de esta manera no será necesario modificar la hora del reloj cuando el horario de verano empiece o finalice.
Programas para controlar el reloj del sistema

Bajo linux existen 2 herramientas principales que son implementadas para administrar el reloj hardware y el de software del sistema, estas
herramientas son:
hwclockControla el reloj de hardware

date Controla el reloj del sistema
Ajustes de tiempo y de las zonas horarias
Hay 2 formas estándar para ajustar el reloj de un equipo
localtimePor ubicacion geografica

El tiempo universal coordinado, o UTC, en español, también conocido como tiempo civil, es el tiempo de la zona horaria de referencia
UTC
respecto a la cual se calculan todas las otras zonas del mundo
Ajuste de la hora en Linux

El procedimiento es relativamente simple:
1) El primero consiste en ajustar el reloj de Hardware a traves de la configuracion del BIOS 2) El segundo consiste en establecer la variable de
entorno TZ a la zona horaria adecuada utilizando el siguiente comando
[BASH]# tzselect
Alternativa al paso 2 Utilice el programa tzconfig que establecerá un enlace simbólico de la siguiente forma:
[BASH]# ln -s /usr/share/zoneinfo/Mexico/General /etc/localtime
3) El tercero consiste en decirle a Linux que nuestro reloj de hardware y de sistema correb bajo UTC, para ello teclee lo siguiente:
[BASH]# hwclock --utc --hctosys
Comando hwclock
Hwclock es una herramienta que nos permite:
Acceder al Reloj del Hardware

Mostrar la hora actual
Poner el Reloj del Hardware a una hora especificada
Poner el Reloj del Hardware a la Hora del Sistema
Poner el Tiempo del Sistema desde el Reloj del Hardware.
también puede ejecutar hwclock periódicamente para insertar o quitar tiempo del Reloj del Hardware para compensar desviaciones sistemáticas en
las que el reloj gana o pierde tiempo consistentemente a una cierta velocidad si se deja solo.
Sintaxis:
[BASH]# hwclock [opciones]
Opciones:
OpcionesDescripcion
--show Lee el reloj del hardware y muestra la hora en la salida estándar.
--set Pone el reloj del hardware a la hora dada por la opción --date
Pone el tiempo del sistema a partir del reloj del hardware. Ésta es una buena opción para poner en uno de los guiones de arranque del
--hctosys
sistema.
39 de 63 24/07/2010 11:53 p.m.

--systohcPone el reloj del hardware a la hora del sistema actual.

Añade o sustrae tiempo del reloj del hardware para tener en cuenta el desvío sistemático desde la última vez que el reloj se puso o se
--adjust
ajustó. Vea la discusión al respecto más adelante.
Indica que el reloj del hardware se mantiene en el tiempo universal coordinado (UTC). Es cosa suya si mantiene su reloj en hora local o
--utc
UTC, pero nada en el reloj le dice qué es lo que ha escogido. Así que con esta opción es como le da esa información a hwclock.
Comando date
Este programa se utiliza para mostrar o establecer la hora del sistema
Sintaxis:
[BASH]# date [opciones] [+FORMATO]
Formato:
OpcionesDescripcion
Una literal %
%a Localización del nombre abreviado del día de la semana (Sun,Sat)
%A Localización del nombre completo del día de la semana (Sunday,Saturday)
%b Localización del nombre abreviado del nombre del mes
%c Localizacion de fecha y hora (Sat Nov 04 12:02:33 EST 1989)
%C Siglo (año dividido por 100 y truncado a un entero) 00-99
%d Dia del mes (01..31)
%D Fecha (mm/dd/yy)
%e Dia del mes (1..31,), a diferencia de %d este suprime el espacio en blanco
%F Lo mismo que %Y-%m-%d
%h Lo mismo que %b
%H Hora (00..23)
%I Hora (01..12)
%j Dia del año (001..366)
%k Hora (0..23)
%l Hola (1..12)
%m Mes (01..12)
%M Minutos (00..59)
%n Una nueva linea
%N Nanosegundos (000000000..999999999)
%p Indicacion de PM o AM en mayusculas
%P Indicacion de pm o am en minusculas
%r Tiempo en 12 horas ( hh:mm:ss AP M)
%R Tiempo en 24 horas ( hh:mm )
%s Segundos desde `00:00:00 1970-01-01 UTC' (una extesion de GNU )
%S Segundos (00..60);
%t Un tabulador horizontal
%T Tiempo , 24 horas (hh:mm:ss)
%u Dia de la semana (1..7) el dia 1 representa el lunes
%U Número de semana del año con el domingo como primer día de la semana (00..53)
%V Número de semana del año con el lunes como primer día de la semana (00..53)
%w Dia de la samana (0..6); 0 representa el Domingo
%W Numero de la semana del año con Lunes como primer dia de la semana (00..53)
%x Representacion de la fecha local (mm/dd/yy)
%X Representacion de la hora local (%H:%M:%S)
%y Los ultimos dos digitos del año (00..99)
%Y Año (1970..)
Servicios Esenciales del Sistema
Mail Transfer Agent Basico
Protocolo SMTP
Simple Mail Transfer Protocol (SMTP) Protocolo Simple de Transferencia de Correo, es un protocolo de la capa de aplicación. Protocolo de red
basado en texto utilizado para el intercambio de mensajes de correo electrónico entre computadoras u otros dispositivos SMTP se basa en el modelo
cliente-servidor, donde un cliente envía un mensaje a uno o varios receptores. La comunicación entre el cliente y el servidor consiste enteramente en
líneas de texto compuestas por caracteres ASCII. El tamaño máximo permitido para estas líneas es de 1000 caracteres. Las respuestas del servidor
constan de un código numérico de tres digitos, seguido de un texto explicativo. El número va dirigido a un procesado automático de la respuesta por
autómata, mientras que el texto permite que un humano interprete la respuesta. En el protocolo SMTP todas las órdenes, réplicas o datos son líneas
40 de 63 24/07/2010 11:53 p.m.

de texto, delimitadas por el carácter <CRLF>. Todas las réplicas tienen un código numérico al comienzo de la línea. En el conjunto de protocolos
TCP/IP, el SMTP va por encima del TCP, usando normalmente el puerto 25 en el servidor para establecer la conexión.
Protocolo POP3
POP3 está diseñado para recibir correo, no para enviarlo; le permite a los usuarios con conexiones intermitentes ó muy lentas (tales como las
conexiones por módem), descargar su correo electrónico mientras tienen conexión y revisarlo posteriormente incluso estando desconectados. Cabe
mencionar que la mayoría de los clientes de correo incluyen la opción de dejar los mensajes en el servidor, de manera tal que, un cliente que utilice
POP3 se conecta, obtiene todos los mensajes, los almacena en la computadora del usuario como mensajes nuevos, los elimina del servidor y
finalmente se desconecta. En contraste, el protocolo IMAP permite los modos de operación conectado y desconectado. Los clientes de correo
electrónico que utilizan IMAP dejan por lo general los mensajes en el servidor hasta que el usuario los elimina directamente. Esto y otros factores
hacen que la operación de IMAP permita a múltiples clientes acceder al mismo buzón de correo. La mayoría de los clientes de correo electrónico
soportan POP3 ó IMAP; sin embargo, solo unos cuantos proveedores de internet ofrecen IMAP como valor agregado de sus servicios.
Protocolo IMAP
Internet Message Access Protocol, o su acrónimo IMAP, es un protocolo de red de acceso a mensajes electrónicos almacenados en un servidor.
Mediante IMAP se puede tener acceso al correo electrónico desde cualquier equipo que tenga una conexión a Internet. IMAP tiene varias ventajas
sobre POP, que es el otro protocolo empleado para obtener correo desde un servidor. Por ejemplo, es posible especificar en IMAP carpetas del lado
servidor. Por otro lado, es más complejo que POP ya que permite visualizar los mensajes de manera remota y no descargando los mensajes como lo
hace POP.
Ventajas sobre POP3
Respaldo para los modos de operación conetado y desconectado
Al utilizar POP3, los clientes se conectan brevemente al servidor de correo, solamente el tiempo que les tome descargar los nuevos mensajes. Al
utilizar IMAP, los clientes permanecen conectados el tiempo que su interfaz permanezca activa y descargan los mensajes bajo demanda. Esta
manera de trabajar de IMAP puede dar tiempos de respuesta más rápidos para usuarios que tienen una gran cantidad de mensajes o mensajes
grandes.
Respaldo para que la información de estado del mensaje se mantenga en el servidor
A través de la utilización de señales definidas en el protocolo IMAP4 de los clientes, se puede vigilar el estado del mensaje, por ejemplo, si el mensaje
ha sido o no leído, respondido o eliminado. Estas señales se almacenan en el servidor, de manera que varios clientes conectados al mismo correo
en diferente tiempo pueden detectar los cambios hechos por otros clientes.
Respaldo para búsquedas de parte del servidor
IMAP4 proporciona un mecanismo para que los clientes pidan al servidor que busque mensajes de acuerdo a una cierta variedad de criterios. Este
mecanismo evita que los clientes descarguen todos los mensajes de su buzón de correo, agilizando, de esta manera, las búsquedas.
Sobre Sendmail
Las raíces de Sendmail se remontan al nacimiento del correo electrónico, una década antes de que naciese ARPANET, el precursor de Internet. Por
entonces, cada buzón de usuario era un fichero con derechos de sólo lectura y las aplicaciones de correo eran simplemente texto incorporado en
ese fichero. Cada usuario tenía que abrir y meterse de lleno en el fichero de correo para buscar correos antiguos y leer el correo nuevo era toda
una faena. La primera transferencia real de un fichero de mensaje de correo entre dos equipos tuvo lugar hasta el año de 1972, año en el que el
correo electrónico empezó a transferirse por FTP a través de un protocolo de red NCP. Este método de comunicación más sencillo muy pronto se
hizo popular, incluso hasta el punto de representar la mayor parte del tráfico de ARPANET en menos de un año. Sin embargo, la falta de estándares
entre los protocolos existentes convirtió al correo electrónico en más difícil de enviar desde algunos sistemas y así continuó hasta que ARPANET
creó el estándar TCP/IP en 1982. Un nuevo protocolo, SMTP, que se materializaba en el transporte de mensajes. Estos avances, en combinación
con la sustitución de los ficheros host por dns, permitieron que se materializasen los agentes MTA con funciones completas. Sendmail, que creció a
partir de un precedente sistema de entrega de correo electrónico denominado Delivermail, muy pronto se convirtió en estándar a medida que Internet
comenzaba a expandirse y a utilizarse más ampliamente. El unico punto debil que preseta sendmail es que este este posee el mayor numero de
errores los cuales son reparados casi de inmediato.
Sendmail en la actualidad
Algunos analisis y encuentas nos expresan comentarios muy buenos sobre Sendmail, esto de acuerdo a una encuesta realizada por la editorial
O'Reilly, la cual formulo la siguiente pregunta ¿Cuantas empresas tienen implementado como servidor de correo a Sendmail? Para dicha encuesta se
seleccionaron al rededor de 400 000 dominios, de los cuales el 12.3 % de los encuestados respondieron que tenian implementado a Sendmail como
servidor de correo, el segundo lugar fue para Postfix con un 8.6 % y en tercer lugar tenemos a Postini con el 8.5%
Sobre Postfix
Postfix es un Agente de Transporte de Correo (MTA) de software libre / código abierto, un programa informático para el enrutamiento y envío de
correo electrónico, creado con la intención de que sea una alternativa más rápida, fácil de administrar y segura al ampliamente utilizado Sendmail.
Formalmente conocido como VMailer e IBM Secure Mailer, fue originalmente escrito por Wietse Venema durante su estancia en el Thomas J.
Watson Research Center de IBM, y continúa siendo desarrollado activamente. Postfix es el agente de transporte por omisión en diversas
distribuciones de Linux y en las últimas versiones del Mac OS X.
Sobre Exim
41 de 63 24/07/2010 11:53 p.m.

Exim (EXperimental Internet Mailer) es un agente de transporte de correo (Mail Transport Agent, usualmente MTA) desarrollado por la Universidad de
Cambridge y puede ser utilizado en la mayoría de los sistemas Unix (entre ellos GNU/Linux). Si bien puede compilarse en sistemas operativos
Windows, se recomienda que sea utilizado en producción sobre sistemas operativos de la familia Unix. Se distribuye sin costo bajo la licencia GNU
GPL por lo que es, además, software libre. Tiene una gran flexibilidad en los caminos que pueden seguir los mensajes según su origen y por
presentar funcionalidades para control de spam, listas de bloqueo basados en DNS (DNSBL), virus, control de relay, usuarios y dominios virtuales y
otros, que se configuran y mantienen en forma más o menos sencilla. El proyecto cuenta con buena documentación, ejemplos y recetas claras de
“como hacer” determinadas tareas. En términos generales se destaca que no existen situaciones para las que Exim sea una opción incorrecta y en
muchas situaciones se desempeña como la mejor opción. Exim es el MTA por defecto en las distribuciones Debian GNU/Linux.
Sobre Qmail
Qmail es un servidor de correo electrónico (SMTP) hecho para Unix. Utiliza el formato maildir para almacenar mensajes (un archivo por mensaje),
eliminando varios problemas asociados al manejo del formato mbox. Qmail es distribuido como código fuente (sourcecode), escrito en lenguaje C.
Administrar impresoras e impresiones
Como imprimir en Linux

En Linux podemos imprimir de tres maneras:
1.Escribir directamente en la impresora: la forma más sencilla de imprimir un archivo en Linux es enviarlo directamente a la impresora. Por ejemplo,
para imprimir investigacion.txt haremos:
[BASH]#cat investigacion.txt > /dev/lp0
2.El sistema lpr/lpd es la versión para Linux del sistema lp (Line Printer) de UNIX. Hasta que apareció CUPS era el sistema estándar de imprimir en
Linux. Incluso ahora, es el sistema que se instala por defecto.
3.El sistema CUPS (Common UNIX Printing System): actualmente es el sistema estándar de impresión en Linux. En el entorno gráfico, las
aplicaciones que pueden imprimir son compatibles tanto con lpr/lpd como con CUPS: utilizarán el sistema que esté instalado, trabajarán sobre él y
obtendrán automáticamente las propiedades de la impresora.
En que consiste el sistema de impresion CUPS

El sistema de impresión CUPS reemplaza al sistema de impresión lpr/lpd y consiste en lo siguiente: 1.El demonio de impresión cupsd (print spooler
daemon): vigila los directorios spool buscando trabajos a imprimir. Cuando aparece alguno, cupsd lanza una copia de sí mismo que imprimirá el
archivo en la impresora apropiada. 2.La cola de impresión (spool): ubicada en el directorio /var/spool/cups, donde se almacenan los trabajos a
imprimir. Los nuevos trabajos a imprimir se colocan en la cola de impresión a la espera: el primero que entra es el primero que sale. 3.Los comandos
lpr/lpd para manejar la cola de impresión: el sistema lpr/lpd es uno de los estándares de UNIX, y las aplicaciones asumen que tendrán los comandos
de este sistema de impresión disponibles. Por este motivo CUPS proporciona su propia versión de esos comandos, que son:
lpr (o lp): enviar trabajos a la cola de impresión. Este comando copia el archivo a imprimir en el directorio de spool, donde permanece hasta
que el demonio cupsd lo imprime. Su sintaxis es:
[BASH]# lpr <archivo>
lpq: consultar los trabajos pendientes en la cola de impresión.

lpc: configurar las impresoras.
lprm: eliminar trabajos de la cola de impresión.
4.los drivers PPD de las impresoras PostScript: en Linux, cuando una aplicación envía un documento a la impresora genera un archivo PostScript.
Si la impresora entiende el lenguaje PostScript puede imprimir el documento directamente. Sólo tenemos que decirle a CUPS cuáles son las
características de la impresora, y eso lo hace el archivo PPD (Postscript Printer Description): contiene todas las características de la impresora,
como tamaños de papel, colores, resoluciones disponibles, etc.
Si la impresora no entiende PostScript debemos traducir los documentos que generan las aplicaciones (PostScript) a un lenguaje que entienda la
impresora, por lo que necesitamos un filtro. De esto se encarga Foomatic (paquete foomatic-db-engine): proporciona el archivo PPD y los filtros
necesarios para traducir los documentos (trabaja sobre GhostScript). En ambos casos, el archivo PPD de la impresora se puede descargar desde
LinuxPrinting (linuxprinting.org) o desde la web de CUPS (cups.org) y se debe guardar en el directorio /usr/share/cups/model.
5.Los comandos CUPS para administrar las impresoras:
lpinfo
lpadmin
enable
disable
accept
reject
lpoptions
lpstat
6.La interfaz web de CUPS: es la mejor opción para administrar CUPS.
42 de 63 24/07/2010 11:53 p.m.

Instalar una impresora local con CUPS

Veamos cómo instalar una impresora local con CUPS utilizando su interfaz web:
conectamos la impresora.
conseguimos e instalamos el archivo PPD de nuestra impresora.
instalamos Foomatic si la impresora no es PostScript.
reiniciamos el demonio de CUPS:
[BASH]# /etc/init.d/cups start
accedemos al interfaz web de CUPS:
[http://localhost:631
entramos a Administracion
pulsamos Añadir impresora e introducimos Nombre de la impresora: HP Lasser Jet, Ubicación: Oficina: HP Laser.
en la siguiente pantalla nos preguntará Tipo de conexión:
seleccionamos el modelo.
nos pedirá Usuario y Contraseña, ya que para administrar impresoras hay que tener permisos de root (la contraseña se envía en texto plano,
sin encriptar).
y ya tenemos la impresora instalada.
pulsando en Impresoras iremos a la página de la nueva impresora. Desde aquí podemos monitorizar los trabajos de impresión, cambiar las
opciones de configuración y seleccionarla como impresora predeterminada.
para terminar, comprobamos que realmente funciona lanzando una página de prueba con Imprimir página de prueba.
Compartir nuestra impresora

Tenemos dos posibilidades para compartir nuestra impresora:
1.que CUPS escuche conexiones de máquinas remotas Los equipos que dispongan de un cliente IPP (Linux, Unix, Mac y Windows XP) podrán
conectar con el demonio de impresión cupsd de nuestra máquina mediante el protocolo IPP (Internet Printing Protocol, puerto 631 TCP), e imprimir
en nuestra impresora, una vez que les permitamos acceder. Para ello, en el archivo de configuración de CUPS, /etc/cups/cupsd.conf
especificaremos qué máquinas tienen acceso a CUPS. Buscaremos las líneas:
<Location />
Order Deny,Allow
Deny All
Allow 127.0.0.1
</Location>
Vemos que por defecto sólo puede acceder a CUPS la propia máquina (127.0.0.1). Para que puedan acceder las máquinas de la LAN añadiremos la
línea:
Allow 192.168.0.0/255.255.255.0
Para terminar reiniciamos el demonio de CUPS:
[BASH]# /etc/init.d/cups restart
Una vez compartida la impresora, es muy sencillo imprimir desde Linux:
Interfaz web de CUPS http://localhost:631

Administración, Añadir impresora
Introducimos Nombre de la impresora, Ubicación y Descripción
Tipo de conexión, Internet Printing Protocol (IPP).
URL de la conexión, ipp:192.168.0.2/printers/Canon.
Modelo, Usuario y Contraseña y la impresora ya está instalada.
Asistente para agregar impresoras
Impresora de red o una impresora conectada a otra computadora
Conectarse a una impresora en Internet o en su red doméstica u organización
URL de la conexión, http://192.168.0.2:631/printers/Canon.
Instalamos los drivers de la impresora desde el CD del fabricante
1.Que el servidor Samba atienda peticiones remotas y las pase a CUPS Los equipos que dispongan de un cliente SMB (Windows) podrán
conectar con el servidor Samba (paquete samba) de nuestra máquina mediante el protocolo SMB (puerto 139 TCP), y éste se encargará de
pasarle la petición a CUPS.
43 de 63 24/07/2010 11:53 p.m.

Vamos a configurar el servidor Samba para compartir nuestra impresora. Primero crearemos en nuestro sistema un usuario específico (smbprint)
para que acceda a la impresora mediante Samba. Si queremos permitir acceso anónimo lo podemos crear sin contraseña:
[BASH]# # /usr/sbin/adduser --system --disabled-password smbprint
Para compartir nuestra impresora CUPS y que sólo el usuario smbprint tenga acceso a ella, como invitado (por lo que todas las máquinas de la red
local y con conexión directa desde Internet podrán imprimir), editaremos el archivo /etc/samba/smb.conf poniendo:
[printers]
browseable = yes
printable = yes
public = yes
guest only = yes
guest account = smbprint
path = /home/smbprint
Además tenemos que decirle a Samba que el sistema de impresión es CUPS, no lpr/lpd, por lo que cambiaremos /etc/samba/smb.conf para que
quede:
[global]
printcap name = cups
printing = cups
Grabamos los cambios y reiniciamos Samba:
[BASH]# /etc/init.d/samba restart
Una vez compartida la impresora, es muy sencillo imprimir desde Windows:
localizamos nuestra máquina en el Explorador de archivos. Veremos que tiene una impresora compartida.
pulsamos Conectar... e instalamos los drivers desde el CD del fabricante.
Fundamentos de Red
Fundamentos de TCP/IP
Sobre TCP/IP
La familia de protocolos de Internet es un conjunto de protocolos de red en la que se basa Internet y que permiten la transmisión de datos entre
redes de computadoras. En ocasiones se le denomina conjunto de protocolos TCP/IP, en referencia a los dos protocolos más importantes que la
componen: Protocolo de Control de Transmisión (TCP) y Protocolo de Internet (IP), que fueron los dos primeros en definirse, y que son los más
utilizados de la familia. Existen tantos protocolos en este conjunto que llegan a ser más de 100 diferentes, entre ellos se encuentra el popular HTTP
(HyperText Transfer Protocol), que es el que se utiliza para acceder a las páginas web, además de otros como el ARP (Address Resolution Protocol)
para la resolución de direcciones, el FTP (File Transfer Protocol) para transferencia de archivos, y el SMTP (Simple Mail Transfer Protocol) y el POP
(Post Office Protocol) para correo electrónico, TELNET para acceder a equipos remotos, entre otros. El TCP/IP es la base de Internet, y sirve para
enlazar computadoras que utilizan diferentes sistemas operativos, incluyendo PC, minicomputadoras y computadoras centrales sobre redes de área
local (LAN) y área extensa (WAN). TCP/IP fue desarrollado y demostrado por primera vez en 1972 por el Departamento de Defensa de los Estados
Unidos, ejecutándolo en ARPANET, una red de área extensa de dicho departamento. La familia de protocolos de Internet puede describirse por
analogía con el modelo OSI (Open System Interconnection), que describe los niveles o capas de la pila de protocolos, aunque en la práctica no
corresponde exactamente con el modelo en Internet. En una pila de protocolos, cada nivel soluciona una serie de problemas relacionados con la
transmisión de datos, y proporciona un servicio bien definido a los niveles más altos. Los niveles superiores son los más cercanos al usuario y tratan
con datos más abstractos, dejando a los niveles más bajos la labor de traducir los datos de forma que sean físicamente manipulables. El modelo de
Internet fue diseñado como la solución a un problema práctico de ingeniería. El modelo OSI, en cambio, fue propuesto como una aproximación
teórica y también como una primera fase en la evolución de las redes de ordenadores. Por lo tanto, el modelo OSI es más fácil de entender, pero el
modelo TCP/IP es el que realmente se usa. Sirve de ayuda entender el modelo OSI antes de conocer TCP/IP, ya que se aplican los mismos
principios, pero son más fáciles de entender en el modelo OSI.
Desarrollo de TCP/IP
La Familia de Protocolos de Internet fueron el resultado del trabajo llevado a cabo por la Agencia de Investigación de Proyectos Avanzados de
Defensa (DARPA por sus siglas en inglés) a principios de los 70. Después de la construcción de la pionera ARPANET en 1969 DARPA comenzó a
trabajar en un gran número de tecnologías de transmisión de datos. En 1972, Robert E. Kahn fue contratado por la Oficina de Técnicas de
Procesamiento de Información de DARPA, donde trabajo en la comunicación de paquetes por satélite y por ondas de radio, reconoció el importante
valor de la comunicación de estas dos formas. En la primavera de 1973, Vint Cerf, desarrollador del protocolo de ARPANET, Network Control
Program(NPC) se unió a Kahn con el objetivo de crear una arquitectura abierta de interconexión y diseñar así la nueva generación de protocolos de
ARPANET. Para el verano de 1973, Kahn y Cerf habian conseguido una remodelación fundamental, donde las diferencias entre los protocolos de
red se ocultaban usando un Protocolo de comunicaciones y además, la red dejaba de ser responsable de la fiabilidad de la comunicación, como
pasaba en ARPANET , era el host el responsable. Cerf reconoció el mérito de Hubert Zimmerman y Louis Pouzin, creadores de la red CYCLADES,
ya que su trabajo estuvo muy influenciado por el diseño de esta red. Un ordenador denominado router (un nombre que fue después cambiado a
44 de 63 24/07/2010 11:53 p.m.

gateway, puerta de enlace, para evitar confusiones con otros tipos de Puerta de enlace) esta dotado con una interfaz para cada red, y envía
Datagrama de ida y vuelta entre ellos. Los requisitos para estor routers están definidos en (Request for Comments 1812).
Esta idea fue llevada a la práctica de una forma mas detallada por el grupo de investigación que Cerf tenía en Stanford durante el periodo de 1973 a
1974, dando como resultado la primera especificación TCP (Request for Comments 675) Entonces DARPA fue contratada por BBN Technologies, la
Universidad de Stanford, y la University College de Londres para desarrollar versiones operacionales del protocolo en diferentes plataformas de
hardware. Se desarrollaron así cuatro versiones diferentes: TCP v1, TCP v2, una tercera dividida en dos TCP v3 y IP v3 en la primavera de 1978, y
después se estabilizó la versión TCP/IP v4 — el protocolo estándar que todavía se emplea en Internet actualmente En 1975, se realizó la primera
prueba de comunicación entre dos redes con protocolos TCP/IP entre la Universidad de Stanford y la University College de Londres(UCL). En 1977,
se realizó otra prueba de comunicación con un protocolo TCP/IP entre tres redes distintas con ubicaciones en Estados Unidos, Reino Unido y
Noruega. Varios prototipos diferentes de protocolos TCP/IP se desarrollaron en múltiples centros de investigación entre los años 1978 y 1983. La
migración completa de la red ARPANET al protocolo TCP/IP concluyó oficialmente el día 1 de enero de 1983 cuando los protocolos fueron activados
permanentemente. En marzo de 1982, el Departamento de Defensa de los Estados Unidos declaró al protocolo TCP/IP el estándar para las
comunicaciones entre redes militares.En 1985, el Centro de Administración de Internet (Internet Architecture Board IAB por sus siglas en inglés)
organizó un Taller de Trabajo de tres días de duración, al que asistieron 250 comerciales promocionando así el protocolo lo que contribuyó a un
incremento de su uso comercial.
Niveles en la pila TCP/IP

Hay algunas discusiones sobre como encaja el modelo TCP/IP dentro del modelo OSI. Como TCP/IP y modelo OSI no están delimitados con
precisión no hay una respuesta que sea la correcta. El modelo TCP/IP no está lo suficientemente dotado en los niveles inferiores como para detallar
la auténtica estratificación en niveles: necesitaría tener una capa extra (el nivel de Red) entre los niveles de transporte e Internet. Protocolos
específicos de un tipo concreto de red, que se sitúan por encima del marco de hardware básico, pertenecen al nivel de red, pero sin serlo. Ejemplos
de estos protocolos son el ARP (Protocolo de resolución de direcciones) y el STP (Spanning Tree Protocol). De todas formas, estos son protocolos
locales, y trabajan por debajo de las capas de Internet. Cierto es que situar ambos grupos (sin mencionar los protocolos que forman parte del nivel
de Internet pero se sitúan por encima de los protocolos de Internet, como ICMP) todos en la misma capa puede producir confusión, pero el modelo
OSI no llega a ese nivel de complejidad para ser más útil como modelo de referencia. El siguiente diagrama intenta mostrar la pila OSI y otros
protocolos relacionados con el modelo OSI original: Normalmente, los tres niveles superiores del modelo OSI (Aplicación, Presentación y Sesión) son
considerados simplemente como el nivel de aplicación en el conjunto TCP/IP. Como TCP/IP no tiene un nivel de sesión unificado sobre el que los
niveles superiores se sostengan, estas funciones son típicamente desempeñadas (o ignoradas) por las aplicaciones de usuario. La diferencia más
notable entre los modelos de TCP/IP y OSI es el nivel de Aplicación, en TCP/IP se integran algunos niveles del modelo OSI en su nivel de Aplicación.
Una interpretación simplificada de la pila TCP/IP se muestra debajo:
Nivel Fisico
El nivel físico describe las características físicas de la comunicación, como las convenciones sobre la naturaleza del medio usado para la
comunicación (como las comunicaciones por cable, fibra óptica o radio), y todo lo relativo a los detalles como los conectores, código de canales y
modulación, potencias de señal, longitudes de onda, sincronización y temporización y distancias máximas.
Nivel de Enlace de Datos
El nivel de enlace de datos especifica cómo son transportados los paquetes sobre el nivel físico, incluyendo los delimitadores (patrones de bits
concretos que marcan el comienzo y el fin de cada trama). Ethernet, por ejemplo, incluye campos en la cabecera de la trama que especifican que
máquina o máquinas de la red son las destinatarias de la trama. Ejemplos de protocolos de nivel de enlace de datos son Ethernet, Wireless Ethernet,
SLIP, Token Ring y ATM. PPP es un poco más complejo y originalmente fue diseñado como un protocolo separado que funcionaba sobre otro nivel
de enlace, HDLC/SDLC. Este nivel es a veces subdividido en Control de enlace lógico (Logical Link Control) y Control de acceso al medio (Media
Access Control).
Nivel de internet
Como fue definido originalmente, el nivel de red soluciona el problema de conseguir transportar paquetes a través de una red sencilla. Ejemplos de
protocolos son X.25 y Host/IMP Protocol de ARPANET.
Con la llegada del concepto de Internet, nuevas funcionalidades fueron añadidas a este nivel, basadas en el intercambio de datos entre una red
origen y una red destino. Generalmente esto incluye un enrutamiento de paquetes a través de una red de redes, conocida como Internet. En la
familia de protocolos de Internet, IP realiza las tareas básicas para conseguir transportar datos desde un origen a un destino. IP puede pasar los
datos a una serie de protocolos superiores; cada uno de esos protocolos es identificado con un único "Número de protocolo IP". ICMP y IGMP son
los protocolos 1 y 2, respectivamente.
Algunos de los protocolos por encima de IP como ICMP (usado para transmitir información de diagnóstico sobre transmisiones IP) e IGMP (usado
para dirigir tráfico multicast) van en niveles superiores a IP pero realizan funciones del nivel de red e ilustran una incompatibilidad entre los modelos
de Internet y OSI. Todos los protocolos de enrutamiento, como BGP, OSPF, y RIP son realmente también parte del nivel de red, aunque ellos
parecen pertenecer a niveles más altos en la pila.
Nivel de Transporte
Los protocolos de enrutamiento dinámico que técnicamente encajan en el conjunto de protocolos TCP/IP (ya que funcionan sobre IP) son
generalmente considerados parte del nivel de red; un ejemplo es OSPF (protocolo IP número 89).
TCP (protocolo IP número 6) es un mecanismo de transporte fiable y orientado a conexión, que proporciona un flujo fiable de bytes, que asegura
45 de 63 24/07/2010 11:53 p.m.

que los datos llegan completos, sin daños y en orden. TCP realiza continuamente medidas sobre el estado de la red para evitar sobrecargarla con
demasiado tráfico. Además, TCP trata de enviar todos los datos correctamente en la secuencia especificada. Esta es una de las principales
diferencias con UDP, y puede convertirse en una desventaja en flujos en tiempo real (muy sensibles a la variación del retardo) o aplicaciones de
enrutamiento con porcentajes altos de pérdida en el nivel de Internet. Más reciente es SCTP, también un mecanismo fiable y orientado a conexión.
Está relacionado con la orientación a byte, y proporciona múltiples sub-flujos multiplexados sobre la misma conexión. También proporciona soporte
de multihoming, donde una conexión puede ser representada por múltiples direcciones IP (representando múltiples interfaces físicas), así si hay un
fallo la conexión no se interrumpe. Fue desarrollado inicialmente para aplicaciones telefónicas (para transportar SS7 sobre IP), pero también fue
usado para otras aplicaciones. UDP (protocolo IP número 17) es un protocolo de datagramas sin conexión. Es un protocolo no fiable (best effort al
igual que IP) - no porque sea particularmente malo, sino porque no verifica que los paquetes lleguen a su destino, y no da garantías de que lleguen
en orden. Si una aplicación requiere estas características, debe llevarlas a cabo por sí misma o usar TCP. UDP es usado normalmente para
aplicaciones de streaming (audio, video, etc) donde la llegada a tiempo de los paquetes es más importante que la fiabilidad, o para aplicaciones
simples de tipo petición/respuesta como el servicio DNS, donde la sobrecarga de las cabeceras que aportan la fiabilidad es desproporcionada para
el tamaño de los paquetes. DCCP está actualmente bajo desarrollo por el IETF. Proporciona semántica de control para flujos TCP, mientras de cara
al usuario se da un servicio de datagramas UDP. TCP y UDP: son usados para dar servicio a una serie de aplicaciones de alto nivel. Las
aplicaciones con una dirección de red dada son distinguibles entre sí por su número de puerto TCP o UDP. Por convención, los puertos bien
conocidos (well-known ports) son asociados con aplicaciones específicas. RTP es un protocolo de datagramas que ha sido diseñado para datos en
tiempo real como el streaming de audio y video que se monta sobre UDP.
Nivel de Aplicacion
El nivel de aplicación es el nivel que los programas más comunes utilizan para comunicarse a través de una red con otros programas. Los procesos
que acontecen en este nivel son aplicaciones específicas que pasan los datos al nivel de aplicación en el formato que internamente use el programa
y es codificado de acuerdo con un protocolo estándar. Algunos programas específicos se considera que se ejecutan en este nivel. Proporcionan
servicios que directamente trabajan con las aplicaciones de usuario. Estos programas y sus correspondientes protocolos incluyen a HTTP
(HyperText Transfer Protocol), FTP (Transferencia de archivos), SMTP (correo electrónico), SSH (login remoto seguro), DNS (Resolución de
nombres de dominio) y a muchos otros. Una vez que los datos de la aplicación han sido codificados en un protocolo estándar del nivel de aplicación
son pasados hacia abajo al siguiente nivel de la pila de protocolos TCP/IP. En el nivel de transporte, las aplicaciones normalmente hacen uso de TCP
y UDP, y son habitualmente asociados a un número de puerto bien conocido (well-known port). Los puertos fueron asignados originalmente por la
IANA.
Protocolo TCP
Las conexiones TCP se componen de tres etapas: establecimiento de conexión, transferencia de datos y fin de la conexión. Para establecer la
conexión se usa el procedimiento llamado negociación en tres pasos (3-way handshake). Una negociación en cuatro pasos (4-way handshake) es
usada para la desconexión. Durante el establecimiento de la conexión, algunos parámetros como el número de secuencia son configurados para
asegurar la entrega ordenada de los datos y la robustez de la comunicación.
Establecimiento de la conexion
Aunque es posible que un par de entidades finales comiencen una conexión entre ellas simultáneamente, normalmente una de ellas abre un socket
en un determinado puerto tcp y se queda a la escucha de nuevas conexiones. Es común referirse a esto como apertura pasiva, y determina el lado
servidor de una conexión. El lado cliente de una conexión realiza una apertura activa de un puerto enviando un paquete SYN inicial al servidor como
parte de la negociación en tres pasos. En el lado del servidor se comprueba si el puerto está abierto, es decir, si existe algún proceso escuchando
en ese puerto. En caso de no estarlo, se envía al cliente un paquete de respuesta con el bit RST activado, lo que significa el rechazo del intento de
conexión. En caso de que sí se encuentre abierto el puerto, el lado servidor respondería a la petición SYN válida con un paquete SYN/ACK.
Finalmente, el cliente debería responderle al servidor con un ACK, completando así la negociación en tres pasos (SYN, SYN/ACK y ACK) y la fase
de establecimiento de conexión. Es interesante notar que existe un número de secuencia generado por cada lado, ayudando de este modo a que no
se puedan establecer conexiones falseadas (spoofing).
Transferencia de datos
Durante la etapa de transferencia de datos, una serie de mecanismos claves determinan la fiabilidad y robustez del protocolo. Entre ellos están
incluidos el uso del número de secuencia para ordenar los segmentos TCP recibidos y detectar paquetes duplicados, checksums para detectar
errores, y asentimientos y temporizadores para detectar pérdidas y retrasos. Durante el establecimiento de conexión TCP, los números iniciales de
secuencia son intercambiados entre las dos entidades TCP. Estos números de secuencia son usados para identificar los datos dentro del flujo de
bytes, y poder identificar (y contar) los bytes de los datos de la aplicación. Siempre hay un par de números de secuencia incluidos en todo
segmento TCP, referidos al número de secuencia y al número de asentimiento. Un emisor TCP se refiere a su propio número de secuencia cuando
habla de número de secuencia, mientras que con el número de asentimiento se refiere al número de secuencia del receptor. Para mantener la
fiabilidad, un receptor asiente los segmentos TCP indicando que ha recibido una parte del flujo continuo de bytes. Una mejora de TCP, llamada
asentimiento selectivo (SACK, Selective Acknowledgement) permite a un receptor TCP asentir los datos que se han recibido de tal forma que el
remitente solo retransmita los segmentos de datos que faltan. A través del uso de números de secuencia y asentimiento, TCP puede pasar los
segmentos recibidos en el orden correcto dentro del flujo de bytes a la aplicación receptora. Los números de secuencia son de 32 bits (sin signo),
que vuelve a cero tras el siguiente byte después del 232-1. Una de las claves para mantener la robustez y la seguridad de las conexiones TCP es la
selección del número inicial de secuencia (ISN, Initial Sequence Number). Un checksum de 16 bits, consistente en el complemento a uno de la suma
en complemento a uno del contenido de la cabecera y datos del segmento TCP, es calculado por el emisor, e incluido en la transmisión del
segmento. Se usa la suma en complemento a uno porque el acarreo final de ese método puede ser calculado en cualquier múltiplo de su tamaño
(16-bit, 32-bit, 64-bit...) y el resultado, una vez plegado, será el mismo. El receptor TCP recalcula el checksum sobre las cabeceras y datos
recibidos. El complemento es usado para que el receptor no tenga que poner a cero el campo del checksum de la cabecera antes de hacer los
46 de 63 24/07/2010 11:53 p.m.

cálculos, salvando en algún lugar el valor del checksum recibido; en vez de eso, el receptor simplemente calcula la suma en complemento a uno con
el checksum incluido, y el resultado debe ser igual a 0. Si es así, se asume que el segmento ha llegado intacto y sin errores.
Hay que fijarse en que el checksum de TCP también cubre los 96 bit de la cabecera que contiene la dirección origen, la dirección destino, el
protocolo y el tamaño TCP. Esto proporciona protección contra paquetes mal dirigidos por errores en las direcciones. El checksum de TCP es una
comprobación bastante débil. En niveles de enlace con una alta probabilidad de error de bit quizá requiera una capacidad adicional de
corrección/detección de errores de enlace. Si TCP fuese rediseñado hoy, muy probablemente tendría un código de redundancia cíclica (CRC) para
control de errores en vez del actual checksum. La debilidad del checksum está parcialmente compensada por el extendido uso de un CRC en el nivel
de enlace, bajo TCP e IP, como el usado en el PPP o en Ethernet. Sin embargo, esto no significa que el checksum de 16 bits es redundante:
sorprendentemente, inspecciones sobre el tráfico de Internet han mostrado que son comunes los errores de software y hardwarecita requerida que
introducen errores en los paquetes protegidos con un CRC, y que el checksum de 16 bits de TCP detecta la mayoría de estos errores simples. Los
asentimientos (ACKs o Acknowledgments) de los datos enviados o la falta de ellos, son usados por los emisores para interpretar las condiciones de la
red entre el emisor y receptor TCP. Unido a los temporizadores, los emisores y receptores TCP pueden alterar el comportamiento del movimiento de
datos. TCP usa una serie de mecanismos para conseguir un alto rendimiento y evitar la congestión de la red (la idea es enviar tan rápido como el
receptor pueda recibir). Estos mecanismos incluyen el uso de ventana deslizante, que controla que el transmisor mande información dentro de los
límites del buffer del receptor, y algoritmos de control de flujo, tales como el algoritmo de Evitación de la Congestión (congestion avoidance), el de
comienzo lento (Slow-start), el de retransmisión rápida, el de recuperación rápida (Fast Recovery), y otros.
Tamaño de ventana TCP

El tamaño de la ventana de recepción TCP es la cantidad de datos recibidos (en bytes) que pueden ser metidos en el buffer de recepción durante la
conexión. La entidad emisora puede enviar una cantidad determinada de datos pero antes debe esperar un asentimiento con la actualización del
tamaño de ventana por parte del receptor. Un ejemplo sería el siguiente: un receptor comienza con un tamaño de ventana x y recibe y bytes,
entonces su tamaño de ventana será (x - y) y el transmisor sólo podrá mandar paquetes con un tamaño máximo de datos de (x - y) bytes. Los
siguientes paquetes recibidos seguirán restando tamaño a la ventana de recepción. Esta situación seguirá así hasta que la aplicación receptora
recoja los datos del buffer de recepción.
Escalado de ventana
Para una mayor eficiencia en redes de gran ancho de banda, debe ser usado un tamaño de ventana mayor. El campo TCP de tamaño de ventana
controla el movimiento de datos y está limitado a 16 bits, es decir, a un tamaño de ventana de 65.535 bytes. Como el campo de ventana no puede
expandirse se usa un factor de escalado. La escala de ventana TCP (TCP window scale) es una opción usada para incrementar el máximo tamaño
de ventana desde 65.535 bytes, a 1 Gigabyte. La opción de escala de ventana TCP es usada solo durante la negociación en tres pasos que
constituye el comienzo de la conexión. El valor de la escala representa el número de bits desplazados a la izquierda de los 16 bits que forman el
campo del tamaño de ventana. El valor de la escala puede ir desde 0 (sin desplazamiento) hasta 14. Hay que recordar que un número binario
desplazado un bit a la izquierda es como multiplicarlo en base decimal por 2.
Fin de la conexion
La fase de finalización de la conexión usa una negociación en cuatro pasos (four-way handshake), terminando la conexión desde cada lado
independientemente. Cuando uno de los dos extremos de la conexión desea parar su "mitad" de conexión transmite un paquete FIN, que el otro
interlocutor asentirá con un ACK. Por tanto, una desconexión típica requiere un par de segmentos FIN y ACK desde cada lado de la conexión.
Una conexión puede estar "medio abierta" en el caso de que uno de los lados la finalice pero el otro no. El lado que ha dado por finalizada la
conexión no puede enviar más datos pero la otra parte si podrá.
Puertos TCP
TCP usa el concepto de número de puerto para identificar a las aplicaciones emisoras y receptoras. Cada lado de la conexión TCP tiene asociado
un número de puerto (de 16 bits sin signo, con lo que existen 65536 puertos posibles) asignado por la aplicación emisora o receptora. Los puertos
son clasificados en tres categorías: bien conocidos, registrados y dinámicos/privados. Los puertos bien conocidos son asignados por la Internet
Assigned Numbers Authority (IANA), van del 0 al 1023 y son usados normalmente por el sistema o por procesos con privilegios. Las aplicaciones
que usan este tipo de puertos son ejecutadas como servidores y se quedan a la escucha de conexiones. Algunos ejemplos son: FTP (21), SSH (22),
Telnet (23), SMTP (25) y HTTP (80). Los puertos registrados son normalmente empleados por las aplicaciones de usuario de forma temporal cuando
conectan con los servidores, pero también pueden representar servicios que hayan sido registrados por un tercero (rango de puertos registrados:
1024 al 49151). Los puertos dinámicos/privados también pueden ser usados por las aplicaciones de usuario, pero este caso es menos común. Los
puertos dinámicos/privados no tienen significado fuera de la conexión TCP en la que fueron usados (rango de puertos dinámicos/privados: 49152 al
65535, recordemos que el rango total de 2 elevado a la potencia 16, cubre 65536 números, del 0 al 65535).
Protocolo UDP
User Datagram Protocol (UDP) es un protocolo del nivel de transporte basado en el intercambio de datagramas. Permite el envío de datagramas a
través de la red sin que se haya establecido previamente una conexión, ya que el propio datagrama incorpora suficiente información de
direccionamiento en su cabecera. Tampoco tiene confirmación ni control de flujo, por lo que los paquetes pueden adelantarse unos a otros; y
tampoco se sabe si ha llegado correctamente, ya que no hay confirmación de entrega o recepción. Su uso principal es para protocolos como
DHCP, BOOTP, DNS y demás protocolos en los que el intercambio de paquetes de la conexión/desconexión son mayores, o no son rentables con
respecto a la información transmitida, así como para la transmisión de audio y vídeo en tiempo real, donde no es posible realizar retransmisiones por
los estrictos requisitos de retardo que se tiene en estos casos.
Puertos TCP
UDP utiliza puertos para permitir la comunicación entre aplicaciones. El campo de puerto tiene una longitud de 16 bits, por lo que el rango de valores
47 de 63 24/07/2010 11:53 p.m.

válidos va de 0 a 65.535. El puerto 0 está reservado, pero es un valor permitido como puerto origen si el proceso emisor no espera recibir mensajes
como respuesta. Los puertos 1 a 1023 se llaman puertos "bien conocidos" y en sistemas operativos tipo Unix enlazar con uno de estos puertos
requiere acceso como superusuario. Los puertos 1024 a 49.151 son puertos registrados. Los puertos 49.152 a 65.535 son puertos efímeros y son
utilizados como puertos temporales, sobre todo por los clientes al comunicarse con los servidores.
Diferencias entre TCP y UDP
UDP: proporciona un nivel de transporte no fiable de datagramas, ya que apenas añade la información necesaria para la comunicación extremo a
extremo al paquete que envía al nivel inferior. Lo utilizan aplicaciones como NFS (Network File System) y RCP (comando para copiar ficheros entre
ordenadores remotos), pero sobre todo se emplea en tareas de control y en la transmisión de audio y vídeo a través de una red. No introduce
retardos para establecer una conexión, no mantiene estado de conexión alguno y no realiza seguimiento de estos parámetros. Así, un servidor
dedicado a una aplicación particular puede soportar más clientes activos cuando la aplicación corre sobre UDP en lugar de sobre TCP.
TCP: es el protocolo que proporciona un transporte fiable de flujo de bits entre aplicaciones. Está pensado para poder enviar grandes cantidades de
información de forma fiable, liberando al programador de la dificultad de gestionar la fiabilidad de la conexión (retransmisiones, pérdida de paquetes,
orden en el que llegan los paquetes, duplicados de paquetes...) que gestiona el propio protocolo. Pero la complejidad de la gestión de la fiabilidad
tiene un coste en eficiencia, ya que para llevar a cabo las gestiones anteriores se tiene que añadir bastante información a los paquetes que enviar.
Debido a que los paquetes para enviar tienen un tamaño máximo, cuanta más información añada el protocolo para su gestión, menos información
que proviene de la aplicación podrá contener ese paquete (el segmento TCP tiene una sobrecarga de 20 bytes en cada segmento, mientras que
UDP solo añade 8 bytes). Por eso, cuando es más importante la velocidad que la fiabilidad, se utiliza UDP. En cambio, TCP asegura la recepción en
destino de la información para transmitir. 109.5 Protocolo ICMP El Protocolo de Mensajes de Control de Internet o ICMP (por sus siglas de Internet
Control Message Protocol) es el sub protocolo de control y notificación de errores del Protocolo de Internet (IP). Como tal, se usa para enviar
mensajes de error, indicando por ejemplo que un servicio determinado no está disponible o que un router o host no puede ser localizado. ICMP
difiere del propósito de TCP y UDP ya que generalmente no se utiliza directamente por las aplicaciones de usuario en la red. La única excepción es
la herramienta ping y traceroute, que envían mensajes de petición Echo ICMP (y recibe mensajes de respuesta Echo) para determinar si un host
está disponible, el tiempo que le toma a los paquetes en ir y regresar a ese host y cantidad de hosts por los que pasa.
Tabla de Puertos TCP y UDP
Puerto/Protocolo Descripcion
1/tcp Multiplexor TCP
7/tcp Protocolo Echo (Eco) Reponde con eco a llamadas remotas
7/udp Protocolo Echo (Eco) Reponde con eco a llamadas remotas
9/tcp Protocolo Discard Elimina cualquier dato que recibe
9/udp Protocolo Discard Elimina cualquier dato que recibe
13/tcp Protocolo Daytime Fecha y hora actuales
17/tcp Quote of the Day (Cita del Día)
19/tcp Protocolo Chargen Generador de caractéres
19/udp Protocolo Chargen Generador de caractéres
0 FTP File Transfer Protocol (Protocolo de Transferencia de Ficheros) - datos
21/tcp FTP File Transfer Protocol (Protocolo de Transferencia de Ficheros) - control
22/tcp SSH, scp, SFTP
23/tcp Telnet comunicaciones de texto inseguras
25/tcp SMTP Simple Mail Transfer Protocol (Protocolo Simple de Transferencia de Correo)
37/tcp time
43/tcp nicname
53/tcp DNS Domain Name System (Sistema de Nombres de Dominio)
53/udp DNS Domain Name System (Sistema de Nombres de Dominio)
67/udp BOOTP BootStrap Protocol (Server), también usado por DHCP
68/udp BOOTP BootStrap Protocol (Client), también usado por DHCP
69/udp TFTP Trivial File Transfer Protocol (Protocolo Trivial de Transferencia de Ficheros)
0 Gopher
79/tcp Finger
0 HTTP HyperText Transfer Protocol (Protocolo de Transferencia de HiperTexto) (WWW)
88/tcp Kerberos Agente de autenticación
0 POP3 Post Office Protocol (E-mail)
111/tcp sunrpc
113/tcp ident (auth) antiguo sistema de identificación
119/tcp NNTP usado en los grupos de noticias de usenet
123/udp NTP Protocolo de sincronización de tiempo
123/tcp NTP Protocolo de sincronización de tiempo
135/tcp epmap
137/tcp NetBIOS Servicio de nombres
137/udp NetBIOS Servicio de nombres
48 de 63 24/07/2010 11:53 p.m.

138/tcp NetBIOS Servicio de envío de datagramas

138/udp NetBIOS Servicio de envío de datagramas
139/tcp NetBIOS Servicio de sesiones
139/udp NetBIOS Servicio de sesiones
143/tcp IMAP4 Internet Message Access Protocol (E-mail)
161/tcp SNMP Simple Network Management Protocol
161/udp SNMP Simple Network Management Protocol
162/tcp SNMP-trap
162/udp SNMP-trap
177/tcp XDMCP Protocolo de gestión de displays en X11
177/udp XDMCP Protocolo de gestión de displays en X11
389/tcp LDAP Protocolo de acceso ligero a Bases de Datos
389/udp LDAP Protocolo de acceso ligero a Bases de Datos
443/tcp HTTPS/SSL usado para la transferencia segura de páginas web
445/tcp Microsoft-DS (Active Directory, compartición en Windows, gusano Sasser, Agobot)
445/udp Microsoft-DS compartición de ficheros
0 IPSec ISAKMP, Autoridad de Seguridad Local
512/tcp exec
513/tcp login
514/udp syslog usado para logs del sistema
0 RIP
591/tcp FileMaker 6.0 (alternativa para HTTP, ver puerto 80)
631/tcp CUPS sistema de impresión de Unix
666/tcp identificación de Doom para jugar sobre TCP
993/tcp IMAP4 sobre SSL (E-mail)
995/tcp POP3 sobre SSL (E-mail)
0 SOCKS Proxy
1337/tcp suele usarse en máquinas comprometidas o infectadas
1352/tcp IBM Lotus Notes/Domino RCP
1433/tcp Microsoft-SQL-Server
1434/tcp Microsoft-SQL-Monitor
1434/udp Microsoft-SQL-Monitor
1494/tcp Citrix MetaFrame Cliente ICA
1512/tcp WINS
1521/tcp Oracle listener por defecto
0Enrutamiento y Acceso Remoto para VPN
con L2TP.
1723/tcp Enrutamiento y Acceso Remoto para VPN con PPTP.
1761/tcp Novell Zenworks Remote Control utility
1863/tcp MSN Messenger
0 NFS Archivos del sistema de red
0 CPanel puerto por defecto
0 Web Host Manager puerto por defecto
2427/upd Cisco MGCP
0 NetPanzer
0 NetPanzer
3128/tcp HTTP usado por web caches y por defecto en Squid cache
3128/tcp NDL-AAS
0 MySQL sistema de gestión de bases de datos
3389/tcp RDP (Remote Desktop Protocol)
3396/tcp Novell agente de impresión NDPS
0 Subversion (sistema de control de versiones)
4662/tcp eMule (aplicación de compartición de ficheros)
4672/udp eMule (aplicación de compartición de ficheros)
4899/tcp RAdmin (Remote Administrator), herramienta de administración remota (normalmente troyanos)
0 Universal plug-and-play
0 Session Initiation Protocol (SIP)
0 AOL y AOL Instant Messenger
5222/tcp XMPP/Jabber conexión de cliente
5223/tcp XMPP/Jabber puerto por defecto para conexiones de cliente SSL
5269/tcp XMPP/Jabber conexión de servidor
49 de 63 24/07/2010 11:53 p.m.

5432/tcp PostgreSQL sistema de gestión de bases de datos

5517/tcp Setiqueue proyecto SETI@Home
5631/tcp PC-Anywhere protocolo de escritorio remoto
5632/udp PC-Anywhere protocolo de escritorio remoto
0 VNC protocolo de escritorio remoto (usado sobre HTTP)
0 VNC protocolo de escritorio remoto (conexión normal)
6000/tcp X11 usado para X-windows
6112/udp Blizzard
6129/tcp Dameware Software conexión remota
6346/tcp Gnutella compartición de ficheros (Limewire, etc.)
6347/udp Gnutella
6348/udp Gnutella
6349/udp Gnutella
0 Gnutella
6355/udp Gnutella
6667/tcp IRC IRCU Internet Relay Chat
6881/tcp BitTorrent puerto por defecto
6969/tcp BitTorrent puerto de tracker
0 Servidor de Fuentes X11
7100/udp Servidor de Fuentes X11
iRDMI por lo general, usado erróneamente en sustitución de 8080. También utilizado en el servidor de
0
streaming ShoutCast.
0 HTTP HTTP-ALT ver puerto 80. Tomcat lo usa como puerto por defecto.
8118/tcp privoxy
0 Pichat peer-to-peer chat server
9898/tcp Gusano Dabber (troyano/virus)
0 Webmin (Administración remota web)
19226/tcp Panda SecurityPuerto de comunicaciones de Panda Agent.
12345/tcp NetBus en:NetBus (troyano/virus)
31337/tcp Back Orifice herramienta de administración remota (por lo general troyanos)
Direcciones IP
Una dirección IP es un número que identifica de manera lógica y jerárquica a una interfaz de un dispositivo (habitualmente una computadora) dentro
de una red que utilice el protocolo IP (Internet Protocol), que corresponde al nivel de red del protocolo TCP/IP. Dicho número no se ha de confundir
con la dirección MAC que es un número hexadecimal fijo que es asignado a la tarjeta o dispositivo de red por el fabricante, mientras que la dirección
IP se puede cambiar. Es habitual que un usuario que se conecta desde su hogar a Internet utilice una dirección IP. Esta dirección puede cambiar
cada vez que se conecta; y a esta forma de asignación de dirección IP se denomina una dirección IP dinámica (normalmente se abrevia como IP
dinámica). Los sitios de Internet que por su naturaleza necesitan estar permanentemente conectados, generalmente tienen una dirección IP fija (se
aplica la misma reducción por IP fija o IP estática), es decir, no cambia con el tiempo. Los servidores de correo, DNS, FTP públicos, y servidores de
páginas web necesariamente deben contar con una dirección IP fija o estática, ya que de esta forma se permite su localización en la red. A través
de Internet, los ordenadores se conectan entre sí mediante sus respectivas direcciones IP. Sin embargo, a los seres humanos nos es más cómodo
utilizar otra notación más fácil de recordar y utilizar, como los nombres de dominio; la traducción entre unos y otros se resuelve mediante los
servidores de nombres de dominio DNS. Existe un protocolo para asignar direcciones IP dinámicas llamado DHCP (Dynamic Host Configuration
Protocol).
Direcciones IPv4
En su versión 6.55, una dirección IP se implementa con un número de 32 bit que suele ser mostrado en cuatro grupos de números decimales de 8
bits (IPv4). Cada uno de esos números se mueve en un rango de 0 a 255 (expresado en decimal), o de 0 a FF (en hexadecimal) o de 0 a 11111111
(en binario). Las direcciones IP se pueden expresar como números de notación decimal: se dividen los 32 bits de la dirección en cuatro octetos. El
valor decimal de cada octeto puede ser entre 0 y 255 (el número binario de 8 bits más alto es 11111111 y esos bits, de derecha a izquierda, tienen
valores decimales de 1, 2, 4, 8, 16, 32, 64 y 128, lo que suma 255 en total).
En la expresión de direcciones IPv4 en decimal se separa cada octeto por un carácter ".". Cada uno de estos octetos puede estar comprendido
entre 0 y 255, salvo algunas excepciones. Los ceros iniciales, si los hubiera, se pueden obviar.
Ejemplo de representación de dirección IPv4: 164.12.123.65
Hay tres clases de direcciones IP que una organización puede recibir de parte de la Internet Corporation for Assigned Names and Numbers
(ICANN): clase A, clase B y clase C. En la actualidad, ICANN reserva las direcciones de clase A para los gobiernos de todo el mundo (aunque en el
50 de 63 24/07/2010 11:53 p.m.

pasado se le hayan otorgado a empresas de gran envergadura como, por ejemplo, Hewlett Packard) y las direcciones de clase B para las medianas
empresas. Se otorgan direcciones de clase C para todos los demás solicitantes. Cada clase de red permite una cantidad fija de equipos (hosts).
En una red de clase A, se asigna el primer octeto para identificar la red, reservando los tres últimos octetos (24 bits) para que sean asignados
a los hosts, de modo que la cantidad máxima de hosts es 224 - 2 (las direcciones reservadas de broadcast últimos octetos a 255 y de red
últimos octetos a 0), es decir, 16 777 214 hosts.
En una red de clase B, se asignan los dos primeros octetos para identificar la red, reservando los dos octetos finales (16 bits) para que sean
asignados a los hosts, de modo que la cantidad máxima de hosts es 216 - 2, o 65 534 hosts.
En una red de clase C, se asignan los tres primeros octetos para identificar la red, reservando el octeto final (8 bits) para que sea asignado a
los hosts, de modo que la cantidad máxima de hosts es 28 - 2, ó 254 hosts.
La dirección 0.0.0.0 es utilizada por las máquinas cuando están arrancando o no se les ha asignado dirección.
La dirección que tiene su parte de host a cero sirve para definir la red en la que se ubica. Se denomina dirección de red.
La dirección que tiene su parte de host a unos sirve para comunicar con todos los hosts de la red en la que se ubica. Se denomina dirección
de broadcast.
Las direcciones 127.x.x.x se reservan para pruebas de retroalimentación. Se denomina dirección de bucle local o loopback.
Hay ciertas direcciones en cada clase de dirección IP que no están asignadas y que se denominan direcciones privadas. Las direcciones privadas
pueden ser utilizadas por los hosts que usan traducción de dirección de red (NAT) para conectarse a una red pública o por los hosts que no se
conectan a Internet. En una misma red no puede existir dos direcciones iguales, pero sí se pueden repetir en dos redes privadas que no tengan
conexión entre sí o que se sea a través de NAT. Las direcciones privadas son:
Clase A: 10.0.0.0 a 10.255.255.255 (8 bits red, 24 bits hosts)

Uso VIP EJ:La red militar norte-americana
Clase B: 172.16.0.0 a 172.31.255.255 (12 bits red, 20 bits hosts)
Uso universidades y grandes compañias
Clase C: 192.168.0.0 a 192.168.255.255 (16 bits red, 16 bits hosts)
Uso de compañias medias y pequeñas ademas pequeños proveedores de internet(ISP)
A partir de 1993, ante la previsible futura escasez de direcciones IPv4 debido al crecimiento exponencial de hosts en Internet, se empezó a
introducir el sistema CIDR, que pretende en líneas generales establecer una distribución de direcciones más fina y granulada, calculando las
direcciones necesarias y "desperdiciando" las mínimas posibles, para rodear el problema que las distribución por clases había estado gestando.
Este sistema es, de hecho, el empleado actualmente para la delegación de direcciones. Muchas aplicaciones requieren conectividad dentro de una
sola red, y no necesitan conectividad externa. En las redes de gran tamaño a menudo se usa TCP/IP. Por ejemplo, los bancos pueden utilizar
TCP/IP para conectar los cajeros automáticos que no se conectan a la red pública, de manera que las direcciones privadas son ideales para ellas.
Las direcciones privadas también se pueden utilizar en una red en la que no hay suficientes direcciones públicas disponibles. Las direcciones
privadas se pueden utilizar junto con un servidor de traducción de direcciones de red (NAT) para suministrar conectividad a todos los hosts de una
red que tiene relativamente pocas direcciones públicas disponibles. Según lo acordado, cualquier tráfico que posea una dirección destino dentro de
uno de los intervalos de direcciones privadas no se enrutará a través de Internet.
Mascara de una direccion IP

La máscara permite distinguir los bits que identifican la red y los que identifican el host de una dirección IP. Dada la dirección de clase A 10.2.1.2
sabemos que pertenece a la red 10.0.0.0 y el host al que se refiere es el 2.1.2 dentro de la misma. La máscara se forma poniendo a 1 los bits que
identifican la red y a 0 los bits que identifican el host. De esta forma una dirección de clase A tendrá como máscara 255.0.0.0, una de clase B
255.255.0.0 y una de clase C 255.255.255.0. Los dispositivos de red realizan un AND entre la dirección IP y la máscara para obtener la dirección
de red a la que pertenece el host identificado por la dirección IP dada. Por ejemplo un router necesita saber cuál es la red a la que pertenece la
dirección IP del datagrama destino para poder consultar la tabla de encaminamiento y poder enviar el datagrama por la interfaz de salida.
Creacion de Subredes
El espacio de direcciones de una red puede ser subdividido a su vez creando subredes autónomas separadas. Un ejemplo de uso es cuando
necesitamos agrupar todos los empleados pertenecientes a un departamento de una empresa. En este caso crearíamos una subred que englobara
las direcciones IP de éstos. Para conseguirlo hay que reservar bits del campo host para identificar la subred estableciendo a uno los bits de
red-subred en la máscara. Por ejemplo la dirección 172.16.1.1 con máscara 255.255.0.0 nos indica que los dos primeros bytes identifican la red
(por ser una dirección de clase B), el tercer byte identifica la subred (a 1 los bits en la máscara) y el tercero identifica el host (a 0 los bits
correpondientes dentro de la máscara). Hay dos direcciones de cada subred quedan reservadas: aquella que identifica la subred (campo host a 0) y
la dirección para realizar broadcast en la subred (campo host a 1).
IP dinamica
Una dirección IP dinámica es una IP asignada mediante un servidor DHCP (Dynamic Host Configuration Protocol) al usuario. La IP que se obtiene
tiene una duración máxima determinada. El servidor DHCP provee parámetros de configuración específicos para cada cliente que desee participar
en la red IP. Entre estos parámetros se encuentra la dirección IP del cliente. DHCP apareció como protocolo estándar en octubre de 1993. El
estándar RFC 2131 especifica la última definición de DHCP (marzo de 1997). DHCP sustituye al protocolo BOOTP, que es más antiguo. Debido a la
compatibilidad retroactiva de DHCP, muy pocas redes continúan usando BOOTP puro. Las IP dinámicas son las que actualmente ofrecen la mayoría
de operadores. Éstas suelen cambiar cada vez que el usuario reconecta por cualquier causa.
Ventajas
51 de 63 24/07/2010 11:53 p.m.

Reduce los costos de operación a los proveedores de servicios internet (ISP).

Reduce la cantidad de IP´s asignadas (de forma fija) inactivas.
Desventajas
Obliga a depender de servicios que redirigen un host a una IP.
Asignacion de direcciones IP
Dependiendo de la implementación concreta, el servidor DHCP tiene tres métodos para asignar las direcciones IP:
manualmente, cuando el servidor tiene a su disposición una tabla que empareja direcciones MAC con direcciones IP, creada manualmente
por el administrador de la red. Sólo clientes con una dirección MAC válida recibirán una dirección IP del servidor.
automáticamente, donde el servidor DHCP asigna permanentemente una dirección IP libre, tomada de un rango prefijado por el administrador,
a cualquier cliente que solicite una.
dinámicamente, el único método que permite la reutilización de direcciones IP. El administrador de la red asigna un rango de direcciones IP
para el DHCP y cada ordenador cliente de la LAN tiene su software de comunicación TCP/IP configurado para solicitar una dirección IP del
servidor DHCP cuando su tarjeta de interfaz de red se inicie. El proceso es transparente para el usuario y tiene un periodo de validez limitado.
IP fija
Una dirección IP fija es una IP asignada por el usuario de manera manual. Mucha gente confunde IP Fija con IP Publica e IP Dinámica con IP
Privada. Una IP puede ser Privada ya sea dinámica o fija como puede ser IP Publica Dinámica o Fija. Una IP Publica se utiliza generalmente para
montar servidores en internet y necesariamente se desea que la IP no cambie por eso siempre la IP Publica se la onfigura de manera Fija y no
Dinámica, aunque si se podría. En el caso de la IP Privada generalmente es dinámica asignada por un servidor DHCP, pero en algunos casos se
configura IP Privada Fija para poder controlar el acceso a internet o a la red local, otorgando ciertos privilegios dependiendo del número de IP que
tenemos, si esta cambiara (fuera dinámica) seria más complicado controlar estos privilegios (pero no imposible) Las IP Publicas fijas actualmente en
el mercado de acceso a Internet tienen un coste adicional mensual. Estas IP son asignadas por el usuario después de haber recibido la información
del proveedor o bien asignadas por el proveedor en el momento de la primera conexión. Esto permite al usuario montar servidores web, correo, FTP,
etc. y dirigir un nombre de dominio a esta IP sin tener que mantener actualizado el servidor DNS cada vez que cambie la IP como ocurre con las IP
Publica dinámica.
Ventajas
Permite tener servicios dirigidos directamente a la IP.
Desventajas
Son más vulnerables al ataque, puesto que el usuario no puede conseguir otra IP.
Es más caro para los ISP puesto que esa IP puede no estar usándose las 24 horas del día.
Direcciones IPv6
La función de la dirección IPv6 es exactamente la misma a su predecesor IPv4, pero dentro del protocolo IPv6. Está compuesta por 8 segmentos de
2 bytes cada uno, que suman un total de 128 bits, el equivalente a unos 3.4x1038 hosts direccionables. La ventaja con respecto a la dirección IPv4
es obvia en cuanto a su capacidad de direccionamiento. Su representación suele ser hexadecimal y para la separación de cada par de octetos se
emplea el símbolo ":". Un bloque abarca desde 0000 hasta FFFF. Algunas reglas acerca de la representación de direcciones IPv6 son:
Los ceros iniciales, como en IPv4, se pueden obviar.
Ejemplo: 2001:0123:0004:00ab:0cde:3403:0001:0063 -> 2001:123:4:ab:cde:3403:1:63
Los bloques contiguos de ceros se pueden comprimir empleando "::". Esta operación sólo se puede hacer una vez.
Ejemplo: 2001:0:0:0:0:0:0:4 -> 2001::4. Ejemplo no válido: 2001:0:0:0:2:0:0:1 -> 2001::2::1 (debería ser 2001::2:0:0:1 ó 2001:0:0:0:2::1).
Fichero /etc/services
El fichero /etc/services contiene una lista de todos los puertos que GNU/Linux utiliza. Para listar el contenido de este fichero teclee lo siguiente:
[BASH]# cat /etc/services
FTP
FTP (sigla en inglés de File Transfer Protocol - Protocolo de Transferencia de Archivos) en informática, es un protocolo de red para la transferencia
de archivos entre sistemas conectados a una red TCP, basado en la arquitectura cliente-servidor. Desde un equipo cliente se puede conectar a un
servidor para descargar archivos desde él o para enviarle archivos, independientemente del sistema operativo utilizado en cada equipo. El Servicio
FTP es ofrecido por la capa de Aplicación del modelo de capas de red TCP/IP al usuario, utilizando normalmente el puerto de red 20 y el 21. Un
problema básico de FTP es que está pensado para ofrecer la máxima velocidad en la conexión, pero no la máxima seguridad, ya que todo el
intercambio de información, desde el login y password del usuario en el servidor hasta la transferencia de cualquier archivo, se realiza en texto plano
sin ningún tipo de cifrado, con lo que un posible atacante puede capturar este tráfico, acceder al servidor, o apropiarse de los archivos transferidos.
Para solucionar este problema son de gran utilidad aplicaciones como scp y sftp, incluidas en el paquete SSH, que permiten transferir archivos pero
52 de 63 24/07/2010 11:53 p.m.

cifrando todo el tráfico.
Telnet
Telnet (TELecommunication NETwork) es el nombre de un protocolo de red (y del programa informático que implementa el cliente), que sirve para
acceder mediante una red a otra máquina, para manejarla remotamente como si estuviéramos sentados delante de ella. Para que la conexión
funcione, como en todos los servicios de Internet, la máquina a la que se acceda debe tener un programa especial que reciba y gestione las
conexiones. El puerto que se utiliza generalmente es el 23.
Ping
La utilidad ping comprueba el estado de la conexión con uno o varios equipos remotos por medio de los paquetes de solicitud de eco y de respuesta
de eco (ambos definidos en el protocolo de red ICMP) para determinar si un sistema IP específico es accesible en una red. Es útil para diagnosticar
los errores en redes o enrutadores IP. Muchas veces se utiliza para medir la latencia o tiempo que tardan en comunicarse dos puntos remotos, y por
ello, se utiliza entre los aficionados a los juegos en red el término PING para referirse al lag o latencia de su conexión. Existe otro tipo, Ping ATM,
que se utiliza en las redes ATM (como puede ser una simple ADSL instalada en casa) y, en este caso, las tramas que se transmiten son ATM (nivel 2
del modelo OSI). Este tipo de paquetes se envían para probar si los enlaces ATM están correctamente definidos.
Dig
Dig es una herramienta (linea de comandos) disponible en prácticamente cualquier distribución linux que te permite hacer consultas a un servidor
dns. Dig precisa conocer la dirección IP de un servidor DNS al que consultar por defecto, dirección IP que toma del archivo resolv.conf, y en
sistemas GNU/Linux en /etc/resolv.conf
Traceroute
Traceroute es una herramienta de diagnóstico de redes que permite seguir la pista de los paquetes que van desde un host (punto de red) a otro. Se
obtiene además una estadística del RTT o latencia de red de esos paquetes, lo que viene a ser una estimación de la distancia a la que están los
extremos de la comunicación. Esta herramienta se llama traceroute en UNIX y GNU/linux, mientras que en Windows se llama tracert. Ejemplo:
[BASH]# traceroute www.google.com

traceroute to www.l.google.com (64.233.169.99), 64 hops max, 40 byte packets
1 * * *
2 172.16.183.1 (172.16.183.1) 23 ms 23 ms 22 ms
3 10.127.66.229 (10.127.66.229) [MPLS: Label 1479 Exp 0] 38 ms 51 ms 38 ms
4 cnt-00-tge1-0-0.gw.cantv.net (200.44.43.85) 38 ms 38 ms 37 ms
5 cri-00-pos1-0-0.border.cantv.net (200.44.43.50) 51 ms 43 ms 43 ms
6 sl-st21-mia-14-1-0.sprintlink.net (144.223.245.233) 94 ms 93 ms 93 ms
7 sl-bb20-mia-5-0-0.sprintlink.net (144.232.9.198) 95 ms 93 ms 93 ms
8 sl-crs1-mia-0-4-0-0.sprintlink.net (144.232.2.248) 94 ms 95 ms 95 ms
9 sl-crs1-atl-0-0-0-1.sprintlink.net (144.232.20.48) 104 ms 104 ms 103 ms
10 sl-st20-atl-1-0-0.sprintlink.net (144.232.18.133) 104 ms 103 ms *
11 144.223.47.234 (144.223.47.234) 103 ms 103 ms 103 ms
12 64.233.174.86 (64.233.174.86) 98 ms 97 ms 64.233.174.84 (64.233.174.84) 103 ms
13 216.239.48.68 (216.239.48.68) 105 ms 104 ms 106 ms
14 72.14.236.200 (72.14.236.200) 106 ms * 105 ms
15 72.14.232.21 (72.14.232.21) 110 ms 109 ms 107 ms
16 * yo-in-f99.google.com (64.233.169.99) 100 ms 99 ms
Funcionamiento
El número de la primera columna es el número de salto, los tres tiempos siguientes son el tiempo de respuesta para los paquetes enviados (un
asterisco indica que no se obtuvo respuesta), posteriormente viene el nombre y la dirección IP del nodo por el que pasa. Estas herramientas
(traceroute y tracert) son órdenes ejecutables en una consola en modo texto. Tracert utiliza el campo Time To Live (TTL) de la cabecera IP. Este
campo sirve para que un paquete no permanezca en la red de forma indefinida (por ejemplo, debido a la existencia en la red de un bucle cerrado en
la ruta). El campo TTL es un número entero que es decrementado por cada nodo por el que pasa el paquete. De esta forma, cuando el campo TTL
llega al valor 0 ya no se reenviará más, sino que el nodo que lo esté manejando en ese momento lo descartará. Lo que hace tracert es mandar
paquetes a la red de forma que el primer paquete lleve un valor TTL=1, el segundo un TTL=2, etc. De esta forma, el primer paquete será eliminado
por el primer nodo al que llegue (ya que éste nodo decrementará el valor TTL, llegando a cero). Cuando un nodo elimina un paquete, envía al emisor
un mensaje de control especial indicando una incidencia. Tracert usa esta respuesta para averiguar la dirección IP del nodo que desechó el
paquete, que será el primer nodo de la red. La segunda vez que se manda un paquete, el TTL vale 2, por lo que pasará el primer nodo y llegará al
segundo, donde será descartado, devolviendo de nuevo un mensaje de control. Esto se hace de forma sucesiva hasta que el paquete llega a su
destino.
Configuracion de los parametros de Red

Configuracion de interfaces de Red
53 de 63 24/07/2010 11:53 p.m.

La configuración de la interfaz es importante en un servidor o equipo de escritorio. Los principales archivos de configuración son
Este archivo de configuración contiene los nombres de equipos dentro de una red local y se utilizar para resolver su
/etc/hosts nombre cuando no se tiene un servidor de DNS en la red local, también este archivo define la dirección de loopback
que representa al propio equipo independientemente de la dirección IP que se le haya asignado.
/etc/resolv.conf Este archivo especifica las direcciones IP de los servidores DNS
/etc/sysconfig/network Este archivo de configuración es utilizado para definir las características de red deseadas
/etc/sysconfig/network
Estos archivos de configuración son utilizados para especificar la configuración de la tarjeta de red.
scripts/ifcfg-<interfaz>
Configuracion del archivo /etc/hosts
Este archivo de texto asocia las direcciones IP con el nombre del equipo (hostname). Este archivo debe tener la siguiente forma:
Direccion IP nombre.Del.Equipo alias
Las modificaciones realizadas en este archivo de configuración son reflejados inmediatamente Nota: Este archivo se encuentra la dirección de
loopback (127.0.0.1), esta dirección es utilizada por varias aplicaciones para su funcionamientos, se recomienda que no modifique esta linea.
Ejemplo:
127.0.0.1 localhost.localdomain localhost

192.168.1.10 mail.redfactor.net mail
192.168.1.13 www.red.factor.net www
207.249.0.40 www.linuxparatodos.net
Configuracion del archivo /etc/resolv.conf
Este archivo de configuración contiene la direcciones IP de los servidores DNS. Sus parámetros de configuración son:
Define las direcciones IP de los servidores de nombre en los cuales se deberán resolver las búsquedas. El archivos hosts solo permite
nameserver
hasta 3 servidores de nombre diferentes
domain Define el nombre de dominio local en el cual pertenecen los equipos en una red local.
Este parámetro define la lista de búsqueda nombres de equiposes útil cuando se busca un equipo dentro de la red local por un nombre
search
corto
sortlist Este parámetro indica la preferencia de los nameserver definidos
Configuracion del archivo /etc/sysconfig/network Los parámetros que utiliza este este archivo son:
Los valores que admites son:

NETWORKING yes Permite la configuración de los servicio de red.
no No permite la configuración de los servicio de red.
FORWARD_IPV4Habilita el reenvío de paquetes. Los valores que admite son yes o no.
Define el nombre del equipo, el cual debe de tener la forma del Fully Qualified Domain Name (FQDN). Por ejemplo:
HOSTNAME
equipo.ejemplo.net
GATEWAY Este parametro define la dirección IP del Gateway
Configuracion de la interfaz de red

El directorio de configuración de la interfaz de red se encuentra en:
/etc/sysconfig/network-scripts/
Dentro de este directorio se encuentran los archivos de configuración de los dispositivos, dependiendo del numero de interfaces de red instaladas en
el computadora será el numero de archivos de configuración, el nombre de estos archivos depende del tipo de dispositivo
Ethernetifcfg-eth0, ifcfg-eth1, ..., ifcfg-ethN.

Wi-Fi ifcfg-wlan0, ifcfg-wlan1, ..., Ifcfg-wlanN.
Modem ifcfg-ppp0, ifcfg-ppp1, ..., ifcfg-pppN.
en donde N representa el numero de interfaz a configurar. Los parámetros que admiten los archivos de configuración de la interfaz de red Ethernet
son los siguientes:
DEVICE Define el nombre del dispositivo físico

BOOTPROTOnone No utiliza ningún protocolo de arranque.
static Se define de forma manual los parámetros de red. dhcp Obtiene los parámetros de red por medio de un servidor de DHPC|
IPADDR Define la dirección IP asignada a ese dispositivo.
NETMASK Define la mascara de red.
NETWORK Define el segmento de red
54 de 63 24/07/2010 11:53 p.m.

HWADDR Define el dirección MAC del dispositivo de red. Se recomienda que modificar el valor de este parámetro.
GATEWAY Define la Dirección IP del Gateway en la red
ONBOOT Establece si el dispositivo debe activarse con los servicios de red
DNS1, DNS2 Define la direcciones de los servidores DNS primario y secundario a utilizar.
Esta opción establece un nombre al equipo. Utilice esta opción si el servidor DHCP requiere que el cliente especifique el nombre
DHCP_HOSTNAME
de su equipo antes de recibir una dirección IP.
Ejemplo del archivo de configuración.
DEVICE=eth0
BOOTPROTO=static
IPADDR=192.168.2.10
NETMASK=255.255.255.0
NETWORK=192.168.2.0
GATEWAY=192.168.2.254
DNS1=192.168.2.1
HWADDR= 00:1E:EC:6E:CD:51
Tareas de Administracion de Seguridad

El Protocolo SSH
El protocolo SSH (Secure Shell) es una herramienta que nos permite conectarnos a equipos remotos (Servidores en Producción) así mismo, nos da
la capacidad de llevar a cabo tareas administrativas dentro del mismo como, activar o apagar servicios, Además de la conexión a otros equipos, SSH
nos permite copiar datos de forma segura, gestionar claves RSA para no escribir claves al conectar a las máquinas y pasar los datos de cualquier
otra aplicación por un canal seguro tunelizado mediante SSH. Una clave RSA (Sistema Criptografico con Clave Publica) es un algoritmo que genera
un par de llaves de autenticacion, la publica y la privada. La publica se distribuye en forma autenticada y la privada que generalmente es guardada
en secreto por el propietario. El protocolo SSH (Secure Shell) esta implementado bajo el estándar TCP/IP, el cual a su vez se encuentra dividido en 5
secciones:
1.Nivel Físico 2.Nivel De Enlace 3.Nivel de Internet 4.Nivel de Transporte 5.Nivel de Aplicación
Por lo que el protocolo SSH esta ubicado en la quinta capa del modelo TCP/IP, nos referimos a la capa de aplicación La capa de aplicación es el
nivel que los programas más comunes utilizan para comunicarse a través de una red con otros programas. Los procesos que acontecen en este nivel
son aplicaciones específicas que pasan los datos al nivel de aplicación en el formato que internamente use el programa y es codificado de acuerdo
con un protocolo estándar. De manera predeterminada, el protocolo SSH atiende peticiones por el puerto 22 En este capitulo haremos uso de
OpenSSH la cual es la alternativa libre y abierta al programa propietario SSH
Acerca de OpenSSH
OpenSSH (Open Secure Shell) es un conjunto de aplicaciones que permiten realizar comunicaciones cifradas a través de una red, usando como
base al protocolo SSH. Este proyecto es liderado actualmente por Theo de Raadt quien actualmente es fundador y líder de proyectos como
OpenBSD. Los desarrolladores de OpenSSH aseguran que este es más seguro que el original, lo cual es debido a la conocida reputación de los
desarrolladores de OpenBSD por crear código limpio y perfectamente auditado, lo que contribuye a que sea más seguro. Su seguridad también es
atribuible al hecho de que su código fuente se distribuya libremente con una licencia BSD. Aunque todo el código fuente del SSH original también
está disponible, existen restricciones con respecto a su uso y distribución, lo que convierte a OpenSSH en un proyecto mucho más atractivo a la
hora de atraer nuevos desarrolladores.
Además de la conexión a otros equipos, openSSH nos permite copiar datos de forma segura mediante la implementación de dos herramientas
proporcionadas por openSSH, estas son:
SCP
SFTP
Estas herramientas en realidad tienen la misma función de copiado solo se diferencian en la forma en como son aplicadas tema del cual hablaremos
mas adelante.
Instalando OpenSSH
A partir de este punto empezaremos a descargar los paquetes necesarios para el perfecto funcionamiento de openSSH, de esta manera si usted se
encuentra trabajando bajo algún ambiente gráfico, sea KDE o GNOME le pedimos abra una terminal de BASH, por otra parte si usted se encuentra
trabajando bajo linea de comandos no tendrá que hacer nada. Los paquetes a descargar son los siguientes:
openssh
openssh-clients
openssh-server
La forma en que se instalaran estos paquetes sera tecleando en consola lo siguiente:
55 de 63 24/07/2010 11:53 p.m.

[root@ localhost ] # yum install -y openssh openssh-clients openssh-server
Una vez finalizado el proceso de instalación pasaremos con las configuraciones propias de openSSH, nos referimos a los ficheros de configuración
Archivos de configuración de OpenSSH

OpenSSH dispone de dos conjuntos diferentes de ficheros de configuración: uno completamente dedicado al cliente (ssh, scp y sftp) y otro
orientado completamente al servidor.
Archivos de configuración del lado del servidor

La ubicación de los ficheros de configuración referentes al servidor openSSH se encuentran en la siguiente ruta:
/etc/ssh/
Dentro del directorio podemos encontrar los siguientes ficheros de configuración:
Contiene grupos Diffie-Hellman usados para el intercambio de la clave Diffie-Hellman que es imprescindible para la
construcción de una capa de transporte seguro. Cuando se intercambian las claves al inicio de una sesión SSH, se crea un
moduli
valor secreto y compartido que no puede ser determinado por ninguna de las partes individualmente. Este valor se usa para
proporcionar la autenticación del host.
El archivo de configuración del sistema cliente SSH por defecto. Este archivo se sobrescribe si hay alguno ya presente en el
ssh_config
directorio principal del usuario
sshd_config El archivo de configuración para el demonio sshd
ssh_host_dsa_key La clave privada DSA usada por el demonio sshd
ssh_host_dsa_key.pubLa clave pública DSA usada por el demonio sshd
ssh_host_key La clave privada RSA usada por el demonio sshd para la versión 1 del protocolo SSH.
ssh_host_key.pub La clave pública RSA usada por el demonio sshd para la versión 1 del protocolo SSH.
ssh_host_rsa_key La clave privada RSA usada por el demonio sshd para la versión 2 del protocolo SSH.
ssh_host_rsa_key.pub La clave pública RSA usada por el demonio sshd para la versión 2 del protocolo SSH.
Archivos de configuración del lado del cliente

La ubicación de los ficheros referentes al cliente se encuentran almacenados en el directorio de trabajo de cada usuario: Ejemplo: “/home/usuario/”
Dentro del directorio podemos encontrar los siguientes ficheros de configuración:
Este archivo contiene una lista de claves públicas autorizadas. Cuando un cliente se conecta al servidor, el servidor autentica al
authorized_keys
cliente chequeando su clave pública firmada almacenada dentro de este archivo.
id_dsa Contiene la clave privada DSA del usuario.
id_dsa.pub La clave pública DSA del usuario
id_rsa La clave RSA privada usada por ssh para la versión 2 del protocolo SSH.
id_rsa.pub La clave pública RSA usada por ssh para la versión 2 del protocolo SSH.
identity La clave privada RSA usada por ssh para la versión 1 del protocolo SSH.
identity.pub La clave pública RSA usada por ssh para la versión 1 del protocolo SSH.
Este archivo contiene las claves de host DSA de los servidores SSH a los cuales el usuario ha accedido. Este archivo es muy
known_hosts
importante para asegurar que el cliente SSH está conectado al servidor SSH correcto
Configuración de fichero sshd_config

La función que desempeñan los ficheros de configuración de openSSH son de vital importancia para la seguridad de nuestro servidor , ya que si no
se llegaran a configurar apropiadamente estos ficheros la vulnerabilidad de nuestro servidor seria demasiado sensible a ataques informáticos, es por
ello que le enseñaremos la manera apropiada en la que deberá ser configurado este vital fichero.
Blindando el fichero sshd_config
Este fichero lo podrá localizar en en la siguiente ruta
/etc/ssh/
El siguiente paso sera abrir el fichero con la ayuda del editor de textos VI
[root@ localhost #] vi /etc/ssh/sshd_config
A partir de este punto comenzaremos a blindar SSH
Cambiando el puerto por defecto
SSH tiene asignado por defecto el puerto 22, esto es algo que conocen todos nuestros posibles atacantes , por lo que es una buena idea cambiarlo.
Para modificar esta opción y las siguientes que iremos mencionando editaremos el fichero de configuración shd_config, que por defecto se
encuentra en el directorio /etc/ssh/. Se recomienda usar un puerto cualquiera por encima del 1024, así que usted puede elegir el que quiera. En
este ejemplo usaremos el 34765, por lo que tendrá que editar el parámetro Port del fichero de configuración el cual deberá quedar así:
56 de 63 24/07/2010 11:53 p.m.

# The strategy used for options in the default sshd_config shipped with
# OpenSSH is to specify options with their default value where
# possible, but leave them commented. Uncommented options change a
# default value.
Port 34567
#AddressFamily any
#ListenAddress 0.0.0.0
#ListenAddress ::
Desactivando el Protocolo 1
Hay dos versiones de ssh en cuanto a su protocolo de comunicación, estas son:
Versión 1
Versión 2
La versión 1 de openSSH hace uso de varios algoritmos de cifrado de datos mas sin embargo, algunos de estos algoritmos han dejado de ser
mantenidos por sus creadores y por lo tanto presenta serios huecos de seguridad que potencialmente permite a un intruso insertar datos en el canal
de comunicación. Para evitar el uso del protocolo 1 y sus posibles ataques a este, basta con indicar que solo admita comunicaciones de ssh
basadas en el protocolo 2, por lo que tendrá que editar el parámetro Protocol del fichero de configuración el cual deberá quedar así:
# Disable legacy (protocol version 1) support in the server for new

# installations. In future the default will change to require explicit
# activation of protocol 1
Protocol 2
Deshabilitando el acceso a root
Este es quizá el parámetro mas importante de seguridad que podemos indicar para blindar nuestro servidor. Prácticamente la mayoría de sistemas
operativos Linux crean por defecto al usuario root , es por ello que la mayoría de los ataques informáticos se concentran en atacar al equipo a través
de la cuenta de root y mucho mas si la cuenta tiene asignada una contraseña débil Una manera de deshabilitar el logeo al sistema a través de la
cuenta de root es poner en 'no' la variable PermitRootLogin , con esto el usuario root no tendrá permiso de acceder mediante ssh y por lo tanto
cualquier intento de ataque directo a root será inútil. Con esto siempre tendremos que ingresar como un usuario normal y ya estando adentro
entonces mediante un su – cambiarnos a la cuenta de root. Para llevar a cabo estos cambios tendrá que editar el parámetro PermitRootLogin del
fichero de configuración el cual deberá quedar de la siguiente manera:
# Authentication:
#LoginGraceTime 2m
PermitRootLogin no
#StrictModes yes
#MaxAuthTries 6
Definiendo un número máximo de intentos de conexión
Muchos de los ataques llevados a cabo por piratas informáticos se basan en fuerza bruta, estableciendo un número máximo de intentos de conexión
lograremos que sus intentos por entrar a nuestro servidor sean disuadidos. Para llevar a cabo estos cambios tendrá que editar el parámetro
MaxAuthTries del fichero de configuración el cual deberá quedar de la siguiente manera:
# Authentication:
#LoginGraceTime 2m
PermitRootLogin no
#StrictModes yes
MaxAuthTries 2
El número 2 indica la cantidad de veces que podemos equivocarnos al ingresar el usuario y/o contraseña, en este caso después de dos intentos, se
perderá o cerrará la conexión. Claro, es totalmente posible volver a intentarlo, pero con solo dos intentos por vez.
Activando el modo estricto
La opción StrictModes debe activarse para que, por ejemplo, los usuarios que establecen permisos de escritura para todos en sus ficheros y
directorios no se lleven una desagradable noticia cuando otro usuario los modifique, de esta manera se protege la información de los usuarios. Para
llevar a cabo estos cambios tendrá que editar el parámetro StrictModes del fichero de configuración el cual deberá quedar de la siguiente manera:
# Authentication:
57 de 63 24/07/2010 11:53 p.m.

#LoginGraceTime 2m
PermitRootLogin no
StrictModes yes
MaxAuthTries 2
Impidiendo la conexión al servidor gráfico
Si nuestro servidor no tienen entorno gráfico instalado, o no queremos que los usuarios se conecten a él, definiremos esta opción en el fichero de
configuración: Para llevar a cabo estos cambios tendrá que editar el parámetro X11Forwarding del fichero de configuración el cual deberá quedar
de la siguiente manera:
# Accept locale-related environment variables

AcceptEnv LANG LC_CTYPE LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY LC_MESSAGES
AcceptEnv LC_PAPER LC_NAME LC_ADDRESS LC_TELEPHONE LC_MEASUREMENT
AcceptEnv LC_IDENTIFICATION LC_ALL
#AllowTcpForwarding yes
#GatewayPorts no
#X11Forwarding yes
Limitando el tiempo para autenticarse con SSH
El número indica la cantidad de segundos en que la pantalla de login estará disponible para que el usuario capture su nombre de usuario y
contraseña, si no lo hace, el login se cerrará, evitando así dejar por tiempo indeterminado pantallas de login sin que nadie las use, o peor aun, que
alguien este intentando mediante un script varias veces el adivinar un usuario y contraseña. Si somos el único usuario del sistema considero que con
20 o 30 segundos es mas que suficiente. Para llevar a cabo estos cambios tendrá que editar el parámetro LoginGraceTime del fichero de
configuración el cual deberá quedar de la siguiente manera:
# Authentication:
LoginGraceTime 30
PermitRootLogin no
StrictModes yes
MaxAuthTries 2
Iniciar, detener o reiniciar el servidor openSSH
Llegado a este punto usted ya deberá contar con las configuraciones de seguridad apropiadas, por lo que solo faltaría iniciar el servicio de SSH.
Para iniciar el servicio de SSH tendrá que teclear en consola y como root lo siguiente:
[root@ localhost ]# /etc/init.d/sshd start
Igualmente existen opciones ya sea para reiniciar, detener, recargar o conocer el status en el que se encuentra el servicio. Estas opciones pueden
ser consultadas en la siguiente tabla:
start Inicia el servicio

stop Detiene el servicio
Reinicia el servicio.-La diferencia con reload radica en que al ejecutar un restart este mata todos los procesos relacionado con el servicio
restart
y los vuelve a generar de nueva cuenta
Recarga el servicio.-La diferencia con restart radica en que al ejecutar un reload este solamente carga las actualizaciones hechas al
reload fichero de configuración del servicio sin necesidad de matar los procesos relacionados con el mismo, por lo que podría entenderse que
hace el cambio en caliente.
condrestartReinicio Condicional.- Solamente se inicia si el servicio se encuentra ejecutándose.
status Da a conocer el estado en el que se encuentra el servicio
Anexando el servicio de SSH al arranque del servidor
Para añadir el servicio de SSH al arranque del servidor solo tendrá que teclear en consola y como root lo siguiente:
[root@ localhost ]# chkconfig sshd on
Esto es útil cuando por motivos ajenos a usted se reinicia el servidor, de esta manera cuando el equipo arranque, automáticamente levantara el
servicio de SSH sin necesidad de levantarlo manualmente después.
Aprendiendo a utilizar openSSH
En esta parte del capitulo le enseñaremos a:
58 de 63 24/07/2010 11:53 p.m.

Conectarse a un equipo remotamente a través de SSH

Copiar archivos o carpetas desde un equipo remoto
Enviar archivos o carpetas a un equipo remoto
Conectándose a un equipo remoto a través de SSH
Para establecer una conexión con un servidor SSH remoto desde Centos haremos uso del Bash, o también conocido como Terminal. La sintaxis
para llevar a cabo esta operación es la siguiente:
[root@ localhost ]# ssh usuarioRemoto@ipDelServidorRemoto
En caso de haber establecido un puerto de escucha distinto al puerto 22, solo deberá especificar el puerto por el cual requiere autenticarse al
servidor. Ejemplo
[root@ localhost ]# ssh -p[puertoDeEscucha] usuarioRemoto@ipDelServidorRemoto
Ejemplo 1: La empresa Factor Integración para la cual trabajamos, nos ha pedido reiniciar el servicio de apache , para ello nos ha proporcionado los
siguientes datos:
IP del servidor remoto -> 207.249.25.60

Nombre del usuario remoto -> adminlog
Puerto de autenticacion -> 34765
Solución: 1.-Para conectarnos al servidor remoto habrá que especificar el puerto de escucha, el usuario remoto y la IP del servidor remoto
(Recuerde que no esta permitido conectarse como root desde SSH)
2.-El siguiente paso sera teclear la contraseña del usuario remoto
3.-Una vez dentro del servidor remoto nos logearemos ahora si como “root”
[adminlog@ web ]# su -
Contraseña: xxxxxxxxxxxxxxxxxx
[root@ web ]#
4.-Por ultimo, solo bastara reiniciar el servidor de apache
[root@ web ]# /etc/init.d/httpd restart
5.-Para salir del SSH solo basta teclear “exit”
[root@ web ]# exit

Connection to 207.249.25.60 closed.
[root@ localhost ~] # _
Copiar u obtener archivos o carpetas desde un equipo remoto

Para copiar archivos, ficheros o carpetas desde un equipo remoto hacia nuestro equipo existen dos maneras:
Mediante el uso del comando SCP

Mediante el uso del comando SFTP
Copiando ficheros a través de SCP (Shell Secure Copy)

Es un medio de transferencia segura de archivos entre un equipo local y uno remoto haciendo uso del protocolo Open Secure Shell (openSSH). La
diferencia en utilizar SCP (Shell ) y SFTP (Security File Transfer Protocol) para copiar archivos, carpetas o ficheros radica en que para SCP
tenemos que conocer exactamente donde se encuentra el recurso que queremos copiar, de otra forma nunca lo descargara, en cambio SFTP nos
deja navegar entre las carpetas lo cual hace mas sencillo la ubicación del recurso que deseamos copiar. La única desventaja que presenta SCP es
que únicamente permite la transferencia de archivos (descarga y subida de ficheros). La sintaxis de SCP para llevar a cabo esta operación es la
siguiente:
[root@ localhost ]#scp usuarioRemoto@ipDelServidorRemoto:rutaDelRecursoRemoto
servidor. Ejemplo:
[root@ localhost ]#scp -P[puertoDeEscucha] usuarioRemoto@ipDelServidorRemoto:rutaDelRecursoRemoto
Aunado a esto, para descargar una carpeta tendrá que seguir la siguiente sintaxis:
[root@ localhost ]#scp -P[puertoDeEscucha] -r usuarioRemoto@ipDelServidorRemoto:rutaDelDirectorioRemoto
59 de 63 24/07/2010 11:53 p.m.

Ejemplo 2: La misma empresa, Factor Integración, nos ha pedido copiar la carpeta de inventarios de la empresa la cual esta hospedada en un
servidor remoto , para ello nos ha proporcionado los siguientes datos:

Ruta del Recurso Remoto -> /tmp/Conta
Solución: Para poder hacer la copia desde servidor remoto habrá que especificar el puerto de escucha, el usuario remoto, la IP del servidor remoto
y la ruta (sin errores) del recurso remoto.
Lo anterior nos copiará la carpeta "/tmp/Conta" remota en el directorio actual "." naturalmente siempre que usuario tenga permisos sobre la carpeta y
su cuenta esté entre las de los que pueden hacer ssh. La opción "-r" significa recursivo, es decir, copia la carpeta y todo su contenido, incluidas las
subcarpetas y el contenido de éstas.
Copiando ficheros a través de SFTP (Security File Transfer Protocol)
El protocolo de transferencia de archivos SFTP es un protocolo que proporciona la transferencia de archivos y la funcionalidad de manipulación de
los mismos Se utiliza normalmente con SSH a fin de asegurar la transferencia de archivos. En comparación de capacidades con el anterior
protocolo SCP, que únicamente permite la transferencia de archivos, el protocolo SFTP permite una serie de operaciones sobre archivos, ficheros, o
carpetas remotos, en pocas palabras, nos permite navegar directamente en el servidor remoto con el fin de localizar el recurso que deseamos
descargar. La sintaxis de SFTP para llevar a cabo esta operación es la siguiente:
[root@ localhost]# sftp usuarioRemoto@ipDelServidorRemoto
servidor. Ejemplo.
[root@ localhost]# sftp -o Port=[PuertoDeEscucha] usuarioRemoto@ipDelServidorRemoto
El siguiente paso sera autenticarnos con la contraseña del usuario remoto
Connecting to IPDelServidorRemoto...
usuarioRemoto@IPDelServidorRemoto's password: xxxxxxxxxxxxxxxxxxxxxx
Una vez dentro del servidor solo bastara ejecutar el comando “get” para descargar algún fichero o archivo.

sftp> get recursoRemoto
La siguiente tabla explica mas a detalle los comandos que pueden ser utilizados con SFTP:
cd rutaRemota Cambia de directorio dentro del servidor remoto

lcd rutaLocal Cambia de directorio en el equipo local
chgrp grp rutaRemota Cambia el grupo de trabajo de un fichero remoto. El grp tiene que ser un Group ID
chmod opciones rutaRemotaCambia los permisos de Lectura, Escritura o de Ejecución a un fichero remoto
chown own rutaRemota Cambia el grupo de trabajo de un fichero remoto. El own tiene que ser un User ID
get rutaRemota rutaLocal Copia un recurso remoto en un equipo local
lmkdir rutaLocal Crea una carpeta en el equipo local

lpwd Imprime la ruta local en la cual estamos trabajando
mkdir rutaRemota Crea una carpeta en el equipo remoto
put rutaLocal rutaRemota Sube un fichero o archivo desde una ruta local hasta una ruta remota
pwd Imprime la ruta remota en la cual estamos trabajando
exit Salimos de SFTP
rename rutaLocal rutaRemotaRenombra un un fichero remoto
rmdir rutaRemota Borra una carpeta remota
rm rutaRemota Borra un fichero remoto
Ejemplo 3: La misma empresa, Factor Integración, nos ha pedido copiar el fichero inventarioEnero.odt que se encuentra dentro la ruta “/tmp/Conta/”
, para ello nos ha proporcionado los siguientes datos:

Ruta del Recurso Remoto -> /tmp/Conta
Solución: 1.-Para poder traer la copia desde servidor remoto hacia nuestro equipo habrá que especificar el puerto de escucha, el usuario remoto y
60 de 63 24/07/2010 11:53 p.m.

la IP del servidor remoto
2.- Nos pedirá autenticarnos con la contraseña del usuario remoto, en este caso la contraseña del usuario “adminlog”
3.-Una vez autenticados con el servidor nos dará acceso a través de SFTP
4.- Nos moveremos entre directorios con la ayuda del comando “cd” hasta estar ubicados en “/tmp/Conta”
5.-Dentro de la carpeta “Conta” aplicar el comando “dir” para visualizar el contenido de la misma
sftp>dir
inventarioEnero.odt inventarioFebrero.odt inventarioMarzo.odt
6.-Con la ayuda del comando “get” descargaremos el fichero nombrado “inventarioEnero.odt” dentro de la carpeta “home” de nuestro sistema
Subir o enviar archivos o carpetas a un equipo remoto
Para subir archivos, ficheros o carpetas desde nuestro equipo hacia un equipo remoto existen dos maneras:
Mediante el uso del comando SCP
Mediante el uso del comando SFTP
Enviando ficheros a través de SCP (Shell Secure Copy)
La sintaxis de SCP para llevar a cabo esta operación es la siguiente:
[root@ localhost ]#scp rutaDelRecursoLocal usuarioRemoto@ipDelServidorRemoto:rutaRemota
servidor. Ejemplo
[root@ localhost ]#scp -P[puertoDeEscucha] rutaDelRecursoLocal usuarioRemoto@ipDelServidorRemoto:rutaRemota
Aunado a esto, para subir una carpeta tendrá que seguir la siguiente sintaxis:
[root@ localhost ]#scp -P[puertoDeEscucha] -r directorioLocal usuarioRemoto@ipDelServidorRemoto:rutaRemota
Ejemplo 4: Se nos ha pedido subir una actualización referente a la pagina web de la empresa , para ello nos ha proporcionado los siguientes datos:

Ruta del Servidor a donde se tiene que subir la información -> /tmp/Conta
Solución: Para subir este directorio al servidor remoto habrá que especificar la ruta del directorio local,el puerto de escucha, el usuario remoto, la IP
del servidor remoto y la ruta (sin errores) a donde se quiere enviar el directorio
Luego de haber hecho esto nos pedirá autenticarnos con la contraseña del usuario remoto
adminlog@207.249.25.60's password:xxxxxxxxxxxxx
Al finalizar nos mostrara un ventana mostrando el progreso de cada copia hecha al servidor remoto como la que se muestra a continuación.
Actualizacion1.html 100% 0.0KB/s 05:00

actualizacion2.html 100% 0.0KB/s 07:00
Enviando ficheros a través de SFTP (Security File Transfer Protocol)
La sintaxis de SFTP para llevar a cabo esta operación es la siguiente:
[root@ localhost]# sftp usuarioRemoto@ipDelServidorRemoto
servidor. Ejemplo.
61 de 63 24/07/2010 11:53 p.m.

El siguiente paso sera autenticarnos con la contraseña del usuario remoto
Una vez dentro del servidor solo bastara ejecutar el comando “put” para descargar algún fichero o archivo.

sftp> put recursoLocal
La siguiente tabla explica mas a detalle los comandos que pueden ser utilizados con SFTP:
cd rutaRemota Cambia de directorio dentro del servidor remoto

lcd rutaLocal Cambia de directorio en el equipo local
chgrp grp rutaRemota Cambia el grupo de trabajo de un fichero remoto. El grp tiene que ser un Group ID
chmod opciones rutaRemotaCambia los permisos de Lectura, Escritura o de Ejecución a un fichero remoto
chown own rutaRemota Cambia el grupo de trabajo de un fichero remoto. El own tiene que ser un User ID
get rutaRemota rutaLocal Copia un recurso remoto en un equipo local
lmkdir rutaLocal Crea una carpeta en el equipo local
lpwd Imprime la ruta local en la cual estamos trabajando
mkdir rutaRemota Crea una carpeta en el equipo remoto
put rutaLocal rutaRemota Sube un fichero o archivo desde una ruta local hasta una ruta remota
pwd Imprime la ruta remota en la cual estamos trabajando
exit Salimos de SFTP
rename rutaLocal rutaRemotaRenombra un un fichero remoto

rmdir rutaRemota Borra una carpeta remota
rm rutaRemota Borra un fichero remoto
Ejemplo 5: Se nos ha pedido subir una actualización referente a la pagina web de la empresa , pero esta vez sera usando SFTP, para ello nos ha
proporcionado los siguientes datos:

Ruta del Servidor a donde se tiene que subir la información -> /tmp/Conta
Solución:
1.- Para subir este directorio al servidor remoto habrá que especificar el puerto de escucha, el usuario remoto y la IP del servidor remoto 2.- Nos
pedirá autenticarnos con la contraseña del usuario remoto, en este caso la contraseña del usuario “adminlog” 3.-Una vez autenticados con el
servidor nos dará acceso a través de SFTP 4.- Nos moveremos entre directorios con la ayuda del comando “cd” hasta estar ubicados en
“/tmp/Conta” 5.-Dentro de la carpeta “Conta” aplicar el comando “lpwd” para verificar la ruta en la cual estamos ubicados localmente
sftp> lpwd
Local working directory: /home/juanito
6.-Si no se encuentra ubicado en el directorio de trabajo indicado cámbiese de directorio mediante el comando “lcd”
sftp> lcd /home/juanito/datosActualizados

lcd /home/juanito/datosActualizados
7.- Cuando este ubicado en el directorio de trabajo que contiene la información que desea subir al servidor remoto teclee lo siguiente:
sftp> put datosactuales
El comando “put” tiene la funcionalidad de subir archivos desde una maquina local hasta un equipo remoto. 8.- Por ultimo teclee la palabra exit para
salir del “SFTP”
sftp> exit
[root@localhost ]#
0 archivos adjuntos 384 Accesos
62 de 63 24/07/2010 11:53 p.m.

Promedio (0 Votos)
63 de 63 24/07/2010 11:53 p.m.

Idioma

¡Te damos la bienvenida a Scribd!

Certificación LPI 102

Cargado por

Información del documento

Fecha en que fue cargado

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Descripción:

Copyright:

Formatos disponibles

Certificación LPI 102

Cargado por

Descripción:

Copyright:

Formatos disponibles

Títulos relacionados

Certificación LPI 102 - Base de Conocimiento http://www2.linuxparatodos.net/web/comunidad/base-de-conocimiento...

Inicio » Certificación LPI »

Certificación LPI 102

Tabla de Contenidos [-]

1 Shell, Scripting y Manejo de datos

1 de 63 24/07/2010 11:53 p.m.

3.3.5 Comando hwclock

2 de 63 24/07/2010 11:53 p.m.

Shell, Scripting y Manejo de datos

Personalizando y conociendo el shell

Archivos de configuracion de BASH

[BASH]# echo $SHELL

Observe la salida del comando. Si es

/bin/bashSu shell de entrada sera el Shell Bourne

.bash_profile (para los shell Bourne y Korn)

Ficheros ~/.bash_profile , ~/.bash_logout y ~/.bashrc

3 de 63 24/07/2010 11:53 p.m.

set bell-style none

Su fichero de configuracion global es el fichero

Diferencias entre ~/.bash_profile , ~/.bashrc y /etc/profile, /etc/bashrc

Solo existe una sola copia de los archivos /etc/profile y /etc/bashrc.

4 de 63 24/07/2010 11:53 p.m.

OSTYPE Cadena describiendo el sistema operativo que esta ejecutando Bash

Como establecer la variable PATH

Variables locales y globales de Shell

[BASH]# saludo='Linux Para Todos'

[BASH]# saludo='Linux Para Todos'

[BASH]# unset saludo

Alias para el Shell Bash

5 de 63 24/07/2010 11:53 p.m.

[BASH]# alias ls='ls -l'

Para eliminar los alias asignados use el comando “unalias”

Funciones de Shell Bash

unction nombreDeLafuncion() {listaDeComandos;}

function Orden que invoca al comando function , es opcional

[BASH]# function listado() { pwd; ls;}

La funcion anteriormente definida se usa de la siguiente manera:

Ejemplos validos en la declaracion de funciones

[BASH]# function look() { pwd; ls;}

[BASH]# function look { pwd; ls; }

[BASH]# $ look() { pwd; ls;}

Ejemplos invalidos en la declaracion de funciones

[BASH]# function look() pwd; ls;

[BASH]# look() { pwd; ls }

[BASH]# function look() {pwd; ls;}

Personalizar o escribir scripts simples

6 de 63 24/07/2010 11:53 p.m.

Comparaciones de cadenas alfanumericas

Comparacion de valores numericos

7 de 63 24/07/2010 11:53 p.m.

for var [in lista]

for planeta in Mercury Venus Terra Marte Jupiter Saturno

Sentencia while y until

La sintaxis del comando until es la siguiente:

8 de 63 24/07/2010 11:53 p.m.

select variable [in lista]

9 de 63 24/07/2010 11:53 p.m.

Manejo de datos en MySQL