LE101 - Linux Enterprise Operacional v1-5

LE-101 - Linux Enterprise Operacional

Tabla de contenido

Índice de contenido

Introducción al sistema operativo LINUX...............................................................................7El sistema operativo Linux......................................................................................................8

Usuarios y grupos...................................................................................................................9

El usuario root.......................................................................................................................10

Organización del árbol de archivos ....................................................................................11

El directorio raíz: / ................................................................................................................11

Introducción a la línea de comandos....................................................................................13

Ejecución de comandos y opciones.....................................................................................13

Obtener ayuda......................................................................................................................13

El comando info....................................................................................................................14

Fecha, hora, calendario........................................................................................................15

Manipulación de contraseñas...............................................................................................16

Utilización de consolas virtuales...........................................................................................16

Otros comandos básicos útiles.............................................................................................17

Manipulación de archivos......................................................................................................18Directorio actual de trabajo...................................................................................................19

Nombres de archivos............................................................................................................19

Listar el contenido de directorios..........................................................................................19

Rutas absolutas y relativas...................................................................................................20

El directorio HOME...............................................................................................................21

Cambiando directorios..........................................................................................................21

Comodines de la línea de comandos...................................................................................22

Comprobando espacio disponible........................................................................................24

Crear y borrar archivos y directorios....................................................................................27

Borrar archivos y directorios.................................................................................................28

Mover o renombrar archivos.................................................................................................28

Copiando archivos y directorios...........................................................................................29

Determinando el tipo de un archivo......................................................................................30

Visualizar archivos de texto..................................................................................................31

Usuarios y grupos..................................................................................................................33Usuario y grupos, concepto..................................................................................................34

El usuario root y otros usuarios del sistema........................................................................34

Modelo de seguridad de Linux.............................................................................................34

Comandos para obtener información de usuarios...............................................................35

Cambiando la identidad del usuario.....................................................................................36

Permisos de acceso a archivos y directorios......................................................................37Seguridad de archivos en Linux...........................................................................................38

Tipos de permisos de archivos.............................................................................................38

Examinando los permisos de archivos y directorios............................................................38

Cambiando permisos de archivos........................................................................................39

Permisos especiales.............................................................................................................41

Permisos por defecto de los archivos..................................................................................43

El sistema de archivos...........................................................................................................45Sistemas de archivos ext2/ext3............................................................................................46

Enlaces o vínculos simbólicos (blandos) y duros.................................................................46

Los enlaces o vínculos.........................................................................................................47

Los vínculos simbólicos y la limitación de los vínculos duros..............................................48

Buscando y procesando archivos.........................................................................................49

bzip2 y gzip: comandos de compresión de datos ...............................................................52

El comando zip.....................................................................................................................53

Copias de seguridad con el comando tar.............................................................................53

Nombres de archivos comprimidos comunes y programas asociados................................55

El editor vi................................................................................................................................56Ejecutar vi ............................................................................................................................57

Comandos de movimiento del cursor ..................................................................................57

Borrar texto ..........................................................................................................................58

Cambiar texto........................................................................................................................58

Deshaciendo y rehaciendo cambios ...................................................................................59

Grabando y saliendo.............................................................................................................59

Cortando, copiando y pegando............................................................................................59

Otras operaciones útiles.......................................................................................................60

Buscando, reemplazando y usando de expresiones regulares...........................................60

Búsqueda y sustituciones.....................................................................................................61

El intérprete de comandos BASH..........................................................................................63GNU Bourne-Again Shell y las variables de en ..................................................................64

Volviendo a llamar a comandos...........................................................................................65

Expansión de la linea de comandos.....................................................................................66

Valores de retorno de los comandos....................................................................................67

Sobrenombres......................................................................................................................67

Scripts de inicialización y finalización...................................................................................68

Historial.................................................................................................................................69

Búsqueda de comandos previamente ejecutados...............................................................69

Substitución de comandos...................................................................................................70

Redirecciones y tuberías.......................................................................................................71Descriptores de archivos, entrada, salida y error estándar.................................................72

Redireccionando la entrada y la salida................................................................................72

Redireccionando el error estándar.......................................................................................73

Sobrescritura y agregado de las redirecciones....................................................................74

Redireccionando la salida estándar y el error estándar.......................................................74

Tuberías................................................................................................................................74

Filtros y procesamiento de cadenas.....................................................................................76Concepto de filtro .................................................................................................................77

Traducción de caracteres ...................................................................................................77

Paginador de la salida por impresora...................................................................................78

Mostradores de ficheros por porciones: tail y head ............................................................79

El comando de ordenado.....................................................................................................80

Supresión de líneas repetidas .............................................................................................81

El comando de selección de campos del fichero.................................................................82

El comando de fusión de campos de diferentes ficheros....................................................83

Expresiones regulares...........................................................................................................85Expresiones regulares..........................................................................................................86

Búsqueda de patrones dentro de archivos..........................................................................86

Correspondencia de principio y fin de línea.........................................................................87

Anulación del significado especial de un caracter...............................................................87

Correspondecia con cualquier caracter................................................................................87

Conjuntos de caracteres.......................................................................................................88

Correspondencia repetida de patrones................................................................................88

Grupos de caracteres...........................................................................................................89

Buscando archivos con un patrón de texto en su contenido ..............................................90

Editores fuera de línea.........................................................................................................90

Editor de flujo sed.................................................................................................................90

El awk....................................................................................................................................94

Variables del awk..................................................................................................................95

Programación en awk...........................................................................................................97

Scripts del shell.......................................................................................................................98Conceptos básicos de scripts del shell................................................................................99

Los caracteres especiales más comunes............................................................................99

El comando read.................................................................................................................100

Test.....................................................................................................................................100

Test de archivos.................................................................................................................101

Test de comparación de enteros........................................................................................101

Test de comparación de cadenas......................................................................................102

Condicionales.....................................................................................................................102

Bucles.................................................................................................................................104

Bucles for............................................................................................................................104

Bucle while..........................................................................................................................105

Case....................................................................................................................................106

Parámetros posicionales ...................................................................................................107

Scripts de ejemplo..............................................................................................................108

Impresión y comunicación...................................................................................................110Imprimir bajo Linux.............................................................................................................111

Viendo la cola de impresión...............................................................................................112

Cancelando un trabajo de impresión..................................................................................112

La variable de entorno PRINTER ......................................................................................112

Enviar correo electrónico....................................................................................................112

Leer el correo......................................................................................................................113

Redirección de correo.........................................................................................................113

Control de procesos y herramientas del sistema.............................................................115

El árbol de procesos...........................................................................................................116

Las señales.........................................................................................................................117

kill, killall..............................................................................................................................117

Usando el control de trabajos.............................................................................................118

Agendando la ejecución periódica de procesos................................................................119

Agendando procesos para su ejecución ...........................................................................120

Nociones básicas de red......................................................................................................122Introducción a las redes IP.................................................................................................123

El comando ping.................................................................................................................123

Obteniendo información sobre interfaces..........................................................................124

Transfiriendo archivos a través de la red...........................................................................125

Shell Seguro (ssh)..............................................................................................................127

Usando el comando scp.....................................................................................................128

Uso del comando sftp.........................................................................................................129

1Introducción al sistema operativo LINUX

Introducción al sistema operativo Linux

El sistema operativo Linux

LINUX es un sistema operativo, compatible Unix. Dos características muy peculiares lo diferencian del resto de los sistemas que podemos encontrar en el mercado, la primera, es que es libre, esto significa que no tenemos que pagar ningún tipo de licencia a ninguna casa desarrolladora de software por el uso del mismo, la segunda, es que el sistema viene acompañado del código fuente. El sistema lo forman el núcleo del sistema (kernel) mas un gran numero de programas / librerías que hacen posible su utilización.

LINUX se distribuye bajo la GNU Public License: Inglés , por lo tanto, el código fuente tiene que estar siempre accesible.

El sistema ha sido diseñado y programado por multitud de programadores alrededor del mundo. El núcleo del sistema sigue en continuo desarrollo bajo la coordinación de Linus Torvalds, la persona de la que partió la idea de este proyecto, a principios de la década de los noventa.

Día a día, más y más programas / aplicaciones están disponibles para este sistema, y la calidad de los mismos aumenta de versión a versión. La gran mayoría de los mismos vienen acompañados del código fuente y se distribuyen gratuitamente bajo los términos de licencia de la GNU Public License.

Las funciones principales de este magnífico sistema operativo son: • Sistema multitarea: En Linux es posible ejecutar varios programas a la vez sin

necesidad de tener que parar la ejecución de cada aplicación.

• Sistema multiusuario: Varios usuarios pueden acceder a las aplicaciones y recursos del sistema Linux al mismo tiempo. Y, por supuesto, cada uno de ellos puede ejecutar varios programas a la vez (multitarea).

• Shells programables: Un shell conecta las ordenes de un usuario con el Kernel de Linux (el núcleo del sistema), y al ser programables se puede modificar para adaptarlo a tus necesidades. Por ejemplo, es muy útil para realizar procesos en segundo plano.

• Multiplataforma: Corre en muchas CPUs distintas, no sólo Intel, también el Alpha, PowerPC, Itanium, etc.

• Consolas virtuales múltiples: Varias sesiones de login a través de las consolas virtuales entre las que se puede cambiar con las combinaciones adecuadas de teclas.

La memoria se gestiona como un recurso unificado para los programas de usuario y para el caché de disco, de tal forma que toda la memoria libre puede ser usada para

caché y éste puede a su vez ser reducido cuando se ejecuten grandes programas.

Linux permite un acceso transparente a particiones Windows (VFAT) y acceso de sólo lectura a particiones NTFS.

El sistema operativo Linux comúnmente puede ser estructurado en capas como se muestra en la siguiente figura:

El hardware se encuentra en el centro. El sistema operativo es la interfaz entre los procesos del usuario y el hardware.

El kernel de Linux es intencionalmente compacto y diseñado para incluir aquellas operaciones que requieren privilegios especiales del sistema para ejecutarse.

El kernel es el programa de control central que provee los servicios básicos del sistema. Es un archivo ejecutable, se compila desde los archivos fuente, archivos objetos y parámetros configurables. Se carga en memoria cuando el sistema inicia y ejecuta programas y administra los recursos del computador.

El kernel espera solicitudes de los procesos del usuario para acceder a los recursos del sistema, como memoria, CPU y dispositivos. Los programas del usuario solicitan servicios al kernel por medio de llamadas del sistema o system calls. Los dispositivos de hardware se comunican con el kernel por medio de interrupciones.

El shell rodea al kernel y actúa como una interfaz del usuario. El shell es conocido como intérprete de comandos. Administra la ejecución de procesos en primer y segundo plano, posee un entorno configurable, un lenguaje flexible y proporciona redirección de la entrada y la salida.

Usuarios y grupos

El concepto de usuarios y grupos es extremadamente importante, ya que tiene una influencia directa sobre todos los demás conceptos que iremos presentando a lo largo de la unidad.

Linux es un sistema multi-usuario verdadero, y para poder usar su sistema GNU/Linux debe poseer una cuenta en el mismo.

Los dos parámetros importantes son, el nombre de conexión (comúnmente abreviado login) y la contraseña. Estos son los que usará para poder ingresar al sistema. Otra acción que ocurrió cuando se creó una cuenta de usuario es la creación de un grupo.

Por defecto, el programa de instalación habrá creado un grupo por usuario. Como veremos más adelante, los grupos son útiles cuando varias personas tienen que compartir archivos. Por lo tanto, un grupo puede contener tantos usuarios como Ud. desee, y es muy común ver tal separación en sistemas grandes.

En una universidad, por ejemplo, Ud. puede tener un grupo por cada departamento, otro grupo para los profesores, y así sucesivamente. La inversa también vale: un usuario puede ser miembro de uno o más grupos, hasta un máximo de treinta y dos. Por ejemplo, un profesor de matemáticas puede ser un miembro del grupo de profesores y también ser miembro del grupo de sus queridos estudiantes de matemáticas. Sin embargo, todo esto no le dice como conectarse.

Para poder conectarse, tendrá que ingresar su nombre de conexión en el prompt Login: y presionar Intro, después de lo cual aparecerá el programa de conexión (denominado login ) que mostrará el prompt Password:, donde deberá ingresar la contraseña para esta cuenta.

Debido a que la conexión en la consola no hace eco de los caracteres que representan a la contraseña, deberá tener cuidado cuando teclea su contraseña a ciegas. Note que Ud. se puede conectar varias veces usando la misma cuenta sobre consolas adicionales y bajo X .

Cada sesión que abra es independiente de las otras, e incluso es posible tener varias sesiones X abiertas concurrentemente.

El usuario root

Normalmente esta es la cuenta que tiene el administrador del sistema, que es muy probable que sea Ud. Para la seguridad de su sistema, es muy importante que la cuenta de root ¡siempre esté protegida por una buena contraseña! Si se conecta como root regularmente es muy fácil cometer un error que puede hacer que su sistema quede inútil; un único error puede hacer que esto ocurra. En particular, si no ha proporcionado una contraseña para la cuenta root, cualquier usuario puede conectarse usando dicha cuenta y alterar cualquier parte de su sistema (¡incluso de otros sistemas operativos presentes en su máquina!).

Obviamente, esto no es una idea muy buena. Vale la pena mencionar que, internamente, el sistema no lo identifica con su nombre de conexión sino con un número único asignado a este nombre de conexión: el UID (User ID, Identificador del usuario). Similarmente, cada grupo se identifica no por su nombre sino por su GID o Group ID, (Identificador del grupo). El UID del usuario root es 0 y el GID es también 0.

Un sistema de archivos consta de de tipos de datos abstractos (que representan la información y las operaciones posibles sobre ellas), que son necesarios para el almacenamiento, organización jerárquica, manipulación, navegación, acceso y consulta de datos. La mayoría de los sistemas operativos poseen su propio sistema de archivos.

Organización del árbol de archivos

Hoy día, un sistema Unix es grande, muy grande. Esto es particularmente cierto con GNU/Linux : la profusión de software disponible lo harían un sistema inmanejable si no hubieran guías para la ubicación de los archivos en la estructura del árbol. Respecto a eso, la norma reconocida es FHS (Filesystem Hierarchy Standard, Norma para la jerarquía del sistema de archivos).

El documento que describe la norma está disponible en diferentes formatos en la Internet en la dirección http://www.pathname.com/fhs/ (http://www.pathname.com/fhs/ ). Sólo da un breve sumario, pero debería ser suficiente para que Ud. sepa en que directorio debería buscar (o poner) un archivo dado.

El directorio raíz: /

El directorio raíz contiene toda la jerarquía del sistema. Aquí tiene una lista de los directorios y subdirectorios principales:

● /bin - Archivos binarios esenciales del sistema. Este directorio contiene los comandos básicos que usarán todos los usuarios y son necesarios para la operación del sistema: ls, cp, login, etc.

● /boot - Contiene los archivos que necesita el administrador de arranque de GNU/Linux, incluyendo el kernel y el disco RAM inicial.

● /dev - Archivos de los dispositivos del sistema.

● /etc - Este directorio contiene todos los archivos de configuración específicos a la máquina.

● /home - Contiene todos los directorios personales de los usuarios del sistema. Este directorio puede, o no montado a través de NFS.

● /lib - Este directorio contiene las bibliotecas esenciales al sistema y los módulos del kernel, en /lib/modules. Todas las bibliotecas que necesitan los binarios presentes en los directorios /bin y /sbin se deben ubicar aquí, junto con el vinculador ld.so.

● /mnt - Directorio que contiene los puntos de montaje para los sistemas de archivos temporales.

● /media - El directorio /media/ contiene los subdirectorios utilizados como puntos de montaje para la media removible, tales como DVD/CD-ROMs y discos flash/USB.

● /misc – Este directorio es utilizado por el servicio autofs el cual permite montar y desmontar automáticamente dispositivos y sistemas de archivos de red .

● /net – Este directorio es utilizado por el servicio autofs el cual permite montar y desmontar automáticamente dispositivos y sistemas de archivos de red.

● /opt - Este directorio contiene los paquetes que no son necesarios para la operación del sistema y generalmente son compilados e instalados desde el fuente, no desde un formato RPM.

● /proc - El directorio /proc/ contiene "archivos" especiales que o bien extraen información del kernel o bien la envían a éste.

● /root - Directorio personal del usuario root.

● /usr – Gerarquía secundaria de los datos de usuario, contiene la mayoría de las utilidades y aplicaciones multiusuario.

◦ /usr/bin - Comandos binarios no esenciales (no necesarios en el modo de usuario único); para todos los usuarios.

◦ /usr/sbin - Sistema de binarios no esencial (por ejemplo demonios para varios servicios de red) utilizables únicamente por el usuario root.

● /sbin - Contiene los binarios del sistema esenciales para el arranque del

mismo, sólo utilizables por root. Un usuario no privilegiado también puede ejecutarlos pero no tendrá provilegios suficientes para que el comando funcione correctamente.

● /selinux – Punto de montaje para el sistema de archivos virtual SELinux cuando este esta habilitado en el kernel.

● /sys – El directorio /sys/ utiliza el nuevo sistema de archivos virtual sysfs específico al kernel 2.6. Ahora con el soporte más extendido para los dispositivos de conexión en caliente (hot plug) en el kernel 2.6, el directorio /sys/ contiene información similar a la que se encuentra en /proc/, pero muestra una vista jerárquica de la información de dispositivos específica con relación a los dispositivos de conexión en caliente.

● /tmp - Directorio destinado a contener archivos temporales que pueden crear ciertos programas.

● /var - Ubicación para los datos que los programas pueden modificar en tiempo real (ej: el servidor de correo electrónico, los programas de auditoria, el

servidor de impresión, etc.)

Introducción a la línea de comandos

La línea de comandos es la manera más directa de enviar comandos a la máquina. Si usa la línea de comandos de GNU/Linux , rápidamente verá que es mucho más potente y tiene más capacidades que los intérpretes de comandos que puede haber usado con anterioridad. La razón de esto es que tiene un acceso directo, no sólo a todas las aplicaciones X , sino también a los miles de utilitarios en modo consola (en oposición al modo gráfico) que no tienen su equivalente gráfico, o nunca (¡o al menos todavía!) será posible mostrar en forma de menús y botones todas las opciones y combinaciones posibles.

Ejecución de comandos y opciones

Lo que obtiene en realidad al iniciar este emulador de terminal es un shell. Este es el nombre del programa con el cual Ud. interactúa. Ud. se encontrará frente al prompt:

[usuario@localhost ~]$

Esto supone que su nombre de usuario es usuario y que el nombre de su máquina es localhost (este es el caso si su máquina no es parte de una red existente). Todo lo que aparece después del prompt es lo que tiene que teclear. Note que cuando Ud. es root el signo $ del prompt cambia por un signo #. (esto sólo es válido con la configuración predeterminada, ya que puede personalizar todos estos detalles en GNU/Linux ).

Todos los comandos Unix consisten de una secuencia de letras, números y caracteres. No son validos los espacios dentro del nombre del comando. Algunos comandos validos son mail, cat, man. Linux además hace diferencia entre mayúsculas y minúsculas, lo que significa que Cat y cat son comandos distintos.

Obtener ayuda

El comando man muestra las páginas de la guía de referencia para un comando dado.

Hay aproximadamente una página completa de información sobre cat. Pruebe correr man este momento. No espere entender la pagina de manual que se le muestra. Las paginas de manual suponen un cierto conocimiento de Unix, conocimiento que tal vez Ud. no tenga en este momento.

Cuando termine de leer la pagina, es probable que vea un bloque en video inverso al nal de la pagina, parecido a “--more--". En lugar de dejar escapar el texto fuera de los limites de la pantalla, man se detiene al final de cada pagina, y espera para ver que ha decidido hacer Ud.. Si desea seguir leyendo, oprima Barra espaciadora y avanzar a una pagina. Si desea terminar con la lectura de la pagina del manual, oprima q .

Cuando el autor describe los argumentos de un comando:

comando <argumento no textual> [--opción={arg1,arg2,arg3}] [argumento_opcional ...]

Los signos “<” (menor que) y “>” (mayor que) denotan un argumento obligatorio que no debe ser copiado textualmente, sino que debe reemplazarse de acuerdo con sus necesidades. Por ejemplo, <archivo> se refiere al nombre real de un archivo. Si dicho nombre es pepe.txt, usted debería teclear pepe.txt, y no <pepe.txt> o <archivo>.

Los corchetes "[ ]" denotan argumentos opcionales, los cuales puede o no incluir en el comando.

Los puntos suspensivos "..." significan que en ese lugar se puede incluir un número arbitrario de elementos.

Las llaves "{ }" contienen los argumentos permitidos en este lugar. Uno de ellos debe ser puesto aquí.

El man provee además una función de búsqueda de palabras clave. Por ejemplo, digamos que Ud. está interesado en el tema PostScript, el lenguaje de control de impresoras desarrollado por Adobe. Si escribe:

$ man -k ps$ man -k Postscript

Recibirá como resultado una lista de todos los comandos, llamadas al sistema, y otras partes documentadas de Linux que contengan la palabra “ps" (o “Postscript") en su nombre o descripción breve. Esto puede llegar a ser muy útil cuando quiere buscar una herramienta para hacer algo, pero no conoce su nombre o si existe.

El comando info

El comando info nos sirve cuando el texto de ayuda de man es insuficiente, o directamente no existe una entrada en su base de datos sobre lo que buscamos. El programa info tiene una interfaz navegable: muchas de las páginas tienen enlaces a otras páginas relacionadas, muy similar a como tienen las páginas web. Los enlaces se indican mediante un asterisco (*) seguido por el título del enlace, seguido por un doble dos puntos (::). Para seguir los enlaces, hay que situar el cursor sobre ellos y pulsar la tecla <INTRO>.

Para ayudar la navegación por los documentos, también están las siguientes teclas:

Tecla Descripciónb Ir un paso hacia atrás, a la última página visitadau Ir al nivel superior en el árbol de páginas

Tecla Descripciónn Ir a la siguiente páginap Ir a la página previaq Salir de info

Fecha, hora, calendario

Para obtener la fecha y hora del sistema se debe ejecutar el comando date. El comando date sin argumentos devuelve la fecha y la hora actual. El comando date puede ser formateado de tal forma a obtener la fecha como sea requerido. Ejemplos:

Mostrar la hora actual:

$ date

Mostrar la hora en el formato año, mes, día:

$ date "+%Y-%m-%d"

$ date "+Año: %Y Mes: %m Dia: %d"

La fecha de un mes antes a partir de hoy:

$ date -d '1 month ago' El mes hace cinco meses del actual:$ date +%B -d '5 month ago'

La fecha de ayer: $date --date "yesterday" La fecha de mañana:$date --date "tomorrow" La fecha del viernes de la próxima semana:$ date -d "next week friday" El comando date también puede ser utilizado por el usuario root para cambiar la hora del sistema, el formato del comando es:

# date [MMDDhhmm[[CC]YY][.ss]]

El comando cal muestra un calendario en pantalla, sin opciones, el comando cal mostrará el calendario para el mes corriente. Podemos especificar al comando que muestre un mes determinado o un año específico. Por ejemplo:

Calendario del mes corriente de este año:$ cal

Calendario del año 2010:

$ cal 2010

Calendario de diciembre de 2010:

$ cal 12 2010

Manipulación de contraseñas

Muchas veces es necesario cambiar la contraseña del inicio de sesión. Esto puede ser tan solo por gusto, para mantener la seguridad, por que la contraseña actual ha sido conocida o por políticas que requieren que la contraseña sea cambiada.

Para cambiar la contraseña se utiliza el comando passwd. Un usuario no privilegiado puede cambiar tan solo su propia contraseña, ejecutando el comando passwd sin opciones.

El usuario root puede cambiar la contraseña de cualquier usuario utilizando el comando passwd <usuario>.

Ejemplos:

Para cambiar su propia contraseña ejecute el comando:

$ passwd

El usuario root puede cambiar la contraseña del usuario juan con el comando:

# passwd juan

Utilización de consolas virtuales

Las consolas virtuales permiten el acceso en simultáneo de un usuario a más de una sesión en el sistema operativo.

Por defecto, Linux tiene seis consolas virtuales además de la reservada para la interfaz gráfica. Puede cambiarse a cualquiera de ellas ingresando la secuencia de teclas Ctrl-Alt- F<n>1, donde <n> es el número de consola a la cual desea cambiarse.

Por defecto, la interfaz gráfica está sobre la consola número 7.

Otros comandos básicos útiles

Puede utilizar el comando bc para realizar cálculos matemáticos. Es una calculadora básica. Los operadores básicos son + (suma), - (resta), * (multiplicación), / (división). Para finalizar la calculadora presione las teclas CTRL+D. Por ejemplo:

$ bcbc 1.06Copyright 1991-1994, 1997, 1998, 2000 Free Software Foundation, Inc.This is free software with ABSOLUTELY NO WARRANTY.For details type `warranty'.2*488/422+242-20

El comando tty le ayudará a determinar en qué terminal está conectado actualmente.

$ tty/dev/pts/2

El comando echo le permite desplegar mensajes en la pantalla. Es muy útil para la programación de scripts del shell. Ejemplo:

$ echo "Mensaje de información"

El comando clear le permite limpiar la pantalla, también puede utilizar el método abreviado CTRL-L.

2Manipulación de archivos

Manipulación de archivos


Directorio actual de trabajo

Para averiguar el directorio de trabajo actual, basta con ingresar el comando pwd y en la linea siguiente saldrá el directorio completo donde estamos posicionados. Ejemplo:

$ pwd/tmp

Nombres de archivos

Un nombre de archivo puede contener cualquier caracter (excepto el caracter nulo - caracter ASCII 0 - y una / que es el separador de directorio), incluso los no imprimibles. Linux distingue entre mayúsculas y minúsculas. Los archivos pueden contener hasta 255 caracteres.

Como debe haber notado, un nombre de archivo no contiene extensión alguna a menos que Ud. lo prefiera así. Bajo GNU/Linux las extensiones no caracterizan el contenido de un archivo, y tampoco lo hacen bajo otros sistemas operativos si es por eso. No obstante, las llamadas extensiones de archivo siempre son muy convenientes. El caracter del punto (.) bajo Unix es simplemente un caracter entre otros. Vale la pena mencionar que, bajo Linux los nombres de archivo que comienzan con un punto son archivos ocultos.

Listar el contenido de directorios

ls: listar archivos.

El comando ls (LiSt, LiStar) es equivalente a dir de DOS , pero puede hacer mucho más. De hecho, esto se debe en gran parte al hecho de que los archivos también pueden hacer más.

La sintaxis del comando ls es la siguiente:

ls [opciones] [archivo|directorio] [archivo|directorio...]

Si no se especifica archivo o directorio alguno en la línea de comandos, ls mostrará la lista de los archivos del directorio corriente.

Sus opciones son muchas y sólo citaremos unas pocas:

19 Ing. Ivan Ferreira


Tecla Descripción-a Listar todos los archivos, incluyendo los archivos ocultos (en Linux los

archivos ocultos son aquellos cuyo nombre comienza con un . ); la opción -A lista casi todos los archivos, lo que significa que se mostrarán todos los archivos que mostrara la opción -a excepto . y ..

-l Muestra información adicional sobre cada archivo (formato largo)-s Muestra el tamaño en kilobytes junto a cada archivo-h Muestra el tamaño en formato fácilmente leíble por el humano junto a cada

archivo-R Listar recursivamente, es decir, todos los archivos y subdirectorios del

directorio que se menciona en la línea de comandos-d Trata a los directorios de la línea de comandos como si fueran archivos

normales en vez de listar su contenido-S Organiza el listado por tamaño de archivo -r Lista los archivo en orden inverso-t lista los archivos ordenados por fecha de creación o modificación

Puede combinar más de una opción en la línea de comandos, por ejemplo para listar los archivos en formato largo, incluyendo los ocultos ejecute:

$ ls -la

Para listar todos los archivos en formato largo, ordenados por fecha de modificación en orden inverso ejecute:

$ ls -latr

Para listar todos los archivos en formato largo, ordenados por tamaño ejecute:

$ ls -laS

Rutas absolutas y relativas

Una trayectoria o ruta absoluta, indica la forma de ubicar un archivo en el sistema de archivos a partir del directorio raíz. Comienza con una “/" y especifica todos lo directorios que existen antes del archivo que Ud. desea. Ejemplo:

$ ls /home/juan/

Una trayectoria o ruta relativa esta referida a su directorio actual. Existen dos directorios que se utilizan solamente para trayectorias relativas: “." y “..". El directorio “." se refiere al directorio actual, y “.." es el directorio anterior o directorio padre: son



“abreviaturas" de directorio, y existen en todos los directorios, aun el directorio raíz tiene un directorio anterior: el es su propio directorio anterior. Ejemplo:

Para listar el directorio actual puede ejecutar:

$ ls ./$ ls .$ ls

Listar el contenido de un directorio inmediatamente superior:

$ ls ../

Listar el contenido de 2 directorios por encima del actual:

$ ls ../../

Listar el contenido del directorio tmp que se encuentra 2 directorios por encima del actual

$ ls ../../tmp/

El directorio HOME

Cada usuario tiene su propio directorio (denominado su directorio personal, o home en inglés). El es el dueño de este directorio, y de los archivos que va a crear posteriormente en él.

El directorio home es el directorio al cual accede automáticamente luego de haber iniciado una sesión en el sistema.

Cambiando directorios

cd: Cambiar de directorio (Change Directory)

El comando cd es exactamente el mismo que en DOS , con alguna funcionalidad extra. Puede usar . para referirse al directorio corriente y .. para referirse al directorio padre del directorio corriente.

Si ingresa cd solo, ser llevado de vuelta a su directorio personal. Si ingresa cd - ser llevado al ultimo directorio en el cual estuvo.

Finalmente, puede especificar el directorio personal del usuario juan ingresando:

$ cd ~juan



Usando ~ solo o seguido de / significa el directorio personal suyo. Note que, como usuario no privilegiado, normalmente no puede ingresar a los directorios personales de otros usuarios (a menos que esos usuarios lo hayan autorizado explícitamente o esa sea la configuración predeterminada del sistema), excepto si Ud. es root.

Ejemplos:

Cambiando al directorio superior usando rutas relativas:

$ cd ..

Cambiando al directorio /tmp usando la ruta absoluta:

$ cd /tmp

Retornando al último directorio utilizado:

$ cd -

Cambiando al directorio HOME:

$ cd ~$ cd

Cambiando al directorio HOME de juan:

$ cd ~juan

Comodines de la línea de comandos

Los comodines permiten especificar de forma más eficiente múltiples archivos en la línea de comandos.

Comodín Descripción* Es reemplazado por el shell por "cualquier conjunto de caracteres"? Es reemplazado por un y solo un caracter en cualquier posición [] Corresponde a cualquier caracter que se encuentre entre corchetes[!] Corresponde a cualquier caracter que no se encuentre entre

corchetes ' El caracter ' (comilla simple), elimina el significado especial de los

patrones de englobamiento, también la barra invertida “\”



Comodín Descripción{c1,c2} Corresponde con c1 o con c2

Ejemplos:

Listar todos los sub-directorios de directorio:

$ ls /directorio/*

Listar todos los archivos README un nivel por debajo de dir:

$ ls /dir/*/README

Listar los archivos que comianzan con a y tienen exactamente cuatro caracteres:

$ ls a???

Listar archivos cuyo nombre comience con a, A, b, B:

$ ls [aAbB]*

Listar archivos uyo nombre comience con cualquier letra del alfabeto:

$ ls [a-zA-Z]*

Listar archivos con nombre que comiencen con un número del 0 al nueve, seguido del número 5, es decir 05, 15, 25, 35, 45, 55, 65, 75, 85, 95:

$ ls [012345789]5

Un listado igual al anterior pero simplificado con el uso de rangos:

$ ls [0-9]5

Listar todos los archivos cuyo nombre no comience con una vocal:

$ ls [!aeiou]*

Listar todos los archivos cuyo nombre no comience con letras minúsculas:

$ ls [!a-z]*

Listar el archivo salarios o el archivo sueldos:

$ ls {salario,sueldo}

Listar cualquier archivo que comience con sal o con sel:



$ ls {sal*,sel*}

$ ls {sal,sel}*

Listar los archivos README de los directorios /usr/share/doc/pam y /usr/share/doc/dovecot:

$ ls /usr/share/doc/{pam,dovecot}/README

Ejemplos de diferencias entre comillas simples y comillas dobles. Comillas dobles:

$ echo "El valor de la variable $PS1 es $PS1"El valor de la variable [\u@\h \W]\$ es [\u@\h \W]\$

Comillas simples:

$ echo 'El valor de la variable $PS1 es $PS1'El valor de la variable $PS1 es $PS1

Comillas dobles con carácter de escape para evitar la interpretación de la variable de entorno PS1:

$ echo "El valor de la variable \$PS1 es $PS1"El valor de la variable $PS1 es [\u@\h \W]\$

Comprobando espacio disponible

El sistema operativo Linux almacena organiza los datos en disco en una estructura de árbol. El punto inicial de la estructura de árbol es el directorio “/” conocido como directorio raiz. La representación de los datos en el disco por medio de esta estructura de árbol es parte de la funcionalidad del sistema de archivos. El sistema de archivos por defecto de Linux es ext3.

Para poder acceder a los datos de un dispositivo que contiene un sistema de archivos, el dispositivo debe estar “montado”.

El término “montado” se refiere a que el dispositivo debe estar asociado a un directorio en la estructura de directorios. En la siguiente figura se puede observar distintos dispositivos montados en directorios diferentes.



El primer disco contiene cuatro particiones, tres de ellas con sistema de archivos ext3. La primera partición esta montada en el directorio raíz. La tercera partición esta montada en el directorio /home, la cuarta partición esta montada en el directorio /tmp. Un segundo disco contiene una única partición que se encuentra montada en el directorio /datos.

Si se almacenan datos en el directorio /home o cualquier subdirectorio de el, se estara utilizando el espacio de la tercera partición del primer disco. Si se almacenan datos en /datos o cualquier subdirectorio de el, se estara utilizando espacio en la partición del segundo disco. Si se almacenan datos en cualquier directorio que no sea /home, /tmp o /datos, se estara utilizando espacio de la partición asociada al directorio raíz, para el ejemplo mostrado en la imagen, es la primera partición del primer disco.

El comando df muestra los distintos sistemas de archivos montados, su capacidad total, capacidad utilizada y capacidad libre. Si no se especifica ningún argumento, muestra el espacio disponible en todos los sistema de archivos existentes montados.

Las opciones más interesantes son:



Opción Descripción-k Muestra los tamaños en bloques de 1024 bytes (1K). Si no se

especifica esta opción, se mostrarán los tamaños en bloques de 512 bytes. Para convertir los tamaños de bloques a MB, es necesario dividir el tamaño reportado por 2048.

-l Muestra información exclusivamente de sistemas de archivo locales (no muestra directorios compartidos por NFS).

-s Muestra el tamaño en kilobytes junto a cada archivo-h Muestra en un formato fácil de interpretar -t <tipo> Muestra solamente los sistemas de archivos del tipo indicado-i Muestra la utilizacion de inodos en lugar de la de bloques-T Imprime el tipo de cada filesystem (sistema de archivos)

Ejemplos:

Tamaños de todos los sistemas de archivos:

$ df -k

Tamaños del sistema de archivos que contiene el directorio actual en formato fácil de interpretar:

$ df -h .

Tamaños del sistema de archivos que contiene el archivo /etc/hosts:

$ df /etc/hosts

El comando du está relacionado a la obtención de información de espacio en disco. Si deseamos conocer el tamaño que ocupa en disco un directorio específico y todo su contenido, utilizaremos el comando du.

El comando du también muestra el resultado en bloques de 512 bytes y también acepta la opción -k para mostrarlos en bloques de 1024 bytes.

La opción mas útil es la opción -s, que resume el total para el argumento dado.

Ejemplos:

Tamaño que ocupan todos los directorios del directorio actual:

$ du -sk *



Tamaño que ocupa el directorio actual:

$ du -sk .

Crear y borrar archivos y directorios

mkdir: creación de directorios vacíos.

mkdir (MaKe DIRectory, Crear directorio) se usa para crear directorios. Su sintaxis es simple:

mkdir [opciones] <directorio> [directorio ...]

Sólo una opción es digna de interés: la opción -p. La misma hace dos cosas:

1. Crear los directorios padre si es que aún no existen. Si no se especifica esta opción y los directorios padre no existen, mkdir simplemente fallará, quejándose que dichos directorios padre no existen;

2. Retornar silenciosamente si el directorio que Ud. desea crear ya existe. Similarmente, si no especifica la opción -p, mkdir fallará, quejándose que el directorio ya existe.

Aquí tiene algunos ejemplos. Crea un directorio denominado pepe en el directorio actual:

$ mkdir pepe

Crea un directorio misc en el directorio images creando primero el último si es que no existe:

$ mkdir -p images/misc/

touch: Creación de archivos vacíos.

Inicialmente, el comando touch no está orientado a la creación de archivos sino a la actualización de la hora de acceso y modificación de los archivos. Sin embargo, touch crea los archivos mencionados como archivos vacíos si es que no existan.

La sintaxis es:

touch [opciones] archivo [archivo...]

Entonces, ejecutar el comando:

$ touch archivo1 imagenes/archivo2



Crea un archivo vacío denominado archivo1 en el directorio corriente y un archivo vaco denominado archivo2 en el directorio imágenes.

Borrar archivos y directorios

rm: borrar archivos o directorios

El comando rm (ReMove, Quitar) es utilizado para eliminar archivos o directorios. Su sintaxis es la siguiente:

rm [opciones] <archivo|directorio> [archivo|directorio...]

Las opciones incluyen:

Opción Descripción-r-R

Borrar recursivamente. Esta opción es obligatoria para borrar un directorio, vacío o no. Sin embargo, también puede usar el comando rmdir para borrar directorios vacíos.

-i Pedir confirmación antes de cada supresión. -f La opuesta de -i, fuerza la supresión de los archivos o directorios.-v Modo “verbose”, muestra el nombre de cada archivo antes de eliminarlo.

Algunos ejemplos:

Borrar todos los archivos cuyo nombre termina en .jpg en el directorio imágenes y borrar el archivo archivo1 en el directorio actual, pidiendo confirmación para cada uno de los archivos

$ rm -i imagenes/*.jpg archivo1

Borra todo el directorio misc/ del directorio images/

rm -Rf images/misc/*

Mover o renombrar archivos

mv: mover o renombrar archivos

La sintaxis del comando mv (MoVe, mover) es la siguiente:



mv [opciones] <archivo|dir.> [archivo|dir. ...] <destino>

Algunas opciones:

Opción Descripción-f Fuerza la operación no hay advertencia alguna en caso de que la

operación sobre-escriba un archivo que ya existe.-i Lo contrario a -f, pedir confirmación al usuario antes de sobre-escribir un

archivo existente. -v Modo verboso, reportar todos los cambios y la actividad.

Algunos ejemplos.

Mover todos los archivos del directorio /tmp/pics/ cuyos nombres terminan en .png al directorio corriente (.), pidiendo confirmación antes de sobre-escribir cualquier archivo.

$ mv -i /tmp/pics/*.png .

Cambiar el nombre del archivo pepe a pepito.

$ mv pepe pepito

Mover, sin pedir confirmación, todos los archivos del directorio corriente cuyos nombres comiencen con archivo junto con todo el directorio imagenes/ al directorio tacho/, y mostrar cada operación llevada a cabo.

mv -vf archivo* imagenes/ tacho/

Copiando archivos y directorios

cp: copiar archivos y directorios

cp (CoPy, Copiar) permite copiar archivos y directorios. Su sintaxis es la siguiente:

cp [opciones] <archivo|dir.> [archivo|dir. ...] <destino>

cp tiene muchas opciones. Estas son las más comunes:

Opción Descripción-R Copiar recursivamente; obligatoria para copiar un directorio, incluso si está

vacío.



Opción Descripción-i Pedir confirmación antes de sobre-escribir cualquier archivo que pudiera

sobre-escribirse. -f La opuesta de -i, reemplazar cualquier archivo existente sin pedir

confirmación alguna.-v Muestra el nombre de cada archivo antes de copiarlo.-p Preserva los permisos, el propietario, el grupo y los tiempos de los ficheros

originales.

Algunos ejemplos:

Copia todos los archivos del directorio /tmp/imagenes al directorio imagenes/ ubicado en el directorio corriente. Si se va a sobre-escribir un archivo se pide confirmación:

$ cp -i /tmp/imagenes/* imagenes/

Copia todo el directorio docs más todos los archivos del directorio /shared/mp3s al directorio miscosas ubicado en el directorio actual.

$ cp -vR docs/ /shared/mp3s/* miscosas/

Hace una copia del archivo pepe bajo el nombre pepito en el directorio actual.

$ cp pepe pepito

Determinando el tipo de un archivo

file: determina el tipo de archivo

El comando file prueba cada argumento e intenta clasificar el tipo de archivo.

En Linux todo está representado por medio de archivos, inclusive ciertos dispositivos del sistema, como discos, unidades de cinta y puertos de entrada y salida.

Existen dos tipos de archivos:

• Archivos convencionales: son aquellos que contienen información y que generalmente sirven a los programas de aplicación.

• Archivos especiales: son aquellos que proveen un interfaz uniforme entre los programas y la E/S al hardware del ordenador.



Los archivos pueden clasificarse en:

• Archivo regular ( - ): Archivos comunes del sistema operativo, tipo ASCII o binario.

• Directorios ( d ): Archivos contenedores de otros archivos.

• Enlaces ( l ): Archivos que referencian a otros archivos.

• Tuberías ( p ): Archivos que permiten el intercambio de información entre procesos.

• Archivos especial de bloques ( b ): Archivos que permiten el acceso a dispositivos que manejan la E/S de la información por bloques y de forma aleatoria, como los discos duros.

• Archivos especial de caracter ( c ): Archivos que permiten el acceso a dispositivos que manejan la E/S de la información en forma secuencial y por caracter, como las terminales, teclado y mouse.

• Archivos socket ( s ): Archivos relacionados a una conexión de red.

Visualizar archivos de texto

cat: mostrar el contenido de uno o más archivos en la pantalla

No hay mucho más que decir, este comando simplemente hace eso: mostrar el contenido de uno o más archivos en la salida estándar, normalmente la terminal. Utilizando redirección de la salida estándar, puede concatenar uno o más archivos usando cat. Por ejemplo:

$ cat archivo1

less: un paginador

Su nombre es un juego de palabras relacionado al primer paginador existente bajo Unix, que se denomina more. Un paginador es un programa que permite al usuario ver archivos largos página por página (o, más precisamente, pantalla por pantalla).

Hablamos primero de less que de more porque su uso es mucho más intuitivo. Utilice el comando less para ver archivos grandes, que no entran en una pantalla.

Por ejemplo:

$ less /etc/termcap



Para acceder a la pantalla siguiente, pulse [barra espaciadora]; para volver a la pantalla anterior, pulse [b]; para salir, presione [q]. También puede usar las flechas de dirección para navegar con less.

Para buscar palabras dentro de un archivo de texto usando less, presione [/] y luego escriba la palabra que quiere buscar. Por ejemplo:

/Linux

De esta forma buscará las coincidencias dentro del texto de la palabra Linux. Para avanzar a la siguiente coincidencia, presione la tecla [n], para ir a la coincidencia anterior presione la tecla [N].

De hecho, simplemente presione [h] para la ayuda (en inglés) y eche un vistazo. Pero de todas formas, el objetivo de esta sección es que Ud. sea capaz de leer archivos largos, y dicho objetivo ya está cumplido.

more: paginador de archivos

El comando more permite la visualización de un archivo por páginas, así como el comando less, excepto que las teclas de control son diferentes. La [barra espaciadora] es utilizada para avanzar una página del archivo, la tecla [Enter] para avanzar por línea y la tecla [b] para retroceder una página. Para salir, utilice la tecla [q]. Puede buscar texto de la misma forma que en less, usando la tecla [/].

$ more /etc/termcap


3Usuarios y grupos

Usuarios y grupos

Usuarios y grupos

Usuario y grupos, concepto

El Linux es un sistema operativo multiusuario. Cada usuario debe tener un “login” para iniciar sesión en el sistema y pertenece a uno o más grupos. Los grupos permiten organizar usuarios de funciones o características similares de tal modo que éstos puedan compartir archivos, hacer más fácil la administración de la seguridad y configuración restricciones del sistema.

Cada usuario y grupo tiene un identificador numérico que es utilizado por el sistema para diferenciar a los usuarios, conocidos como UID y GID. El sistema no reconoce diferencia entre los usuarios según el nombre del usuario, por lo tanto, si dos usuarios con nombres distintos tienen el mismo ID, el sistema Linux no podrá diferenciar quién es quién.

El usuario root y otros usuarios del sistema

Existen tres categorías de cuentas de usuarios, usuario administrativo (root), usuarios regulares y usuarios de servicio.

El usuario root tiene el control total del sistema y puede sobrepasar cualquier restricción de seguridad.

Los usuarios regulares tienen privilegios necesarios para realizar las tareas normales en Linux, como guardar archivos en su directorio personal, usar procesadores de texto, navegadores, etc. No pueden realizar la configuración del equipo o instalación de software a menos que el usuario root explícitamente lo permita.

Como los usuarios regulares no tienen privilegios administrativos, no pueden accidentalmente o intencionalmente manipular archivos de configuración, borrarlos o infectarlos con algún virus o programa trojano.

Existen servicios como samba, apache, mail, proxy, impresión, etc, que tienen su propia cuenta de usuario de servicio. Estas cuentas existen para permitir a estos programas interactuar con el computador y no necesitan de una contraseña válida.

Modelo de seguridad de Linux

Linux utiliza un grupo privado de usuarios (UPG, del inglés "User Private Group"), que permite que el manejo de grupos UNIX sea mucho más fácil. El esquema UPG no añade o cambia nada al modo tradicional UNIX de manejar grupos. Simplemente


Usuarios y grupos

ofrece una nueva convención para ello. Cada vez que se crea un nuevo usuario, por defecto, se le asigna un único grupo.

Anteriormente, los usuarios eran, por defecto, agregados a un grupo común. Esto permite que cualquier persona dentro del mismo grupo, a menos que se haya configurado de lo contrario, pueda acceder al directorio personal de otro usuario y en ocasiones modificar o borrar archivos en él.

En el modelo UPG, ningún usuario puede acceder al directorio personal de otro, y si se desea que estos usuarios compartan archivos entre sí, se los agrupa en un grupo secundario común y a este grupo se permite el acceso a un directorio específico.

Comandos para obtener información de usuarios

Puede utilizar el comando who para averiguar quienes están utilizando el sistema actualmente. La sintaxis del comando es:

who [opciones]... [ archivo | arg1 arg2 ]

El comando who tiene algunas opciones interesante:

Opción Descripción-b Indica cuándo se inició por última vez el sistema.-r Indica el nivel de ejecución actual. -H Muestra una cabecera para los campos.

También puede utilizar el comando whoami para averiguar con qué usuario ha iniciado sesión. Ejemplo:

$ whojperez pts/1 Oct 16 09:13 (192.168.6.13)plopez pts/2 Oct 16 09:49 (192.168.5.220)

$whoamijperez

El comando uptime le proporciona información de cuántos usuarios están actualmente en el sistema, así como el tiempo que el equipo ha estado funcionando y la carga de trabajo hace 1, 5 y 15 minutos. Una carga normal de trabajo depende del equipo, cantidad de procesadores, memoria, etc. Ejemplo:

# uptime 14:58:24 up 26 days, 11:26, 2 users, load average: 0.68, 0.73, 0.71

El comando id le permite obtener información del nombre de usuario, su UID, los


Usuarios y grupos

grupos a los que pertenece y el GID de cada uno de ellos. La sintaxis del comando es:

id [opcion]... [nombre_usuario]

Ejemplo:

$ iduid=64682(jperez) gid=48357(jperez) grupos=220(dba),48357(jperez)

Para mas información acerca del comando id consulte la página man del comando.

Cambiando la identidad del usuario

su: Usuario sustituto.

El comando su le permite ejecutar un shell con un UID o GID sustituto. La sentencia del comando es:

su [opcion]... [-] [usuario [arg]...]

Si se ejecuta sin opciones, le solicitará que ingrese la contraseña para el usuario root. Si la contraseña proporcionada es correcta, habrá iniciado un shell como root y podrá realizar tareas administrativas.

La opción “-", como en “su -", indica que las variables de entorno del usuario a nombre de quien estamos solicitando un shell, sean inicializadas.

Si se especifica un usuario específico, le solicitará la contraseña para ese usuario, a menos que sea usted el usuario root, a quién no se le solicita ninguna contraseña.

La opción más interesante es la opción “-c”, que ejecuta el comando dado como argumento y finaliza. Por ejemplo, para visualizar el archivo shadow como root ejecute:

$ su -c "cat /etc/shadow"

La contraseña del usuario root deberá ser proporcionada.


4Permisos de acceso a archivos y directorios

Permisos de acceso a archivos y directorios


Seguridad de archivos en Linux

Como dueño del archivo, un usuario puede configurar permisos sobre sus archivos. Estos permisos distinguen tres categorías de usuarios: el dueño del archivo, todos los usuarios que son miembros del grupo asociado al archivo (denominado también grupo dueño) pero no son el usuario dueño, y los otros, que son todos los usuarios que no son ni el dueño ni miembros del grupo dueño.

Tipos de permisos de archivos

Hay tres permisos diferentes:

1. Permiso de lectura (r por read, leer): para un archivo, esto permite que se lea su contenido. Para un directorio, esto permite que se muestren los archivos que contiene (es decir, los archivos en este directorio).

2. Permiso de escritura (w por write, escribir): para un archivo, esto permite que se modifique su contenido. Para un directorio, esto permite que un usuario agregue y/o quite archivos de este directorio, incluso si no es el dueño de esos archivos.

3. Permiso de ejecución (x por execute, ejecutar): para un archivo, esto permite su ejecución (en consecuencia, normalmente sólo los archivos ejecutables tienen activo este permiso). Para un directorio, esto permite que un usuario lo recorra (lo que significa poder ingresar a, o pasar por, ese directorio). Note que esto está separado del acceso de lectura: bien puede ser que Ud. pueda recorrer un directorio, pero no leer su contenido! Todas las combinaciones de estos permisos son posibles.

Examinando los permisos de archivos y directorios

Los comandos ls -l y ls -ld nos permiten examinar los permisos de archivos y directorios.

Los diferentes campos de salida del comando ls -l son los siguientes (de izquierda a derecha):

● El primer caracter es el tipo del archivo, contiene un guión (-) si es un archivo regular, una (d) si es un directorio, una (l) si es un enlace, una (c) si es un archivo de caracter, una (b) si es un archivo de bloques, una (p) si es una tubería o una (s) si es un archivo socket.



● Los nueve caracteres que siguen representan los permisos asociados con ese archivo. Aquí puede ver la distinción que se hace entre los diferentes usuarios para el mismo archivo:

Los primeros tres caracteres representan los derechos asociados con el dueño del archivo, los siguientes tres se aplican a todos los usuarios que pertenecen al grupo dueño del archivo, y los últimos tres se aplican a los otros usuarios que no el propietario del archivo ni pertenecen al grupo propietario. Un guión (-) significa que el permiso no está activo.

● Luego viene el número de vínculos del archivo. Posteriormente veremos que los archivos no sólo se identifican por su nombre sino también por un número (el número de i-nodo), y por lo tanto es posible que un archivo en disco tenga varios nombres.

Para un directorio, el número de vínculos tiene un significado especial, a nivel general, puede utilizar el número para identificar cuantos sub directorios contiene ese directorio.

● Luego viene el nombre del dueño del archivo y el nombre del grupo dueño.

● Finalmente, se muestra el tamaño del archivo (en bytes) y la fecha de su última modificación, seguido por último por el nombre del archivo o directorio propiamente dicho.

Cambiando permisos de archivos

chmod: Cambiar permisos (modos) de archivos.

El comando chmod (CHange MODe, Cambiar el modo) La sintaxis general es:

chmod [opciones] <cambio de modo> <archivo|dir> [archivo|dir. ...]

Existen dos formas que puede indicar los permisos:

● En octal: entonces los derechos del usuario dueño se corresponden con



números de la forma <x>00, donde <x> corresponde al permiso asignado:

– 4 para permiso de lectura

– 2 para permiso de escritura

– 1 para permiso de ejecución;

Similarmente, los derechos del grupo propietario toman la forma <x>0 y los permisos para los otros la forma <x>. Por lo tanto, todo lo que Ud. necesita hacer es sumar los permisos asignados para obtener el modo correcto.

Por lo tanto, los permisos rwxr-xr-- corresponden a 400+200+100 (permisos del dueño, rwx) +40+10 (permisos del grupo propietario, r-x) +4 (permisos de los otros, r--) = 754; de esta forma, los permisos se expresan en términos absolutos. Esto significa que los permisos previos se reemplazan incondicionalmente.

Puede utilizar una tabla como la inferior para asignar permisos, luego con práctica, mentalmente podrá asignar estos permisos.

u g oR (4) 4 4 -W (2) 2 - -X (1) 1 1 -

7 5 0

El resultado de los permisos en octal calculado en el cuadro es 750, indicando todos los permisos para el usuario propietario, lectura y ejecución para el grupo propietario y ningún permisos para los demás usuarios.

● Con expresiones: aquí los permisos se expresan con una secuencia de expresiones separadas por comas. Por lo tanto una expresión toma la forma:

[categoría]+|-|=<permisos>

La categoría puede ser una o más de:

• u (User. Usuario, permisos para el dueño)

• g (Group. Grupo, permisos para el grupo propietario)

• o (Others. Otros, permisos para los otros ).



Si no se especifica categoría alguna, los cambios se aplicarán para todas las categorías. Un signo + otorga un permiso, un - lo niega. Finalmente, el permiso es uno o más de:

• r (Read, lectura)

• w (Write, escritura)

• x (eXecute, ejecución).

Las opciones principales son:

Opción Descripción-R Cambiar los permisos recursivamente.-v Modo verboso , muestra las acciones efectuadas para cada archivo.

Ejemplos:

Quitar recursivamente el permiso de escritura para los otros sobre todos los archivos y subdirectorios del directorio /shared/docs/.

$ chmod -R o-w /shared/docs

Quitar recursivamente el permiso de escritura para el grupo y para los otros sobre todo el directorio privado/, y quitar el permiso de ejecución para los otros.

$ chmod -R og-w,o-x privado/

Asignar permiso de lectura y ejecución para todos:

$ chmod +rwx miarchivo.bash

Permisos especiales

Existen permisos especiales para archivos y directorios

● T: Sticky (pegajoso) ((t) minúscula si el permiso (x) además está asignado para otros).

● S: SGID (Set Group ID). ((s) minúscula en el grupo si el permiso (x) además está asignado).

● S: SUID (Set User ID). ((s) minúscula en el usuario si el permiso (x) además



está asignado)

El permiso Sticky en archivos no tiene función en Linux. El permiso Sticky en directorio provoca que los archivos contenidos dentro de ese directorio puedan ser borrados únicamente por el usuario propietario y por el usuario root.

El permiso SUID en directorios no tiene función en Linux. El permiso SUID en archivos permite que si el archivo es ejecutable, en lugar de correr con los permisos del usuario que ejecutó el archivo, se ejecutará con los permisos del usuario propietario del archivo.

El permiso SGID en archivos permite que si el archivo es ejecutable, en lugar de correr con los permisos del grupo al que pertenece el usuario que ejecutó el archivo, se ejecutará con los permisos del grupo propietario del archivo.

El permiso SGID en directorios obliga a que los archivos que se crean por debajo del directorio, hereden el grupo propietario del directorio contenedor.

El SGID en directorios es parte del modelo de seguridad User Private Group.

Para asignar los permisos especiales en forma octal debe utilizar:

● Sticky: 1000

● SGID: 2000

● SUID: 4000

Para asignar con expresiones:

● Sticky: +t

● SUID: u+s

● SGID: g+s

Ejemplos:



Establecer sticky, lectura, escritura y ejecución para todos:

$ chmod 1777 tmp

Establecer sticky:

$ chmod +t tmp

Establecer SGID, lectura, escritura y ejecución para el propietario, lectura y ejecución para todos:

$ chmod 2755 directorio/

Establecer SGID:

$ chmod g+s directorio/

Establecer SUID:

$ chmod u+s archivo.bash

Permisos por defecto de los archivos

Cuando se crea un archivo o directorio, éste se crea con ciertos permisos por defecto. Los permisos por defecto están dados por la configuración del umask.

El comando umask permite definir qué permisos tendrán por defecto los archivos y directorios son creados.

El comando umask sin parámetros nos devuelve dicho valor :

$ umask022

Los permisos se calculan en base al umask de la siguiente manera:

• Para nuevos directorios o archivos ejecutables (programas compilados):

777 Permisos predeterminados- 022 Se resta el valor de umask

755 Permisos permitidos

Esto significa que los permisos con los que el archivo será creado serán 755 (rwxr-x-r-x).

• Para nuevos archivos de texto:



666 Permisos predeterminados- 022 Se resta el valor de umask

644 Permisos permitidos

En el caso anterior, 666-022 = 644 , es decir , cualquier fichero que creemos con un editor ó con otros comandos serán creados con permisos 644 (rw-r--r--) .

Para cambiar la máscara , usamos el comando umask con la nueva máscara que le deseamos dar :

$ umask 077

En cuyo caso , todos los ficheros a partir del ése momento , y hasta que finalice la sesión, serán creados con sin permisos para el grupo y los otros.


5El sistema de archivos

El sistema de archivos


Sistemas de archivos ext2/ext3

Sistema de archivos Ext2: El Segundo Sistema de Archivos Extendido (Second Extended Filesystem) (su forma abreviada es Ext2FS o simplemente ext2) ha sido el sistema de archivos predeterminado de GNU/Linux por muchos años. El mismo reemplazó al Sistema de archivos extendido (Extended File System). De allí, el término segundo.

El sistema de archivos nuevo corrigió ciertos problemas y limitaciones. Ext2FS respeta las normativas usuales para los sistemas de archivos de tipo Unix. El mismo fue diseñado para evolucionar desde su concepción, a la vez de ofrecer una gran robustez y buen rendimiento.

Sistema de archivos Ext3: Como su nombre lo sugiere, el Tercer Sistema de Archivos Extendido (Third Extended File System es el sucesor de Ext2FS. El mismo es compatible con este último pero está mejorado por una característica muy interesante: journaling.

Una de las mayores fallas de los sistemas de archivos tradicionales como Ext2FS es su baja tolerancia a caídas del sistema abruptas (fallas de energía o programas que se cuelgan). En general, dichos eventos implican un examen prolongado de la estructura del sistema de archivos e intentos para corregir errores, resultando algunas veces en una corrupción aun mayor del sistema de archivos.

En consecuencia puede producirse una pérdida total o parcial de los datos grabados. El journaling responde a este problema. Para simplificar, digamos que la idea es grabar las acciones (tales como el guardar un archivo) antes de llevarlas a cabo efectivamente. Podemos comparar su funcionamiento al de un capitán de un bote que anota en su cuaderno de bitácora los eventos diarios.

El resultado, un sistema de archivos coherente siempre. Y si ocurren problemas, la verificación es muy rápida y las reparaciones eventuales, muy limitadas. Por lo tanto, Ext3FS ofrece la tecnología de sistemas de archivos con journal, a la vez que mantiene la estructura de Ext2FS asegurando una compatibilidad excelente.

Enlaces o vínculos simbólicos (blandos) y duros

Los i-nodos son, junto con el paradigma “todo es un archivo”, la parte fundamental de cualquier sistema de archivos Unix. La palabra i-nodo es una abreviación de Information NODE (NODO de Información). Los i-nodos se almacenan en el disco en una tabla de i-nodos. Existen para todos los tipos de archivos que se pueden



almacenar en un sistema de archivos, y esto incluye a los directorios, las tuberías nombradas, los archivos de modo caracter, y as sucesivamente. Los i-inodos también son la forma en la que Unix identifica de forma unívoca a un archivo.

En Unix, Ud. no identifica a un archivo por su nombre, sino por un número de i-nodo. La razón para esto es que un mismo archivo puede tener varios nombres, o no tener ninguno.

Los enlaces o vínculos

La mejor forma de comprender qué hay detrás de esta noción de vínculo es por medio de un ejemplo. Creemos un archivo (regular):

$ touch archivo1

$ ls -il archivo132555 -rw-rw-r-- 1 jperez jperez 0 sep 10 08:12 archivo1

La opción -i del comando ls imprime el número de i-nodo, que es el primer campo de la salida. Como puede ver, antes de crear el archivo a, no haba archivo alguno en el directorio.

El otro campo de interés es el tercero, que es el contador de vínculos del archivo (bueno, de hecho, del i-nodo). De hecho, el comando touch archivo1 puede separarse en dos acciones distintas:

1. Creación de un i-nodo, al cual el sistema le atribuye el número 32555, y cuyo tipo es el de un archivo regular,

2. Creación de un vínculo a este i-nodo.

Por lo tanto, el archivo archivo1 es un vínculo al i-nodo numerado 32555, y por el momento es sólo uno: el contador de vínculos muestra un 1.

Pero ahora, si ingresamos:

$ ln archivo1 archivo2

$ ls -il archivo? 32555 -rw-rw-r-- 2 jperez jperez 0 sep 10 08:12 archivo1 32555 -rw-rw-r-- 2 jperez jperez 0 sep 10 08:12 archivo2

Habremos creado otro vínculo al mismo i-nodo. Como puede ver, no hemos creado archivo alguno denominado archivo2, sino que sólo hemos agregado otro vínculo al i-nodo numerado 32555 en el mismo directorio y lo denominamos archivo2. Puede ver en la salida de ls -l que el contador de vínculos para el i-nodo ahora es 2, y ya no es 1



Ahora, si hacemos:

$ rm archivo1$ ls -il archivo232555 -rw-rw-r-- 1 jperez jperez 0 sep 10 08:12 archivo2

Vemos que incluso cuando hemos borrado el archivo original, el i-nodo todavía existe. Pero ahora el único vínculo a él es el archivo denominado archivo2.

Por lo tanto, bajo Unix un archivo tiene uno o más vínculos en uno o más directorios, los cuales pueden ser considerados el nombre del archivo. También los directorios se almacenan en i-nodos, pero su contador de vínculos, contrariamente a todos los otros tipos de archivos, es el número de subdirectorios que contiene. Existen al menos dos vínculos por directorio: el directorio en sí mismo (.) y su directorio padre (..).

Ejemplos típicos de archivos que no están vinculados (es decir, no tienen un nombre) son las conexiones de red: nunca verá el archivo correspondiente a su conexión con un sitio web en su árbol de archivos, sin importar que directorio intente. Similarmente, cuando usa una tubería en el shell, el archivo que corresponde a la misma existe, pero no está vinculado.

Los vínculos simbólicos y la limitación de los vínculos duros

Los vínculos simbólicos son archivos de un tipo particular que sólo contienen una cadena de caracteres arbitraria, que puede, o no, apuntar a un nombre de archivo existente. Cuando se menciona un vínculo simbólico en la línea de comandos o en un programa, de hecho se accede al archivo al que apunta, si es que existe. Por ejemplo:

$ echo "Hola" > miarchivo $ ln -s miarchivo mivinculo

$ ls -il total 4 169 -rw-rw-r-- 1 reina reina 6 sep 10 21:30 miarchivo 416 lrwxrwxrwx 1 reina reina 6 sep 10 21:30 mivinculo -> miarchivo

$ cat miarchivo Hola

$ cat mivinculo Hola

Puede ver que el tipo de archivo para mivinculo es 'l', por Link (Vínculo). Los derechos de acceso para un vínculo simbólico son insignificantes: siempre serán rwxrwxrwx. También puede ver que este es un archivo diferente de miarchivo, ya que su número de i-nodo es diferente. Pero se refiere al archivo miarchivo de manera simbólica, por lo tanto cuando ingresa cat mivinculo, en realidad estará imprimiendo el contenido del archivo miarchivo.



Para demostrar que un vínculo simbólico contiene una cadena de caracteres arbitraria, podemos hacer lo siguiente:

$ ln -s "No soy un archivo existente" otrovinculo

$ ls -il otrovinculo 418 lrwxrwxrwx 1 reina reina 20 sep 10 21:43 otrovinculo -> No soy un archivo existente

$ cat otrovinculo cat: otrovinculo: No existe el fichero o el directorio

Pero los vínculos simbólicos existen porque superan varias de las limitaciones de los vínculos normales ( duros ):

● No se puede crear un vínculo a un i-nodo en un directorio que está en un sistema de archivos diferente a dicho i-nodo.

● No se pueden vincular dos directorios, debido a que el contador de vínculos para un directorio tiene un uso especial como hemos visto. Pero Ud. puede hacer que un vínculo simbólico apunte a un directorio y usarlo como si realmente fuera un directorio. Por lo tanto los vínculos simbólicos son muy útiles en muchas circunstancias, y muy a menudo, la gente tiende a usarlos para vincular archivos entre sí, incluso cuando podría haberse usado un vínculo normal. No obstante, una ventaja de los vínculos normales es que Ud. no pierde el archivo si borra el original.

● Los permisos de un vínculo no pueden ser modificados, siempre será 777.

● Finalmente, si ha observado atentamente, sabrá que el tamaño de un vínculo simbólico es simplemente el tamaño de la cadena de caracteres.

Para borrar un vínculo se utiliza el comando rm, como con cualquier otro archivo.

Buscando y procesando archivos

find: busca archivos basado en criterios.

find es un utilitario de Unix muy antiguo. Su rol es buscar recursivamente uno o más directorios y encontrar archivos que se correspondan con un cierto conjunto de criterios en esos directorios. Aunque es muy útil, su sintaxis es verdaderamente compleja, y usarlo requiere cierta práctica. La sintaxis general es:

find [opciones] [directorios] [criterios] [accion]

Si no especifica directorio alguno, find buscará en el directorio corriente. Si no especifica el criterio, esto es equivalente a verdadero, por lo que se encontrarán



todos los archivos.

Las opciones, criterios y acciones son tan numerosas que solo mencionaremos algunas de cada una. Comencemos por las opciones:

Opción Descripción-xdev No extender la búsqueda a los directorios ubicados en otros

sistemas de archivos.-follow Seguir los vínculos simbólicos si apuntan a directorios. Por

defecto no los sigue.

Algunos criterios que pueden ser utilizados para la búsqueda son:

Criterio Descripción-type <tipo> Busca los archivos de un tipo dado; <tipo> puede ser uno

de: f (archivo regular), d (directorio), l (vínculo simbólico), s (socket), b (archivo en modo de bloques), c (archivo en modo caracter) p (tubería nombrada).

-name <patron> Encontrar los archivos cuyo nombre se corresponde con el <patron> dado. Con esta opción, se trata a <patron> como un patrón de englobamiento del shell.

-iname <patron> Como -name, pero sin distinguir mayúsculas/minúsculas.-mtime <n> Encontrar los archivos a los que se han modificado hace <n>

días. También puede especificar +<n> o -<n>, en cuyo caso la búsqueda se hará para los archivos modificados antes de n días o de <n> días hasta ahora respectivamente.

-newer <archivo> Encontrar los archivos que han sido modificados más recientemente que el archivo <archivo>.

Existen muchas otras pruebas, debe referirse a la página man para más detalles.

Para combinar las pruebas, Ud. puede utilizar uno de:

● <c1> -a <c2>: Verdadero si tanto <c1> como <c2> son verdaderas; -a está implícito, por lo tanto puede ingresar <c1> <c2> <c3> ... si quiere que todas las pruebas <c1>, <c2>, ... sean verdaderas.

● <c1> -o <c2>: Verdadero si <c1> o <c2> o ambos son verdaderos. Note que -o tiene una precedencia menor que -a, por lo tanto si desea, por ejemplo, los archivos que verifican los criterios <c1> o <c2> y verifican el criterio <c3>, tendrá que usar paréntesis y escribir ( <c1> -o <c2> ) -a <c3>. Debe escapar



(desactivar) los paréntesis, ya que si no lo hace ¡el shell los interpretará!

● -not <c1>: Invertir la prueba <c1>, por lo tanto -not <c1> es verdadero si <c1> es falso.

Finalmente, puede especificar una acción para cada archivo encontrado. Las acciones más usadas frecuentemente son:

Acción Descripción-print Simplemente imprime el nombre de cada archivo en la

salida estándar. Esta es la acción predeterminada si Ud. no especifica acción alguna.

-ls Muestra en la salida estándar el equivalente de ls -ilds para cada archivo que encuentra.

-exec <comando> Ejecutar el comando <comando> sobre cada archivo encontrado. La línea de comandos <comando> debe terminar con un ;, que deberá desactivar para que el shell no lo interprete; la posición del archivo se representa con {}.

-ok <comando> Igual que -exec pero pedir confirmación para cada comando.

Ejemplos:

Digamos que quiere encontrar todos los directorios en /usr/share. Entonces ingresará:

$ find /usr/share -type d

Suponga que tiene un servidor HTTP, todos sus archivos HTML están en /var/www/html, que coincide con su directorio corriente. Ud. desea encontrar todos los archivos que no se modificaron en el último mes. Debido a que tiene páginas de varios autores, algunos archivos tienen la extensión html y otros la extensión htm. Desea mover estos archivos en el directorio /var/www/obsolete . Entonces ingresará:

$ find $ -name "*.htm" -o -name "*.html" $ -a -mtime +30 -exec mv {} \ /var/www/obsolete \;

Está bien, este es uno un poco complejo y requiere una pequeña explicación. El criterio es este: $ -name "*.htm" -o -name "*.html" $ -a -mtime +30 que hace lo que queremos: Encuentra todos los archivos cuyos nombres terminan con .htm o con .html \(



-name "*.htm" -o -name "*.html" \) , y (-a) que no han sido modificados en los últimos 30 días, lo que es más o menos un mes (-mtime +30).

Note los paréntesis, aquí son necesarios, porque -a tiene una precedencia mayor. Note también que los paréntesis están desactivados para el shell.

Y finalmente, está el comando a ejecutar para cada uno de los archivos: -exec mv {} /var/www/obsolete \; Aquí también, tiene que desactivar el ; para el shell, ya que de no ser así el shell lo interpretaría como un separador de comandos. Si no lo hace, find se quejará que le falta un argumento a -exec.

bzip2 y gzip: comandos de compresión de datos

Al principio, bzip2 había sido escrito como un reemplazo de gzip. Sus relaciones de compresión generalmente son mejores, pero por otra parte, toma más memoria. La razón por la cual todavía está aquí gzip es que todavía es más usado que bzip2.

Ambos comandos tienen una sintaxis similar:

gzip [opciones] [archivo(s)] gunzip [opciones] [archivo(s)]

bzip2 [opciones] [archivo(s)] bunzip2 [opciones] [archivo(s)]

Si no se especifica un nombre de archivo, tanto gzip como bzip2 esperarán datos de la entrada estándar y enviarán los resultados a la salida estándar. Por lo tanto, puede usar ambos programas en tuberías. También ambos programas tienen un conjunto de opciones en común:

Opción Descripción-1 .. -9 Configuran el nivel de compresión. A mayor número, mejor

compresión, pero mejor también significa más lenta. -d Descomprimir el(los) archivo(s). Esto es equivalente a usar gunzip

o bunzip2. -c Volcar el resultado de la compresión/descompresión de los archivos

dados en la línea de comandos a la salida estándar.

Ahora, algunos ejemplos. Digamos que quiere comprimir todos los archivos que terminan con .txt en el directorio actual usando bzip2, entonces usará:

$ bzip2 -9 *.txt



Los archivos quedarán con un nombre que termina en .bz2.

$ gzip -9 *.txt

Los archivos quedarán con un nombre que termina en .gz.

Para descomprimir los archivos utilice los comandos bunzip2 y gunzip respectivamente.

También existen otros utilitarios de compresión para GNU/Linux tales como zip, arj o rar.

El comando zip

El comando zip también es muy utilizado. La sintaxis del comando zip es la siguiente:

zip [opciones ...] [archivo_zip archivo1 archivo2 ... ]

Para comprimir archivos con el comando zip ejecute:

$ zip archivo.zip archivo1 archivo2 archivo3

Para comprimir todo un directorio ejecute el comando:

$ zip -r archivo.zip directorio

Para listar el contenido de un archivo zip utilice el comando:

$ unzip -l archivo.zip

Para descomprimir un archivo ejecute:

$ unzip archivo.zip

Copias de seguridad con el comando tar

Al igual que find, tar es un utilitario Unix de larga data, y como tal, su sintaxis es un poco especial. La sintaxis es:

tar [opciones] [archivos...]

Entre las opciones encontramos:



Opción Descripciónc Esta opción se usa para crear nuevos paquetes (respaldos) tar.x Esta opción se usa para extraer los archivos de un paquete tar

existente. t Listar los archivos de un paquete tar existente.v Esto simplemente listará los archivos mientras se agregan o se

extraen de un paquete, o, en conjunción con la opción t (ver arriba), imprime un listado largo de archivo en vez de uno corto.

f <archivo> Crear, extraer o listar los archivos del paquete <archivo>. Si <archivo> es un dispositivo de cinta, como /dev/st0, se listará el contenido del medio. Si el parámetro archivo es - (un guión, la entrada o la salida (dependiendo de si está creando un archivador o extrayendo de uno) será asociado con la entrada estándar o la salida estándar.

z Le dice a tar que el paquete a crear debe comprimirse con gzip, o que el paquete del que se quiere extraer está comprimido con gzip.

j Le dice a tar que el paquete a crear debe comprimirse con bzip2, o que el paquete del que se quiere extraer está comprimido con bzip2.

p Cuando se extraen archivos de un paquete, preservar todos los atributos del archivo, incluyendo pertenencia, último tiempo de acceso, y así sucesivamente. Muy útil para los volcados del sistema de archivos.

Ejemplos:

Hace una copia de seguridad de todos los archivos del directorio personal de jose al archivo /tmp/backup_home.tar:$ tar cvf /tmp/backup_home.tar /home/jose

Lista el contenido de la copia de seguridad:

$ tar tvf /tmp/backup_home.tar

Restaura la copia de seguridad:

$ tar xvf /tmp/backup_home.tar

También es posible restaurar tan solo algunos archivos específicos de la copia de seguridad, para ello, debe especificar como un argumento más al comando tar x el



nombre del archivo y su ruta, así como se muestra en el comando tar t. Por ejemplo:

$ tar xvf /tmp/backup_home.tar home/jose/miarchivo.txt

La ubicación donde los archivos son restaurados depende de el comando con el que fueron salvados los archivos. Si se utilizó una ruta absoluta para especificar la lista de archivos, se restauran en su ubicación original, si se utilizó una ruta relativa para especificar la lista de archivos, se restaurarán en una ruta a partir del directorio actual.

El Linux por defecto remueve la raíz (/) de los archivos especificados con ruta completa.

Nombres de archivos comprimidos comunes y programas asociados

Al obtener de Internet o recibir un archivo que debe ser descompactado en Linux, identifique el programa a utilizar según el nombre del archivo:

Nombre Descripción.gz Archivo comprimido con gzip..bz2 Archivo comprimido con bzip2..tar.gz o .tgz Empaquetado con tar y comprimido con gzip. Utilice gunzip para

descomprimir el archivo, luego el comando tar, o utilice tar con la opción z para realizar ambos pasos de una sola vez.

.tar.bz2 Empaquetado con tar y comprimido con gzip2. Utilice bunzip2 para descomprimir el archivo, luego el comando tar, o utilice tar con la opción j para realizar ambos pasos de una sola vez.

.zip Archivo comprimido con zip.

.Z Comprimido con el comando compress. Utilice el comando uncompress para descomprimirlo. Generalmente no se instala por defecto en Linux debido a su pobre habilidad de compresión.


6El editor vi

El editor vi

El editor vi

Ejecutar vi

El comando vi es utilizado editar archivos de texto. Para ejecutar vi, simplemente tiene ingresar el comando vi seguido del nombre de archivo que desea crear. Ver a una pantalla con una columna de tildes (~) en el lado izquierdo, vi esta ahora en modo de comando. Cualquier cosa que teclee ser a interpretado como un comando, no como texto que usted desea escribir.

Para introducir texto, tiene que teclear un comando. Los dos comandos de entrada básicos son los siguientes:

Comando Descripcióni Insertar texto a la izquierda del cursor.a Añadir texto a la derecha del cursor.

Dado que esta al comienzo de un archivo vacío, no importa cual de estos usar. Presione la tecla a o la tecla i y después teclee el siguiente texto:

Las pulgas grandes tienen pequeñas pulgas<ENTER> sobre sus espaldas para que les muerdan.<ENTER> Y las pulgas pequeñas tienen pulgas mas pequeñas<ENTER> <Esc>

Fijese que tiene que pulsar la tecla Esc para finalizar la inserción y volver al modo de comando.

Comandos de movimiento del cursor

Si bien el Linux es posible desplazarse con las teclas de dirección, es recomendado que aprenda a utilizar las siguientes teclas para mover el cursor dentro del vi:

Comando Descripciónh Mueve el cursor un espacio a la izquierda.j Mueve el cursor hacia abajo.k Mueve el cursor hacia arriba.l Mueve el cursor un espacio a la derecha.


El editor vi

Estos comandos se pueden repetir manteniendo la tecla pulsada. Intente mover el cursor por el texto ahora. Si intenta un movimiento imposible, por ejemplo, pulsar la tecla k cuando el cursor esta en la línea superior, la pantalla parpadear a momentáneamente o el terminal sonar.

Borrar texto

Comando Descripciónx Borra el caracter que hay en el cursor. D Borra toda la línea desde la posición actual del cursor.dw Borra la palabra que está delante del cursor. Puede indicar mas de una

palabra usando d<n>w, siendo <n> la cantidad de palabras que desea borrar.

dd Borra toda la línea en la que se encuentra el cursor.

Mueva el cursor a la primera línea y ubíquelo de modo que esté sobre la n. Pulse la letra x , y la n desaparecerá. Ahora pulse la letra i para cambiarse al modo de inserción y vuelva a teclear la n. Pulse Esc cuando haya terminado.

Mueva el cursor a la última línea y presione dos veces la tecla d (dd). Este comando borrara toda la línea sobre la cual está situado.

Cambiar texto

Comando Descripciónr Cambia (reemplaza) el caracter que hay en el cursor.cw Cambia toda la palabra que está por delante del cursor.

Mueva el cursor a la primera línea y ubiquelo de modo que esté sobre la letra P de la primera palabra pulgas. Pulse la letra r, y el caracter al cual desea cambiar. No necesita volver a pulsar la tecla Esc debido a que no ha entrado en modo edición.

Ahora sitúe el cursor en la segunda línea al comienzo de la palabra pequeñas. Pulse la letra c seguido de w (cw), ahora podrá cambiar toda esa palabra por la que desee. Pulse Esc cuando haya terminado.


El editor vi

Deshaciendo y rehaciendo cambios

Comando Descripciónu Deshacer la operación (undo).CTRL+r Reehacer la operación (redo).. Repetir la última acción.

Si desea deshacer algún cambio que haya realizado, presione la tecla Esc y a continuación la tecla u.

Si desea rehacer un cambio que deshizo, presione la combinación de teclas CTRL+r, o tecla Esc, luego la tecla dos puntos “:” y escriba la palabra redo.

La tecla . Puede utilizarla para repetir la última acción realizada, sea cual fuera que fué.

Grabando y saliendo

Comando Descripción:w Grabar el archivo.q Salir.q! Salir sin guardar las modificaciones.wq Guardar y salir.wq! Guardar y salir omitiendo la protección de escritura. Sólo posible para el

propietario del archivo y root.

Asegúrese de que está en modo de comando presionando la tecla Esc. Luego presione la tecla dos puntos y luego w (:w). Esto guardara el archivo en disco. El comando para salir de vi es q. Si quiere combinar el guardar y salir, utilice :wq.

Para salir sin guardar los cambios que ha realizado, presione la tecla Esc y luego :q!.

Cortando, copiando y pegando


El editor vi

Comando Descripcióncc Corta una línea y cambia a modo inserción.yy Copia una línea. Puede indicar <n>yy para copiar <n> líneas.p Pega una línea por debajo del cursor.

Otras operaciones útiles

Comando Descripcióno Letra “o” minúscula. Inserta una línea por debajo del cursor y cambia a

modo inserción.O Letra “o” mayúscula. Inserta una línea por encima del cursor y cambia a

modo inserción.A Agregar texto al final de la línea.I Agregar texto al inicio de la línea.J Unir la línea inferior con la línea en la cual está posicionada el cursor.

Buscando, reemplazando y usando de expresiones regulares

vi le permite buscar una cadena de texto en el buffer de edición.

Comando Descripción/Linux Busca hacia la derecha y abajo la siguiente instancia de la palabra

Linux.?Linux Busca hacia la izquierda y arriba la siguiente instancia de la palabra

Linux.n Repite la última búsqueda.N Repite la última búsqueda en dirección opuesta.J Unir la línea inferior con la línea en la cual está posicionada el cursor.

La cadena en el comando / or ? puede ser una expresión regular. Los caracteres especiales de una expresión regular son:


El editor vi

Búsqueda y sustituciones

vi usa el modo de comandos de ex para llevar a cabo búsquedas y sustituciones. Todos los comandos que empiezan con dos puntos son comandos en modo ex.

Los comandos de búsqueda y sustitución permiten que se usen expresiones regulares sobre un rango de líneas y sustituir la tira de caracteres que se busca. El usuario puede pedir confirmación antes de que se realice la sustitución. Para buscar y sustituir una línea utilice la siguiente sintaxis:

:<linea_inicial>,<linea_final>s/<texto_a_buscar>/<texto_de_sustitucion>/[g|c]

El significado de cada campo, en orden a partir del primero:

Comando Descripción<linea_inicial> A partir de qué numero de línea se realizará la

búsqueda. Utilice . para indicar desde la línea actual.<linea_final> Hasta qué línea se realizará la búsqueda. Utilice . para

indicar hasta la línea actual y $ para indicar a hasta el final del documento.

<texto_a_buscar> El texto que se busca.<texto_de_sustitucion> El texto que reemplazará a al texto buscado.g Realice los cambios en todas las concordancias.c Solicitar confirmación antes de efectuar un reemplazo.

Ejemplos de búsqueda y reemplazo:

Desde el inicio hasta el final, buscar y sustituir “los” por “Los”:

:1,$ s/los/Los/g

Igual al anterior, utilizando % en lugar de 1,$ para indicar “en todo el documento”:

:% s/los/Los/g

Borra el contenido de la línea actual hasta la quinta, buscando cualquier concurrencia de cualquier carácter usando expresiones regulares (^.*) y reemplazando por nada (//):

:.,5 s/^.*//g

Sustituye “los" con “Los" solicitando confirmación antes de hacer la operación:


El editor vi

:% s/los/Los/c

Borra los primeros cuatro caracteres de cada línea, buscando los primieros 4 caracteres de cada línea usando expresiones regulares (^....) y reemplazando por nada //:

:% s/^....//g


7El intérprete de comandos BASH

El intérprete de comandos BASH


GNU Bourne-Again Shell y las variables de en

Bash es un interprete de comandos que ejecuta las órdenes leídas desde la entrada estándar o desde un archivo.

Las variables de entorno son variables que se almacenan en memoria durante la ejecución del shell BASH. Los procesos tienen sus variables de entorno y el shell le permite verlas directamente con el comando echo.

Algunas variables interesantes son:

● HOME: esta variable de entorno contiene una cadena de caracteres que representa su directorio personal.

● PATH: esta variable contiene la lista de todos los directorios en los cuales el shell busca los ejecutables cuando Ud. ingresa un comando. Note que predeterminadamente, a diferencia de DOS , el shell ¡no buscará los comandos en el directorio corriente!

● USER: esta variable contiene una cadena que representa su nombre de conexión.

● UID: Contiene su identificador de usuario (UID)

● PS1: contiene la definición de su prompt. Generalmente, es una combinación de secuencias especiales. Puede leer la página man bash para más información.

● PS2: contiene la definición de su prompt secundario. El prompt secundario aparece cuando no se ha finalizado un comando.

Para hacer que el shell muestre el valor de una variable, debe anteponer al nombre de la misma un $. Aquí, el comando echo lo ayudará:

echo "Realizando copia de seguridad del directorio $HOME"tar cvf /tmp/$USER.tar $HOME

Como puede ver, el shell substituye el valor de la variable antes de ejecutar el comando. El comando anterior mostrará un mensaje indicando se está realizando una copia de seguridad, luego ejecutará la copia de seguridad con el comando tar del directorio HOME del usuario que ejecutó el comando a un archivo llamado



/tmp/<nombre_usuario>.tar.

Es posible visualizar la lista completa de variables definidas con el comando set o env.

Para definir una variable de ambiente, ésta debe ser exportada al shell, de otra forma el shell no tendrá conocimiento de la variable.

Por ejemplo, puede utilizar los siguientes comandos para modificar la variable PATH:

$ PATH=$PATH:/usr/local/bin$ export PATH

o

$ export PATH=$PATH:/usr/local/bin

Estos comandos hacen que la variable PATH tenga el mismo valor que tenía antes agregando el directorio /usr/local/sbin.

Para eliminar la definición de una variable de ambiente se ejecuta el comando unset:

$ export ORACLE_HOME=/oracle$ echo $ORACLE_HOME/oracle

$ unset ORACLE_HOME$ echo $ORACLE_HOME

$

Las variables son muy utilizadas en los scripts del shell.

Volviendo a llamar a comandos

Puede verse que con las teclas de las flechas para arriba y para abajo. Ud. puede remontarse hasta un número de comandos previamente ejecutado igual al definido en la variable de entorno HISTSIZE. Es más, el histórico es persistente de una sesión a otra, por lo que no va a perder los comandos que ingresó en una sesión previa.

Las teclas de las flechas izquierda y derecha mueven el cursor hacia la izquierda y hacia la derecha en la línea corriente, por lo que puede editar sus comandos de esta forma. Pero hay más en materia de edición: Ctrl+a y Ctrl+e, por ejemplo, lo llevarán al comienzo y al final, respectivamente, de la línea corriente.

Las teclas Backspace 3 y Supr funcionan como se espera. Un equivalente de Backspace es Ctrl+h y un equivalente de Supr es Ctrl+d. Ctrl+k borrará toda la línea



desde la posición del cursor hasta el final de la misma, y Ctrl+w borrará la palabra delante del cursor.

Ingresar Ctrl+d en una línea en blanco le hará cerrar la sesión corriente, lo cual es mucho más corto que tener que ingresar exit. Ctrl+c interrumpirá el comando en curso de ejecución, excepto si se encuentra en el proceso de edición, en cuyo caso interrumpirá la edición y lo devolverá al prompt. Ctrl+l borra la pantalla.

Finalmente, están Ctrl+s y Ctrl+q. Estas secuencias de teclas sirven, respectivamente, para suspender y reanudar el flujo de caracteres sobre una terminal. No son muy usadas, pero sin embargo, puede ocurrir que ingrese Ctrl+s por error (después de todo, s y d están muy cerca una de la otra en el teclado...). Entonces, si presiona las teclas pero no ve aparecer caracter alguno en la terminal, primero intente Ctrl+q y preste atención: aparecerán en la pantalla todos los caracteres juntos que ingresó entre el Ctrl+s no deseado y Ctrl+q.

Puede volver a ejecutar un comando por medio del uso de el caracter de admiración (!). Ejemplo:

$ ls -la /tmp$ touch /tmp/archivo$ !ls

Expansión de la linea de comandos

El completado es una funcionalidad muy útil, y todos los shells modernos (bash, inclusive) la tienen. Su rol es darle al usuario el menor trabajo posible. La mejor manera de ilustrarlo es con un ejemplo.

Suponga que su directorio personal contiene un archivo cuyo nombre es archivo_con_un_nombre_muy_largo, y Ud. quiere visualizarlo.

Suponga que Ud. también tiene en el mismo directorio otro archivo denominado archivo_texto. Ud. está en su directorio personal. Así que Ud. ingresa la secuencia siguiente:

$ less /etc/pa<TAB>

Es decir, ingresa el comando less pa y luego presiona la tecla TAB. El shell ahora extenderá la línea de comandos por Ud. completando el nombre del archivo passwd. Si ingresa el comando less /etc/ho y presiona la tecla TAB dos veces, se mostrara la lista de archivos que comienzan con ho para que pueda continuar ingresando el nombre y presionando la tecla TAB hasta que sea único:

$ less /etc/ho<TAB><TAB>



host.conf hosts hosts.allow hosts.deny hotplug/ hotplug.d/

También puede completar comandos, digitando el comienzo del comando y luego presionando TAB. Por ejemplo ingresando:

$ upt<TAB>

Completara el comando uptime.

Finalmente puede autocompletar nombres de equipos, usuarios o variables de ambiente anteponiendo los caracteres ~, @ y $ respectivamente.

Valores de retorno de los comandos

Los comandos devuelven un código de retorno 0 si el comando termina correctamente, o un número entre 1 y 255 según la razón de falla. La página del man del comando puede dar información acerca de las variables de retorno, por ejemplo, la del fsck. El código de retorno del último comando queda en una variable llamada '?', que se interroga como $?. Por ejemplo, si la ejecucion del comando ls es correcta, el valor de retorno es 0:

$ ls$ echo $?0

Si ocurre un error, el valor de retorno sera diferente de 0:$ ls /nols: /no: No such file or directory$ echo $? 1

Sobrenombres

Los sobrenombres o aliases son definiciones de sinónimos o atajos a comandos frecuentemente utilizados, por ejemplo:

$ alias ll="ls -la"

Define el alias ll, ahora al ejecutar ll, se ejecutará el comando ls -la.

Para eliminar la definición de un alias se utiliza el comando unalias.

Para mostrar los aliases definidos ejecute el comando alias sin opciones.

Para mostrar un alias específico ejecute el comando con el nombre del alias, por ejemplo:



$ alias ll

Scripts de inicialización y finalización

Existen tres ficheros en el directorio de un usuario que tienen un significado especial para el shell Bash. Estos ficheros permiten al usuario configurar el entorno de su cuenta automáticamente 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 configuración de bash.

● Archivo .bash_profile es el el mas importante de los tres. Es leído y los comandos incluidos en el, ejecutados, cada vez que el usuario entra en el sistema. Cualquier cambio hecho en este fichero no tendrá efecto hasta que salgamos y entremos en el sistema de nuevo. Una alternativa para no tener que salir del sistema es ejecutar el comando source .bash_profile.

$ cat .bash_profile# .bash_profile

# Get the aliases and functionsif [ -f ~/.bashrc ]; then. ~/.bashrcfi

# User specific environment and startup programs

BASH_ENV=$HOME/.bashrcUSERNAME=""PATH=$PATH:/usr/local/pgsql/binMANPATH=$MANPATH:/usr/local/pgsql/manPGLIB=/usr/local/pgsql/libPGDATA=/usr/local/pgsql/data

export USERNAME BASH_ENV PATH MANPATH PGLIB PGDATAumask 027

● Archivo .bashrc es leído 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 ejecución de un subshell.

$ cat .bashrc# .bashrc

# User specific aliases and functions

alias ll=”ls -la”alias rm=”rm -i”



# Source global definitionsif [ -f /etc/bashrc ]; then . /etc/bashrcfi

● Archivo .bash_logout es el fichero leído por Bash, cuando salimos del sistema. Podemos definir, por ejemplo que se borren los ficheros temporales creados en nuestra ultima sesión o registrar el tiempo que hemos estado utilizando el sistema. Si .bash_logout no existe, ningún comando sera ejecutado a nuestra salida.

$ cat .bash_logout# ~/.bash_logout

clear

Historial

El comando history nos permite visualizar la lista de comandos ejecutados previamente. Existen variables de entorno que controlan el comportamiento del historial.

● HISTSIZE: El número de comandos a recordar.

● HISTFILE: El archivo en el cual se almacena el historial, por defecto ~.bash_history.

● HISTCONTROL: Si se define a ignorespace, las líneas de comando que comienzan con espacio no se guardan en el historial. La opción ignoredups evita que comandos duplicados se guarden de forma independiente y la combinación de ambas opciones es ignoreboth.

Búsqueda de comandos previamente ejecutados

Presionando las teclas CTRL+r, podemos buscar comandos ejecutados previamente. Una vez introducido el patrón, presionando CTRL+r repetidamente iremos recuperando los comandos que concuerden con el patrón.

El comando fc puede ser utilizado para listar, recuperar y editar comandos previamente ejecutados. Opciones comunes:

Opción Descripción-l Lista los últimos comandos ejecutados.



Opción Descripción-n Edita el comando n de la lista.

Substitución de comandos

La sustitución de comandos permite que la salida de un comando sea tratada como si fuese escrita en la línea de comandos. La substitución de comandos sucede cuando es encerrado de la siguiente forma:

$(comando)

O entre comillas invertidas:

`comando`

Bash realiza la expansión ejecutando el comando y reemplazando el comando con la salida estándar del comando. Por ejemplo:

$ tar cvf /tmp/$USER.tar $(find $HOME -name *.odt)

En el ejemplo anterior, el comando find se ejecutará primero y la salida de éste será utilizado por el comando tar. De esta forma, estamos indicando a tar que haga una copia seguridad de todos los archivos .odt que pueda encontrar en el directorio HOME o cualquier subdirectorio de éste del usuario que ejecuta el comando.

En el siguiente ejemplo, se creará un archivo tar que contenga la fecha actual anexado al nombre del archivo:

$ tar cvf /tmp/$USER-$(date +%m-%d-%Y).tar $HOME

En el ejemplo anterior, el comando date es ejecutado primero y el resultado utilizado por el comando tar, de esta forma se anexa al nombre del archivo tar la fecha actual en formato MM-DD-AAAA.


8Redirecciones y tuberías

Redirecciones y tuberías


Descriptores de archivos, entrada, salida y error estándar

Cuando un programa Linux desea utilizar un archivo, primero debe abrir ese archivo. Cuando hace esto, el Linux asociará un número con el archivo. Este número, el cual es usado por el programa cuando lee o escribe a un archivo, es el descriptor de archivo.

Un programa típico abrirá tres archivos cuando inicia. Esto archivos son:

● Entrada estándar - standard input (stdin)

● Salida estándar - standard output (stdout)

● Error estándar - standard error (stderr)

La entrada estándar tiene un descriptor de archivo 0, salida estándar utiliza el 1, y el número 2 es usado por el error.

En general, estos tres descriptores están asociados con la terminal desde la cual se inició el proceso, siendo el teclado la entrada. El objetivo de las redirecciones y las tuberías es redirigir estos descriptores.

Redireccionando la entrada y la salida

Suponga, por ejemplo, que Ud. quiere una lista de los archivos que terminan en .png en el directorio imagenes. Esta lista es muy larga, por lo que Ud. desea almacenarla en un archivo para consultarla a gusto más tarde. Puede ingresar el comando siguiente:

$ ls imagenes/*.png 1> lista_de_archivos

Esto significa que la salida estándar de este comando (1) se redirecciona (>) al archivo denominado lista_de_ archivos. El operador > es el operador de redirección de la salida. Si el archivo de redirección no existe, se crea, pero si existe se sobre-escribe su contenido.

Sin embargo, el descriptor predeterminado que redirecciona el operador > es la salida estándar y no es necesario especificarla en la línea de comandos. Entonces podría haber escrito simplemente:



$ ls imagenes/*.png > lista_de_archivos

y el resultado será exactamente el mismo. Luego, puede mirar el archivo usando un paginador de archivos de texto tal como less. Imagine ahora que Ud. quiere saber cuantos de estos archivos hay. En vez de contarlos a mano, puede usar el utilitario denominado wc (Word Count, Contador de palabras) con la opción -l, que escribe en la salida estándar el número de líneas en el archivo.

Una solución es la siguiente:

$ wc -l 0 < lista_de_archivos

y esto da el resultado deseado. El operador < es el operador de redirección de la entrada, y el descriptor redirigido por defecto es el de la entrada estándar, es decir, 0, y Ud. simplemente tiene que escribir la línea:

$ wc -l < lista_de_archivos

Redireccionando el error estándar

También puede ser útil redirigir el error estándar. Por ejemplo, desea saber a cuales directorios de /etc no tiene acceso: una solución es listar este directorio recursivamente y redirigir los errores a un archivo, a la vez que no se muestra la salida estándar:

$ ls -R /etc > /dev/null 2> errores

lo que significa que se redireccionará la salida estándar (>) a /dev/null, un archivo especial donde todo lo que escribe se pierde (es decir que, como efecto secundario, no se muestra la salida estándar) y el canal de error estándar (2) se redirecciona (>) al archivo errores.

Esto es muy útil al momento de realizar copias de seguridad agendadas o automatizadas. Por ejemplo con el comando tar, usted puede crear una copia de seguridad de los archivos de su directorio personal de la siguiente forma:

$ tar cvf /tmp/$USER.tar $HOME > /tmp/$USER.log 2 > /tmp/$USER.errs

En el archivo <nombre_usuario>.log obtendrá información de qué archivos fueron salvados correctamente, y en el archivo <nombre_usuario>.errs será un registro de errores que ocurrieron durante la copia de seguridad.



Sobrescritura y agregado de las redirecciones

Cada vez que redireccionamos la salida estándar o el error estándar a un archivo, por defecto este se sobreescribe. Si no deseamos que los archivos se sobreescriban y queremos concatenar el resultado de un comando, redireccionar de la siguiente forma:

Para redireccionar stdout, utilice >>, por ejemplo:

$ ls -l > lista$ ls -l >> lista

Para redireccionar stderr, utilice 2>>, por ejemplo:

$ ls -l /root 2> lista$ ls -l /root 2>> lista

Redireccionando la salida estándar y el error estándar

Si desea que tanto los mensajes de información como los mensajes de error sean redireccionados al mismo archivo debe utilizar la siguiente sintaxis:

$ comando > archivo 2>&1

Esta forma de redirección indica programa que envíe los mensajes dirigidos al error estándar al mismo lugar que envía los mensajes salida estándar.

Por ejemplo:

$ tar cvf /tmp/$USER.tar $HOME > $USER.log.err 2>&1

Tuberías

En el mundo Linux, las tuberías (también conocidas como pipes) relacionan la salida estándar de un comando con la entrada estándar de otro comando.

Por ejemplo, existen varias opciones disponibles con el comando ls, pero ¿qué pasa si la visualización del contenido de un directorio es demasiado rápida como para verla?

Vamos a ver el contenido del directorio /etc/ con el comando:

$ ls -al /etc

¿Cómo podemos visualizar la salida antes de que desaparezca de la pantalla?



Una forma es entubando la salida a una utilidad llamada less, use la barra vertical (|) conocida como pipe para entubar comandos.

$ ls -al /etc | less

De esta manera verá el contenido de /etc/ en una pantalla a la vez.

Si desea saber cuantos archivos de tipo pdf existen en su directorio personal, puede utilizar el siguiente comando:

$ ls -l *.pdf | wc -l

La salida del comando ls muestra la lista de archivos pdf, uno por cada linea, y el comando wc -l cuenta la cantidad de lineas resultantes, obteniendo así la lista de archivos existentes.


9Filtros y procesamiento de cadenas

Filtros y procesamiento de cadenas


Concepto de filtro

Linux ofrece una amplia gama de herramientas capaces de gestionar la información contenida en ficheros de texto.

Los filtros son órdenes que operan sobre estructuras de datos (ficheros) y proporcionan como salida modificaciones sobre la entrada. Por tanto, son órdenes de gestión de la información contenida en ficheros.

Los filtros leen el fichero de entrada y escriben el resultado de su operación sobre la salida estándar. Cada orden de gestión de información o filtro realiza unos cambios propios sobre la información del fichero de entrada, que dependen del programa específico utilizado.

En general, los filtros nunca modifican el fichero de entrada, simplemente escriben el resultado en la salida estándar. Si se desea que el resultado se almacene en otro fichero deberá redireccionarse esta salida.

Existen gran variedad de filtros, desde los más sencillos que operan ligeras modificaciónes, hasta los más potentes que llevan a cabo operaciones complejas de manipulación de información, próximas a las manipulaciones de los editores de texto o de las bases de datos.

Traducción de caracteres

tr: Traduce o asigna caracteres de un archivo desde una forma a otra. Por ejemplo se puede usar tr para convertir todos los tabuladores en espacios. Este comando permite hacer un sólido manejo de caracteres con una estructura bastante sencilla. La sintaxis es:

tr [-d] [-s] [de_cadena] [a_cadena]

Opción Descripción-d Suprime los caracteres de la cadena inicial. -s Suprime las repeticiones consecutivas.

Ejemplos:

Sistituir “:” por nueva línea (line feed):



$ echo $PATH | tr ":" "\n"

Remover todos los espacios en blanco de un archivo:$ tr -d "[:space:]" /etc/hosts

Convertir todas las minúsculas en mayúsculas:

$ tr [:lower:] [:upper:]

Paginador de la salida por impresora

pr: El comando pr formatea un archivo y lo visualiza en la salida estándar, aunque el formateo se realiza pensando en la impresora. La sintaxis es:

pr [+página] [opciones] [lista_archivos]

Los nombres de la lista de archivos deben estar delimitados por espacios. Si se deja en blanco, se lee la entrada estándar.

Opción Descripción+pagina Empieza a imprimir desde la página especificada. El valor

predeterminado es 1.-columnas Especifica un número de columnas de salida. Dividiendo la

pantalla en tantas partes como indique el número.-d Hace que la salida esté a doble espacio. -nancho Numera las líneas. c es el caracter que se sitúa entre el número

de línea y la salida normal, el valor predeterminado es el tabulador, ancho es el valor del número de posiciones de caracteres + 1 que ocupa el número, el valor predeterminado es 5.

-wn Establece la longitud de la línea a n columnas. Para salida en forma de columnas el valor predeterminado es 72. Esta opción da algunos problemas.

-ln Establece la longitud de la página en n líneas. El valor predeterminado es 66. El número no puede ser inferior a 10.

-h <texto> En vez del nombre de archivo, es la cabecera que muestra por defecto, utiliza cadena como cabecera.

-t No imprime la cabecera ni el pie de página. Normalmente se imprime una cabecera y un pie de página de cinco líneas.

Ejemplos:



Imprime dos archivos en columnas separadas:

$ pr -m -t README1 README2This is the This is the 1st file. 2nd file.

Lista archivos y directorios en dos columnas con doble espaciado:

$ ls -a | pr -t -a -c2 -d

Inserta una cabecera personalizada al texto:

$ pr -h 'Instrucciones de Instalacion' README.txt | lpr

Mostradores de ficheros por porciones: tail y head

El comando tail permite visualizar el final de un archivo de texto o hacer el seguimiento del crecimiento de este. La sintaxis es:

tail [-líneas] [-f] [fichero]

Opción Descripción-lineas Es un número que representa a las líneas del archivo que se

empieza a visualizar. Si a este número le precede el signo -, el desplazamiento está relacionado con el final del archivo. Si se utiliza el +, el desplazamiento está relacionado con el comienzo del archivo. Si no se especifica nada, muestra las 10 últimas líneas.

-f Cuando se utiliza esta opción y la entrada no es estándar, tail controla el crecimiento del archivo. Esto es un bucle de salida sin fin y tiene que ser terminado con la tecla de interrupción.

El comando head muestra la porción inicial de un fichero. La sintaxis es:

head [-líneas] [fichero]

Opción Descripción-lineas Es el número de líneas a imprimirse desde el principio del

archivo. El valor predeterminado es 10.



Ejemplos:

Muestra las primeras seis líneas del archivo archivo.txt$ head -6 archivo.txt

Muestra las últimas 25 líneas del archivo archivo.txt$ tail -25 archivo.txt

Hace un seguimiento al archivo de registro debug.log$ tail -f debug.log

El comando de ordenado

sort: ordena las líneas de la entrada estándar. Tiene multitud de opciones, entre lasque podemos destacar:

Opción Descripción-n Ordenado numérico. Por defecto es alfabética.-r Orden inverso.-u Elimina las líneas duplicadas.-f Ordena sin distinguir mayúsculas y minúsculas.-b Ignora los espacios en blanco.-k pos1[,pos2] Indica la posición de las claves de ordenación. El formato de la

clave se especifica siguiendo el formato pos1[,pos2], donde el campo consiste en la parte de la línea entre pos1 y pos2 comenzando desde 1. Por tanto, para ordenar por el segundo campo, utilizaría -k 2,2. Si indica pos2 entonces se ordena a partir del segundo campo hasta el final de la línea.

Ejemplos:

Utilice el comando cat para visualizar el archivo /etc/passwd, este archivo posee campos delimitados por dos puntos “:”, cada campo tiene su significado. Haremos con el archivo las siguientes operaciones:

Ordenar el archivo alfabéticamente utilizando toda la línea como campo de ordenamiento:

$ sort /etc/passwd



Ordenar en forma inversa, utilizando el primer campo para el ordenamiento (nombre de usuario) utilizando como delimitador de campos dos puntos (:):

$ sort -t ":" -r -k 1,1 /etc/passwd

Ordenar por el tercer campo, en formato numérico y de forma inversa, utilizando como delimitador de campos dos puntos (:) :

$ sort -t ":" -nr -k 3,3 /etc/passwd

Supresión de líneas repetidas

uniq: Este comando quita las líneas que son idénticas, produciendo una sola línea de salida. El comando uniq asume que el archivo ya está ordenado puesto que las líneas que son iguales deben ser adyacentes. La sintaxis es:

uniq [opciones ...] [fichero_entrada] [fichero_salida]

El fichero_entrada se refiere al nombre del archivo que se va a leer, si no se especifica asume la estándar.

La salida es el fichero que se va a crear con el resultado. Si no se especifica es la estándar. La salida, si se especifica, no puede ser la misma que la entrada.

Opción Descripción-u Sólo muestra las líneas que no están repetidas. -d Muestra sólo las líneas que están repetidas.

Ejemplos:

Lista los nombres de todos los alumnos de la case A y la clase B, ordenando alfabéticamente y mostrando solamente las líneas repetidas:

$ cat alu_claseA alu_claseB | sort | uniq -d

Elimina los nombres repetidos del archivo alu_claseA y crea un archivo alu_claseA.uniq como resultado:

$ uniq alu_claseA > alu_claseA.uniq



El comando de selección de campos del fichero

cut: Este comando extrae campos de una lista de archivos. Los campos pueden estar definidos como posiciones de caracteres o relativamente con un separador de campo. El separador por defecto es el tabulador. La sintaxis es la siguiente:

cut [-c <caracteres> | -f <campos> ] [-d <separador> ] [-s] [lista_archivos]

Opción Descripción-c <caracteres> Muestra los caracteres especificados por los números

(posiciones) de la lista. Puede ser una lista separada por comas, un rango separado por guiones o una combinación de ambos. Por ejemplo son válidos: 1,4,5,1-4 y 1-4,5-10,10,25.

-f <campos> Muestra los campos especificados mediante los números de la lista. Los campos se distinguen por un caracter separador. Si se repite el separador varias veces seguidas, no se tratan como un separador. Para indicar la lista se hace con la misma sintaxis de los caracteres.

-d <separador> Especifica el separador de campo. Un caracter de tabulación es el valor predeterminado. El separador puede ser cualquier caracter.

-s Suprime las líneas que no tienen separador de campo.

Ejemplos:

Mostrar el primer caracter de cada línea del archivo:

$ cut -c 1 /etc/passwd

Mostrar el primer, quinto y desde el décimo a vigésimo caracter del archivo:

$ cut -c 1,5,10-20 /etc/passwd Muestra el segundo campo del archivo passwd siendo el delimitador dos puntos “:”:

$ cut -d ":" -f 2 /etc/passwd

Muestra el tercer campo de un archivo cuyos campos están separados por espacios:

$ cut -d " " -f 3 /etc/passwd

Muestra a partir del tercer campo en adelante:

$ cut -d ":" -f 2- /etc/passwd



El comando de fusión de campos de diferentes ficheros

paste: Produce una salida en forma de columnas desde uno o más archivos, donde cada archivo proporciona una columna de la salida, paste se utiliza frecuentemente con cut para reordenar columnas de un archivo. Si no se especifica nada en contra la salida es la estándar. La sitanxis es:

paste [-d <caracter>] [-s] [lista_archivos]

Opción Descripción-d <caracter> Especifica el caracter que se utiliza para delimitar cada columna. El

valor predeterminado es el tabulador. -s Pegar un archivo a la vez en lugar de en paralelo.

Ejemplos:

Suponga los siguientes archivos:

$ cat nombres JuanCarlosDavidJose

$ cat direccionesPeru y ArtigasPalma y EstrellaOliva y AlberdiEstrella y Colón Para unirlos ejecute el comando:

$ paste nombres direcciones

Juan Peru y ArtigasCarlos Palma y EstrellaDavid Oliva y AlberdiJose Estrella y Colón

Para este caso, los campos están separados por un tabulador. Para usar un caracter diferente use -d.

Para pegar líneas del mismo archivo use la opción -s:

$ paste -s Juan Carlos David Jose


10Expresiones regulares

Expresiones regulares

Expresiones regulares

Las expresiones regulares son cadenas de caracteres (unos normales y otros con significados especiales) que representan un conjunto de cadenas más complejo en forma de expresiones simples. Debido a que muchos de los caracteres que utilizan expresiones regulares tienen significados especiales en el shell es mejor encerrar la expresiones entre comillas. Las comillas simples ' son las más seguras, pero a menudo las comillas dobles " son suficientes. En los casos sencillos no es necesario que el patrón esté entrecomillado.

Búsqueda de patrones dentro de archivos

La familia grep forma un conjunto de tres utilidades para la búsqueda en ficheros de patrones regulares de caracteres.

grep|egrep|fgrep [opciones] [patron] [file] [> file.out]

Hay tres programas en la familia. grep es el primero que apareció y localiza patrones regulares con alguna particularidad. fgrep realiza una búsqueda muy rápida pero los patrones están delimitados. egrep es una forma extendida de grep que busca patrones regulares de forma completa aunque ello conlleva lentitud de proceso.

El comando grep tiene las siguientes opciones:

Opción Descripción-c Visualiza sólo el número de líneas en las que coincide el

patrón.-i No hace distinción entre mayúsculas y minúsculas al realizar

comparaciones.-l Visualiza sólo los nombres de fichero en las que coincide.-n Visualiza el número de línea antes de cada línea.-s Suprime la visualización de los mensajes de error.-v Visualiza sólo aquellas líneas en las que no coinciden con el

patrón.-w Busca el patrón como palabra.-f <archivo> Toma el patrón de fichero y no de la línea de comandos.-E Modo extendido. Permite expresiones regulares extendidas.

Los patrones utilizan expresiones regulares.

Correspondencia de principio y fin de línea

Un caracter circunflejo (^) que aparece al principio de una cadena se corresponde con el comienzo de una línea. Similarmente, el signo dólar ($) al final de una cadena se corresponde con el fin de línea. No hay ningún caracter especial que se corresponda a un salto de línea, aunque sí es posible identificar una línea vacía.

Expresión Descripción"^patron" Aparición de la palabra patron al principio de una línea del

fichero."dado$" Aparición de la palabra dado al final de una línea del fichero."^lugar$" Línea que sólo contiene la palabra lugar."^$" Una línea vacía.

Por ejemplo, para mostar las líneas que contienen el texto root en el archivo /etc/passwd utilice el comando:

$ egrep "root" /etc/passwd

Para mostrar las líneas que comienzan con el texto root en el archivo /etc/passwd utilice el comando:

$ egrep "^root" /etc/passwd

Para mostrar las líneas que terminan con lel texto bash en el archivo /etc/passwd utilice el comando:

$ egrep "bash$" /etc/passwd

Anulación del significado especial de un caracter

El caracter de barra invertida (\) delante de otro caracter anula el significado especial de este último.

Ejemplo, mostrar todos los archivos cuyos nombres comienzan con punto del resultado de ls -a:

$ ls -a | egrep "^\."

Correspondecia con cualquier caracter

El punto (.) tiene un significado especial y se corresponde con cualquier caracter (incluidos caracteres especiales, dígitos, espacios en blanco, etc.).

Ejemplos:

Expresión Descripción"a..." Aparición de una a seguida por tres caracteres cualesquiera,

precedidos y acabados por espacio (es decir, aquellas palabras de cuatro letras que comienzan con a como alla, a12%, etc.).

"a...\.log$" Líneas que acaban en una palabra de cuatro letras que empieza por a y terminan con .log.

"ÂM. $" Líneas que contienen únicamente palabras de al menos tres caracteres que empiezan por AM y acaban en espacio.

Por ejemplo, para mostar las líneas que comienzan con a y tienen exactamente cuatro caracteres en el archivo /usr/share/dict/words utilice el comando:

$ egrep â...$ /usr/share/dict/words

Conjuntos de caracteres

Los caracteres encerrados entre corchetes [ ] especifican un conjunto de caracteres que van a ser buscados. Dentro del corchete, un signo menos - entre dos caracteres especifica un rango. Notar que dicho rango tiene que ser ascendente; de lo contrario se pierde la interpretación.

Si el caracter ^ aparece entre corchetes adquiere el significado de negación del conjunto ([^]).

Expresión Descripción"[a-z]" Todas las minúsculas."[a-z]...\.log$" Líneas que acaban en una palabra de cuatro letras que

empieza por una letra de la a a la z y terminan con .log."^[â-z]" Líneas que no comiencen por letras minúsculas (que

comiencen con algo distinto de letras minúsculas)."[-ab]$" Concuerda con el caracter -, a, b al final de la línea.

Para obtener las lineas que comienzan con r o s del archivo /etc/passwd utilice el comando:

$ egrep "^[rs]" /etc/passwd

Para obtener las lineas que no comienzan con r o s del archivo /etc/passwd utilice el comando:

$ egrep "^[^rs]" /etc/passwd

Correspondencia repetida de patrones

A veces interesa buscar un patrón que se repite un número determinado de veces. Esta especificación del número de repeticiones se conoce como cierre y su formato

general es {n,m} donde n es el número mínimo de repeticiones y m el número máximo. Si falta n se toma como 1 y si falta m se toma como infinito.

Están disponibles algunas formas abreviadas que suelen utilizar casi todos los programas de manipulación de textos.

Expresión Descripción* Equivale a {0,} significando que el patrón que le precede va a ser

repetido cero o más veces.+ Equivale a {1,} significando que el patrón que le precede va a ser

repetido una o más veces.? Equivale a {0,1} significando que el patrón que le precede puede

ser repetido sólo cero o una vez.

Por ejemplo, consultando las lineas que comienzan con pe y utilizando las expresiones anteriores obtenemos:

$ cd /usr/share/dict

La siguiente expresión indica que la linea debe comenzar con el carácter p y el carácter el carácter e puede aparecer 0 o más veces:

$ egrep “^pe*$” wordsppepee

La siguiente expresión indica que la linea debe comenzar con el carácter p y el carácter el carácter e puede aparecer 1 o más veces:

$ egrep “^pe+$” wordspepee

La siguiente expresión indica que la linea debe comenzar con el carácter p y el carácter el carácter e puede aparecer 0 o una vez:

$ egrep “^pe?$” wordsppe

Grupos de caracteres

Pueden formarse grupos de caracteres cuando éstos se encierran entre paréntesis (). De esta forma se pueden tratar palabras. Dentro de grupos de caracteres puede utilizarse el caracter de barra vertical '|' para separar opciones alternativas.

Para obtener la lista de archivos o directorios que tienene permisos de lectura escritura y ejecución o lectura y ejecución para el grupo utilice el comando:

$ ls -la | egrep "^[-d]...(rwx|r-x)"

En el comando anterior se filtra el resultado del comando ls -la para mostar las líneas que comienzan con – (representando archivos) o d (representando directorios) con la expresión ^[-d], posteriormente existen tres caracteres cualesquiera indicados con la expresión ... los cuales serían los permisos para el propietario del archivo, luego deberían estar los grupos de caracteres rwx o r-x indicados con la expresión (rwx|r-x).

Buscando archivos con un patrón de texto en su contenido

Ahora que ya conoce de expresiones regulares, el comando find y el comando grep, podemos agrupar estas funciones de tal modo a encontrar archivos que contengan un texto dado.

Utilizaremos el comando find para buscar archivos regulares y ejecutaremos el comando grep en cada archivo encontrado para verificar si existe la cadena de texto buscada.

Por ejemplo:

$ find / -type f -exec grep -l "<patron>" {} \:

El comando find buscará todos los archivos regulares a partir de la raíz y pasará el resultado al comando grep, el cual solo mostrará el nombre del archivo (-l) que contenga el patrón dado.

Editores fuera de línea

Existen ocasiones en las que el uso de un editor de textos como el vi o emacs puede ser demasiado o no cumplen con lo que queremos realizar. Tal vez se tengan que hacer cambios repetitivos a archivos o tener que procesar datos de una fuente y enviarlos a otro archivo en un orden correcto o tal vez solo queremos una forma simple de hacer el trabajo desde un script o la línea de comandos. Es aquí donde entran a trabajar los editores fuera de línea y para nombrar solo 2 veremos el editor de flujo sed y el lenguaje de programación awk (por Alfred Aho, Peter Weinberg y Brian Kernighan). Lo especial de awk es que es un lenguaje con todas las letras y muy poderoso, pero en ocasiones nos facilitará tareas tediosas de procesamiento de información y por esto lo ponemos en el rango de un editor fuera de línea. Aunque esto no quiere decir que es lo único que puede hacer.

Editor de flujo sedNo es preciso detallar en demasía el uso de este editor fuera de línea dada que posee mucha similitud en su uso al editor de textos vi pero si es bueno mostrar algunas de sus funciones y usos tanto en el procesamiento desde un script o en la línea de comandos. Existen 3 casos específicos en los que se podrá usar sed.

1. Para editar archivos muy largos para editar interactivamente.

2. Para editar archivos de cualquier tamaño cuando la secuencia de comandos de edición es muy complicada para hacer el tipeado confortable en ambiente interactivo.

3. Para usar múltiples funciones globales de edición eficientemente en un solo paso

Existen diferentes formas de realizar una edición con el sed. Puede hacerse desde la línea de comando o simplemente guardándolos en un archivo para poder ser usado luego. sed lee la entrada línea a línea y realiza los cambios a estas de acuerdo a lo que se le especifique. Luego de hacer estos cambios dirige su salida hacia stdout, la cual puede ser redireccionada. El comando sed actúa en forma similar a filtros como el grep y sort pero con la diferencia que con sed se podrán crear programas mas complicados y con una mayor cantidad de funciones.

Para definir una estructura de uso del sed veremos 2 formas distintas. La primera es la utilizada en la línea de comandos a través de una canalización y que tendrá esta estructura:

comando | sed <opciones> <descripción_de_la_edición>

La segunda opción para su uso a partir de la línea de comandos:

sed -f script_de_edición <archivo>

Con la opción -f le decimos a sed que a continuación le pasaremos un archivo donde encontrara las reglas a aplicar en <archivo>. El comando sed tiene mucho que ver con el editor vi en el área de búsqueda y reemplazo donde la estructura es la siguiente:

[<linea_inicial>,<linea_final>] comando_de_edicion [argumentos]

Siendo <linea_inicial>,<linea_final> las direcciones serán reglas que el sed tendrá que encontrar en el texto, si se omitieran estas sed realizara los cambios en todas las líneas. El comando_de_edicion indica a sed los cambios que tiene que hacer.

Puede estar en un archivo guardado para ser pasado al sed con la opción -f o puede ser ejecutado directamente desde la línea de comandos.

Considere que tiene un archivo llamado passwd con 10 líneas como el siguiente:

$ cat passwdroot:x:0:0:root:/root:/bin/bashbin:x:1:1:bin:/bin:/sbin/nologindaemon:x:2:2:daemon:/sbin:/sbin/nologinadm:x:3:4:adm:/var/adm:/sbin/nologinlp:x:4:7:lp:/var/spool/lpd:/sbin/nologinsync:x:5:0:sync:/sbin:/bin/syncshutdown:x:6:0:shutdown:/sbin:/sbin/shutdownjperez:x:59106:59106:Usuario Restringido:/home/jperez:/bin/bashplopez:x:59107:59107:Usuario Restringido:/home/plopez:/bin/bashhgomez:x:59108:391:Usuario Restringido:/home/hgomez:/bin/bash

Si desea eliminar la primera línea de puede ejecutar el siguiente comando:

$ cat passwd | sed '1 d'bin:x:1:1:bin:/bin:/sbin/nologindaemon:x:2:2:daemon:/sbin:/sbin/nologinadm:x:3:4:adm:/var/adm:/sbin/nologinlp:x:4:7:lp:/var/spool/lpd:/sbin/nologinsync:x:5:0:sync:/sbin:/bin/syncshutdown:x:6:0:shutdown:/sbin:/sbin/shutdownjperez:x:59106:59106:Usuario Restringido:/home/jperez:/bin/bashplopez:x:59107:59107:Usuario Restringido:/home/plopez:/bin/bashhgomez:x:59108:391:Usuario Restringido:/home/hgomez:/bin/bash

La primera línea no fue mostrada debido a que se indico a sed que realice el comando de edición “d” sobre la línea 1.

Puede ejecutar comandos de edición directamente sobre el archivo, por ejemplo, para eliminar desde la linea 1 hasta la linea 3 puede ejecutar el siguiente comando:

$ sed '1,3 d' passwdadm:x:3:4:adm:/var/adm:/sbin/nologinlp:x:4:7:lp:/var/spool/lpd:/sbin/nologinsync:x:5:0:sync:/sbin:/bin/syncshutdown:x:6:0:shutdown:/sbin:/sbin/shutdownjperez:x:59106:59106:Usuario Restringido:/home/jperez:/bin/bashplopez:x:59107:59107:Usuario Restringido:/home/plopez:/bin/bashhgomez:x:59108:391:Usuario Restringido:/home/hgomez:/bin/bash

Tenga en cuenta que el archivo original no fue modificado, simplemente la salida mostrada en pantalla, la cual podria ser redireccionada con el carácter “>” a un nuevo archivo con las líneas modificadas o utilizando el comando de edición “w”. Por ejemplo:

$ sed '1,3 d' passwd > passwd.sed$ sed '1,3 d; w passwd.sed' passwd

Múltiples comandos de edición fueron separados por “;” en el comando anterior.

Puede invertir el orden de las líneas sobre las cuales se ejecutará el comando de edición utilizando el carácter !, por ejemplo:

$ sed '1,3! d' passwdroot:x:0:0:root:/root:/bin/bashbin:x:1:1:bin:/bin:/sbin/nologindaemon:x:2:2:daemon:/sbin:/sbin/nologin

El comando anterior elimina todas las líneas excepto la 1 a la 3.

Para eliminar la linea 1, y las líneas 8 a la 10, ejecute el siguiente comando:

$ sed '1,3 d; 8,10 d' passwdadm:x:3:4:adm:/var/adm:/sbin/nologinlp:x:4:7:lp:/var/spool/lpd:/sbin/nologinsync:x:5:0:sync:/sbin:/bin/syncshutdown:x:6:0:shutdown:/sbin:/sbin/shutdown


Con el comando de edición “s” del editor sed puede realizar búsqueda y sustitución, por ejemplo, para reemplazar el directorio home de los usuarios restringidos de /home a /rhome utilice el siguiente comando:

$ sed '1,$ s/home/rhome/' passwdroot:x:0:0:root:/root:/bin/bashbin:x:1:1:bin:/bin:/sbin/nologindaemon:x:2:2:daemon:/sbin:/sbin/nologinadm:x:3:4:adm:/var/adm:/sbin/nologinlp:x:4:7:lp:/var/spool/lpd:/sbin/nologinsync:x:5:0:sync:/sbin:/bin/syncshutdown:x:6:0:shutdown:/sbin:/sbin/shutdownjperez:x:59106:59106:Usuario Restringido:/rhome/jperez:/bin/bashplopez:x:59107:59107:Usuario Restringido:/rhome/plopez:/bin/bashhgomez:x:59108:391:Usuario Restringido:/rhome/hgomez:/bin/bash

Puede utilizar el comando de edición “p” del editor sed para mostrar las líneas indicadas, por ejemplo:

$ sed -n '1,5 p' passwdroot:x:0:0:root:/root:/bin/bashbin:x:1:1:bin:/bin:/sbin/nologindaemon:x:2:2:daemon:/sbin:/sbin/nologinadm:x:3:4:adm:/var/adm:/sbin/nologinlp:x:4:7:lp:/var/spool/lpd:/sbin/nologin

En este caso es necesario agregar la opción -n al comando sed para evitar que se muestren las líneas que no concuerdan con las líneas indicadas.

Puede utilizar expresiones regulares en lugar de números de línea para indicar la posición donde deben ejecutarse los comandos de edición. Para utilizar expresiones regulares en lugar de números de línea, utilice la siguiente sintaxis:

/expresion_regular/ comando_de_edicion [argumentos]

Por ejemplo, el siguiente comando:

$ sed '/Restringido/ s/\/bin\/bash/\/sbin\/nologin/' passwdroot:x:0:0:root:/root:/bin/bashbin:x:1:1:bin:/bin:/sbin/nologindaemon:x:2:2:daemon:/sbin:/sbin/nologinadm:x:3:4:adm:/var/adm:/sbin/nologinlp:x:4:7:lp:/var/spool/lpd:/sbin/nologinsync:x:5:0:sync:/sbin:/bin/syncshutdown:x:6:0:shutdown:/sbin:/sbin/shutdownjperez:x:59106:59106:Usuario Restringido:/home/jperez:/sbin/nologinplopez:x:59107:59107:Usuario Restringido:/home/plopez:/sbin/nologinhgomez:x:59108:391:Usuario Restringido:/home/hgomez:/sbin/nologin

Sustituye la aparición de "/bin/bash" por "/sbin/nologin" en las líneas que contengan "Restringido". Como el patrón de búsqueda y sustitución contiene el carácter / el cual es interpretado por sed como una instrucción, éste debe ser escapado usando la barra invertida (\/bin\/bash).

Existen ocasiones en las que se desea obtener partes de archivos que concuerden con un patrón determinado, por ejemplo si se desea eliminar todas las líneas de comentario de un archivo, es decir las líneas que comienzan con el carácter #, puede utilizar el siguiente comando:

$ sed -n '/^#/ d' /etc/sysctl.conf

Con la instrucción /^#/ se está indicando a sed que procese las líneas que concuerdan con la expresión regular ^#, es decir, las líneas que comienzan con el carácter “#” y con el comando de edición d se indica a sed que elimine las líneas.

Si desea eliminar las líneas que son comentario y además las líneas en blanco utilice el comando:

$ sed '/^#/ d; /^$/ d' /etc/sysctl.conf


El awkEL awk es un poderoso lenguaje de programación el cual permite crear scripts complejos de tratamiento de texto. El awk al igual que el sed lee las líneas completas para realizar sus modificaciones. Uno de los aspectos mas útiles en relación al awk es que a diferencia del "sed", awk puede dividir las líneas en campos a través de un separador de campo indicado en el script o en la línea de comandos. Si no se indica ninguno se tomara como separador de campo un espacio o tabulador. Usando la opción -F de la línea de comandos o la variable FS desde un programa hecho en awk se puede especificar un nuevo separador de campo.

Por ejemplo si lo que quisiéramos es ver los UID que aparecen en el archivo /etc/passwd primero tendríamos que saber como separar los campos. En el archivo /etc/passwd se separan por un ":". Ahora tendríamos que saber en que campo se encuentra el UID. Es en el campo numero 3, comenzando a contar como el primero de los campos. El 0 es la línea completa:

$ awk -F : '{print $3}' /etc/passwd

Como vemos lo primero que hicimos fue indicarle al awk cual seria el separador de campo "-F :", luego entre comillas le indicamos que imprima a la salida estándar el campo nº 3, '{print $3}'. De esta forma vemos los nombres contenidos en el

archivo /etc/passwd. Podríamos imprimir mas de un campo a la vez:

$ awk -F : '{print $1,$3,$4}' /etc/passwd

Podríamos además incluir texto adicional al resultado del comando, por ejemplo:

$ awk -F : '{print "Usuario:",$1,"UID:",$3,"GID",$4}' /etc/passwd

Todo el proceso gira en torno a la comparación de todas las líneas del archivo, la sintaxis es, en general, de la forma:

expresión { acción }

Si la evaluación de la expresión resulta positiva, se realiza la acción asociada.

Por ejemplo, si deseamos mostrar los usuarios del archivo /etc/passwd cuyo UID es mayor a 500 utilizaremos la siguiente sintaxis:

$ awk -F : '$3 >= 500 { print $1,$3,$4 }' /etc/passwd

Algunos de los operadores que awk puede manejar son los siguientes:

Operador Descripción < Menor que. <= Menor o igual que. == Igual a. != Diferente a. >= Mayor o igual que. > Mayor que.

Otra posibilidad es el usar expresiones regulares para efectuar la búsqueda. Por ejemplo:

$ awk -F : '/^root/ { print $0 }' /etc/passwd

Este comando mostrará toda la línea que comienza con root. Lo único que tendremos que hacer es encerrarlo entre barras "/" para que se tomen como expresión regular.

Variables del awkExisten diferentes variables integradas, que permiten llevar cuentas de distintos aspectos. Por ejemplo existe la variable NR que llevara la cuenta de los registros que mostremos. Por ejemplo supongamos que necesitamos obtener un listado largo de un directorio, pero solo queremos ver los permisos, el nombre del archivo y el número de registro que a pasado por el awk:

$ ls -l | awk '{ print NR,$1,$9}'

Existen muchas más variables en el awk que son de extrema utilidad. Por ejemplo, en el caso anterior sabíamos que el ultimo campo estaba en la posición número 9, pero ¿que ocurre si no sabemos la posición del último campo o esta varia? Para esto esta la variable NF que lleva la cuenta de la cantidad de campos de cada registro. Por ello en lugar de la anterior forma podríamos poner:

$ ls -l | awk '{ print NR,$1,$NF}'

y obtendríamos idénticos resultados. Pero un momento, aquí hay algo raro. La variable NR no tiene el signo $, en cambio la variable NF si lo tiene. Esto esta dado así para que no sea reemplazado por el awk. Por ejemplo si hubiésemos puesto la variable NF sin signo $, lo que nos esta mostrando no es el último campo, sino la cantidad de campos que ese registro tiene. Esto es, a diferencia del shell, el símbolo de dólar es utilizado para referenciar campos, no para utilizar el valor de las variables.

Las siguientes variables predefinidas son comúnmente utilizadas:

Variable DescripciónFS (Field separator). Contiene el caracter que indica a awk en qué punto

del registroacaba un campo y empieza el siguiente. Por omisión es un espacio. Se puede indicar un caracter alternativo mediante una instrucción de asignación como FS = “/”. Si se deja vacío, cada lectura se realiza dejando un caracter en cada campo.

NF (Number of fields). Contiene el número total de campos que contiene el registro que se está leyendo en cada momento.

RS (Record separator).C ontiene el caracter que indica a awk en qué punto del archivo acaba un registro y empieza el siguiente. Es “\n” por omisión.

NR (Number of record). Contiene el número de orden del registro que se estáprocesando en cada momento.

OFS (Output FS). Contiene el separador de campos para la salida generada por awk. La instrucción print inserta en la salida un caracter de separación cada vez que aparece una coma en el código.

ORS (Output RS). Contiene el caracter que awk escribirá al final de cada registro. Es“\n” por omisión.

Para redefinir una variable utilice la opción -v del awk, por ejemplo:

$ awk -v FS=”:” -v OFS=”\t” '{ print $1,$3,$4 }' /etc/passwd

El comando anterior redefine las variables predeterminadas FS y OFS indicando que el separador de campos de entrada es “:” y el separador de campos de salida es un tabulador.

Programación en awk

El awk puede ser usado no sólo en una línea. Podríamos usarlo también como cualquier otro lenguaje para realizar múltiples tareas en una línea o realizar algo antes de comenzar la lectura y otra después. Para demarcar el código se utilizan los pares BEGIN-END. Todo lo que aparece después de la palabra BEGIN, pero en el mismo renglón, se realiza antes de que comience el ciclo, es decir, antes que se procese el texto. Cualquier cosa que este después de END se realiza después de que se haya leído la última línea y cerrado el ciclo. Estas líneas tendrán que estar en un archivo que será utilizado por el awk para procesar en este ejemplo al archivo /etc/passwd. Un ejemplo seria el siguiente:

BEGIN { FS=":"}{ print "Nombre Completo:",$5 }{ print "Nombre de Usuario:",$1}{ print "UID:",$3,"GID:",$4 }{ print " " }END { print "Total de usuarios:", NR}

Este pequeño programa realizado con el vi será guardado en el archivo awk.src, el nombre se lo damos nosotros, y nos servirá para mostrar algunos datos del /etc/passwd mas detalladamente. La forma de ejecutarlo es a través del modificado "-f" donde le decimos al awk que a continuación le pasaremos un archivo con el programa que tiene que usar para procesar el /etc/passwd.

$ awk -f awk.src /etc/passwd

Otro ejemplo podría ser este que utiliza awk para verificar el estado del espacio en disco:

BEGIN { ALERTA = 70 CRITICO = 90}$5 >= ALERTA && $5 <= CRITICO { print "Atencion:",$6,"Uso:",$5"%" }$5 >= CRITICO { print "Critico:",$6,"Uso:",$5"%" }

Luego ejecute el comando:

$ df |tr -d % | awk -f /tmp/awk.src

Y obtendrá un reporte indicando los sistemas de archivos que se encuentran en estado de alerta o crítico.

11Scripts del shell

Scripts del shell

Conceptos básicos de scripts del shell

El intérprete de comandos o "shell" de Linux es también un lenguage de programación completo. La programación de shell se usa mucho para realizar tareas repetidas con frecuencia. Los desarrolladores de sistemas suelen escribir aplicaciones en el lenguaje de base del sistema operativo, gcc en el caso de Linux, por razones de rapidez y eficiencia. Sin embargo, el shell de Linux tiene un excelente rendimiento en la ejecución de "scripts" (guiones); ésta es la denominación aplicada a los programas escritos en el lenguaje del shell.

Una vez creado un archivo de script, es conveniente cambiar el modo del archivo a ejecutable, para ello ejecute el comando:

$ chmod 755 archivo.sh

Entonces para ejecutar un archivo script, introduzca la ruta al archivo. El script se ejecutará en un nuevo shell. Si desea que el script se ejecute en el shell actual en lugar de iniciar uno nuevo, ejecute el script usando punto, espacio y el nombre del script de la siguiente forma:

. archivo.sh

Como en cualquier lenguaje de programación, en bash hay una serie de caracteres y palabras reservadas que tienen un significado especial.

Los caracteres especiales más comunes

Como en cualquier lenguaje de programación, en bash hay una serie de caracteres y palabras reservadas que tienen un significado especial:

Codigo Descripción#!/bin/bash Todos los scripts de shell empiezan con esta linea, que sirve para

decirle al sistema operativo que se trata de un fichero ejecutable y que sepa cual es el intérprete que lo tiene que interpretar.

# Comentario, todo lo que haya tras él en una línea es ignorado. ; Separa dos comandos.. Seguido del nombre de un fichero, hace que el contenido de ese

fichero sea interpretado por la shell como si fuese parte del script, es como un #include de C o el comando source del bash.

' y " Las comillas dobles y simples tienen un funcionamiento distinto como se describe más abajo.

Codigo Descripción` o $() Comillas invertidas y $(), se ejecuta lo que hay entre ellos como un

comando y se sustituye su salida.\ Escapa al siguiente carácter.

• Comillas dobles: En general los caracteres especiales no son interpretados cuando están entre comillas dobles. Sin embargo algunos de ellos sí son interpretados:

– $: Esta permitido referenciar variables dentro de las comillas dobles.

– \: Se pueden escapar caracteres.

– `: Se puede realizar sustitución de comandos, esto es, ejecutar un comando y sustituir la cadena por su salida.

• Comillas simples: Dentro de las comillas simples todos los caracteres son interpretados literalmente, ninguno de los caracteres especiales conserva sus significado dentro de ellas.

• Comillas invertidas: Poner una cadena entre comillas invertidas supone ejecutar su contenido como un comando y sustituir su salida.

El comando read

Este comando tiene como propósito solicitar información al usuario. Su ejecución captura las digitaciones del usuario, hasta obtener un caracter nueva línea (tecla ENTER).. El ejemplo siguiente obtiene datos del usuario y los repite en pantalla:

clearecho "Datos del usuario."echo -n "Nombre y apellido: "read NOMBREecho -n "Cédula de identidad: "read CEDULAechoecho "Ha ingresado los siguientes datos:"echo " Nombre y apellido: $NOMBRE"echo " Cédula de Identidad: $CEDULA"

También puede usarse read para detener momentáneamente la ejecución de un programa. El siguiente ejemplo detiene la ejecución del programa hasta que se presione la tecla ENTER:

echo "Presione ENTER para continuar..."read

Test

Este comando prueba condiciones y devuelve valor cierto (0) o falso (distinto de 0) según el criterio de cierto y falso del shell; esto lo hace apto para usar en la condición de if. Tiene dos formas equivalentes

test expresión[ expresión ]

Los blancos entre la expresión y los corchetes son necesarios.

Test de archivos

Estos tests toman como argumento el nombre de un archivo y devuelven verdadero (0) o falso (1):

Prueba Descripción-e Verdadero si el archivo existe. -f Comprueba que el archivo es un archivo regular (que no es ni un

directorio, ni un dispositivo). -d Devuelve verdadero si se trata de un directorio. -h Cierto si el archivo es un enlace simbólico. -r Cierto si se tiene permiso para leer el archivo . -w Cierto si se tiene permiso para escribir el archivo. -x Cierto si se tiene permiso para ejecutar el archivo.

El siguiente ejemplo verifica si un archivo es ejecutable:

if [ -x /bin/ls ]then echo "el archivo es ejecutable"fi

Es común utilizar un archivo vacío para indicar que un proceso ya se encuentra en ejecución. Durante el inicio del proceso, se crea un archivo vacío indicando que el proceso está activo.

El siguiente ejemplo es comúnmente utilizado para verificar si un proceso ya se encuentra en ejecución consultando la existencia del archivo:if [ -e /var/run/proceso ]then echo "El proceso ya se está ejecutando"fi

Test de comparación de enteros

Toman dos valores y devuelven verdadero o falso:

Prueba Descripción-eq Igual a.-ne No es igual a. -gt Mayor que.

Prueba Descripción-ge Mayor o igual que.-lt Menor que.-le Menor o igual que.

Ejemplo:

Este script verifica la cantidad de sesiones de un usuario, si tiene mas sesiones a las establecidas, entonces se lo no se le permite el inicio de sesión. El script deberá ser llamado desde el /etc/profile:

LIMIT=2SESSIONS=`who | grep $USER | wc -l`if [ $SESSIONS -gt $LIMIT ]then echo "Usted ya tiene $SESSIONS activas” echo “No se permiten nuevos inicios de sesion" exit 0fi

Test de comparación de cadenas

Comparan dos cadenas y devuelven verdadero o falso.

Prueba Descripción= ó == Comparación de igualdad.!= Comparación de desigualdad. El operador ! se puede colocar delante

de cualquier test para negar su resultado.< y > Menor que y mayor que.

Ejemplo:

if [ "$USER" != "root" ]then echo "Usted debe ser root para ejecutar este programa"else tar cvf /dev/st0 /fi

Condicionales

Las condicionales permiten efectuar comandos basándose en el resultado de expresiones.

if [ expresion 1 ]then Bloque 1elif [ expresion 2 ]then Bloque 2else Bloque 3

fi

Este es el modelo más general con todas las opciones posibles. Si el valor de retorno de expresion 1 es 0 (verdadero), las líneas de comandos de "Bloque 1" serán ejecutadas. El resto del bloque if será ignorado en ese caso.

Si el valor de retorno de test 1 no es 0 (por tanto es falso), pero el de expresion 2 sí que es 0, entonces el "Bloque 1" no será ejecutado, mientras que el "Bloque 2" sí que será ejecutado. El "Bloque 3" será ignorado. Podemos poner tantos elif como necesitemos.

Si ni expresion 1 ni expresion 2 ni cualquier otra de otros elif que pongamos retornan 0, entonces el "Bloque 3" será ejecutado.

Usamos fi para terminar la estructura condicional. Las condiciones pueden conformarse por cualquier forma de test.

Ejemplos.

Este script verifica si un numero introducido es menor, igual o mayor a cinco.

#!/bin/bash

echo "Intrduzca un numero: "

read NUMERO

if [ $NUMERO -lt 5 ]then echo "El numero era menor que 5"elif [ $NUMERO -eq 5 ]then echo "El numero era 5"elif [ $NUMERO -gt 5 ]then echo "El numero era mayor que 5"else echo "No introdujo un numero"fi

Este script verifica si un usuario tiene acceso a un directorio dado. El script puede ejecutarse de dos formas, interactivamente si no se especifica como argumento el directorio o de forma no interactiva, indicando la ruta al directorio como primer argumento.

#!/bin/bash

# Uso del script: $0 [ruta_a_dir]

# Comprobamos la cantidad de argumentos recibidos# Si no se paso ningun argumento, ejecuta el script# en modo interactivoif [ $# -eq 0 ]then echo -n "Ingrese ruta al directorio: " read DIR # Verificamos que el usurario haya introducido # una ruta, si no, termina el programa con error. if [ -z $DIR ]

then echo "Debe introducir una ruta valida" exit 1 fielse DIR=$1fi

# Se verifica si se tiene acceso al directoriocd $DIR > /dev/null 2>&1

# Se verifica el valor de retorno del comando anteriorif [ $? -eq 0 ]then echo "Usted tiene acceso a $DIR"else echo "Usted no tiene acceso a $DIR"fi

Bucles

Los bucles en bash difieren un poco de lo que son en la mayoría de los lenguajes de programación, pero vienen a cumplir una misión similar; a solucionar el problema de "Quiero que mi script haga esto mientras se de esta condición", o "Para cada uno de los elementos siguientes, quiero que mi script haga esto otro".

Así, tenemos dos tipos de bucles diferentes en bash: for y while.

Bucles for

Este comando implementa una estructura repetitiva, en la cual una secuencia de comandos se ejecuta una y otra vez. Su sintaxis básica es la que sigue:

for VARIABLE in <Lista de valores>do Comando 1 Comando 2done

for (( inicializacion; condicion; incremento ))do Comando 1 Comando 2done

Ejemplos.

Este script obtiene información de tres usuarios, root, lp y bin.

for USER in root lp bindo finger $USERdone

Este script establece el permiso de ejecución a todos los archivos del directorio:

for FILE in $(ls *.sh)`do echo "Haciendo ejecutable el archivo $FILE" chmod 755 $FILEdone

Este script verifica si reponden 5 hosts de la red.

for I in $(seq 5)do echo "Haciendo ping a 192.168.0.$I" ping -c 1 192.168.0.$Idone

Este script es un simple contador.

for (( i=0; i<10; i++ ))do echo $idone

Bucle while

Este comando implementa una estructura repetitiva en la cual el conjunto de comandos se ejecuta mientras se mantenga válida una condición (while = mientras). La condición se examina al principio y luego cada vez que se completa la secuencia de comandos. Si la condición es falsa desde la primera vez, los comandos no se ejecutan nunca. Su sintaxis básica es la que sigue:

while [ expresion ]do Comando 1 Comando 2done

Ejemplos.

Este script realiza el comando df -k cada cinco segundos hasta que se cancele presionando CTRL+C.

while truedo df -k sleep 5done

Este script utiliza el comando expr para crear un contador que se incrementa de a uno.

CONTADOR=0while [ "$CONTADOR" -lt 10 ]do echo $CONTADOR CONTADOR=$(expr "$CONTADOR" + 1)done

Este script verifica si un usuario tiene acceso a un directorio dado. Si el usuario no introduce una ruta válida, el script vuelve a solicitar la ruta al directorio.

#!/bin/bash

# Comprobamos la cantidad de argumentos recibidos# Si no se paso ningun argumento, ejecuta el script# en modo interactivo

if [ $# -eq 0 ]then echo -n "Ingrese ruta al dir: " read DIR # Verificamos que el usurario haya introducido # una ruta, si no, vuelve a solicitar la ruta. while [ -z $DIR ] do echo -n "Ingrese ruta al directorio: " read DIR doneelse DIR=$1fi

# Se verifica si se tiene acceso al directoriocd $DIR > /dev/null 2>&1

# Se verifica el valor de retorno del comando anteriorif [ $? -eq 0 ]then echo "Usted tiene acceso a $DIR"else echo "Usted no tiene acceso a $DIR"fi

En los bucles break y continue tienen el mismo funcionamiento que en otros lenguajes. break termina el bucle y continue salta a la siguiente iteración.

Case

Este comando implementa alternativas o "casos"; elige entre múltiples secuencias de comandos la secuencia a ejecutar. La elección se realiza encontrando el primer patrón con el que aparea una cadena de caracteres.

Si bien es posible hacerlo con if, y elif, pero existe otra forma más eficiente y cómoda de hacer esto: con la estructura case. Se usa como sigue:

case $VARIABLE in valor1) Bloque 1 ;; valor2) Bloque 2 ;; . . . . *) Ultimo Bloque ;;esac

valor1 y valor2 son valores que nosotros esperamos que la variable pueda contener, y Bloque 1 y Bloque 2 son los bloques de comandos con lo que queremos que se haga en cada caso. Podemos poner tantos valores reconocibles como queramos. Los puntos son precisamente para indicar aquello. El * (asterisco) es un comodín exactamete igual que hacíamos moviéndonos entre directorios en capítulos anteriores, cualquier cosa que no haya coincidido en alguna de las de arriba

coincidirá aquí. Esto es completamente opcional.

Ejemplo. Este script permite la creación de un backup si se especifica la opción -c o –create, y lista el backup creado si se indica la opción -l, -t o --list.

if [ $# -lt 1 ]then echo "Error. Esperaba al menos un parametro" exit 1fi

case $1 in-c|--create) echo "Creando backup de $HOME" tar cvf /tmp/$USER.tar $HOME ;;-l|-t|--list) echo "Listando backup en el archivo /tmp/$USER.tar" tar tvf /tmp/$USER.tar ;;*) echo "Error de sintaxis" echo "Uso: $0 <-c|--create>" echo " $0 <-l|-t|--list>" ;;esacexit 0

Con exit salimos del script, haciendo que el valor devuelto sea 0 (éxito) o 1 (error) según los parámetros fueran reconocidos o no.

Parámetros posicionales

Es un tipo de variable de shell, almacenan los parámetros de entrada de un script. Tienen los nombres 0, 1, 2, ...y sus valores son $0, $1, $2...

La variable # contiene el número de parámetros posicionales sin contar con el 0.

La variable $ contiene el identificador del proceso bash que corrió el script.

Ejemplo:

if [ $# -eq 0 ]then echo "Debe especificar al menos un argumento" echo "Uso: $0 usuario" exit 1else ps -u $1 exit 0fi

Primero se comprueba si no se ha dado un argumento al script “procesos”, si no, se despliega un mensaje de cómo debería ejecutarse el comando y termina con un código de error. Si se ha especificado un argumento, se toma el primer parámetro posicional, el cual contiene el valor del argumento dado y se lo pasa al comando a ser ejecutado.

Scripts de ejemplo

Script utilizado para eliminar archivos mas antiguos a una semana de un directorio específicado:

#!/bin/bash

echo Bienvenido $USERecho -n "Introduzca el nombre del directorio donde desea borrar los archivos mas antiguos de una semana: "read DIRcd $DIR 2> /dev/null

# Si el valor de retorno es diferente de 0, existio un error.

case $? in0) find $DIR -type f -mtime +7 -ok rm {} \; ;;1) echo "El directorio que usted introdujo no existe" ;;esac

El siguiente script permite la realización de una copia de seguridad del directorio personal. Este script evita la ejecución simultanea del mismo trabajo de copia de seguridad y los mensajes de información y error son registrados a archivos que podrán ser consultados posteriormente.

#!/bin/bash# Definimos los permisos por defecto para los archivosumask 022

# Variables configurables por el usuario# En que directorio se almacenara la copia de seguridadBACKUPDIR=/tmp

# A que archivo se hara la copia de seguridadBACKUPFILE=$BACKUPDIR/$USER-`date +%d-%m-%Y`.tar

# El backup podria hacerse a cinta en lugar de archivo.# Para ello, comente la declaracion anterior de BACKUPFILE# y descomente la linea de abajo# BACKUPFILE=/dev/st0

# A que archivo se enviaran los mensajes de informacionLOGFILE=$BACKUPDIR/$USER.log

# A que archivo se enviaran los mensajes de errorERRFILE=$BACKUPDIR/$USER.errs

# Este archivo evita ejecucion simultanea de mas de una tarea de# copia de seguridad para el mismo usuarioRUNFILE=/tmp/$USER.run

# Inicio del scriptif [ -e "$RUNFILE" ]then echo "La copia de seguridad para el usuario $USER ya esta en ejecucion" exit 1else touch $RUNFILE echo "Haciendo copia de seguridad del directorio $HOME" tar cvf $BACKUPFILE $HOME > $LOGFILE 2> $ERRFILE if [ $? -eq 0 ]

then echo "La copia de seguridad ha finalizado sin errores" else echo "La copia de seguridad ha finalizado con errores" echo "El registro de error ha sido enviado a su direccion de correo" mail -s "Errores durante el respaldo" $USER < $ERRFILE fi rm $RUNFILEfiexit 0

12Impresión y comunicación

Impresión y comunicación

Imprimir bajo Linux

Los usuarios tienen que usar el comando lpr para imprimir un fichero. El comando lpr es responsable de preocuparse por el trabajo inicial para imprimir un fichero, pasando entonces el control a otro programa, cupsd o lpd, el demonio de las impresoras de líneas.

Este demonio le dice entonces a la impresora cómo imprimir el fichero.

Cuando lpr es ejecutado, primero copia el fichero a un cierto directorio (el directorio de spool) donde el fichero permanece hasta que cupsd/lpd lo imprime.

Esto permite que hayan múltiples trabajos a la vez en una cola.

Las sintaxis de lpr es bastante familiar:

lpr [ opciones ] [ nombre_fichero ... ]

Si no se especifica un nombre de fichero, lpr asume que la entrada será efectuada por la entrada estándar (normalmente el teclado o la salida de otro programa). Esto permite que el usuario redirija la salida de un programa al dispositivo de impresión. Por ejemplo:

$ tail /etc/hosts | lpr

El comando lpr acepta varios argumentos en la línea de comandos que permiten al usuario controlar cómo trabaja. Algunos de los argumentos más ampliamente usados son:

Opción Descripción-P <impresora> Especifica la impresora a usar.-s Crea un enlace simbólico en lugar de copiar el fichero completo al

directorio de spooling (útil para ficheros grandes).-# <numero> Eespecifica el número de copias a imprimir.

Un ejemplo de interacción con lpr podría ser algo como:

$ lpr -# 2 -sP laser1 archivo

Este comando crearía un enlace simbólico al fichero archivo en el directorio de spool de la impresora llamada laser1, donde debería ser procesado por cupsd/lpd. Además debería imprimir una segunda copia de archivo.

Viendo la cola de impresión

Para verificar los trabajos en la cola de impresión se utiliza el comando lpstat. Con la opción -R puede visualizar los trabajos de impresión en cola:

$ lpstat -R 0 hplj01-1 jperez 1024 vie 09 oct 2009 09:44:43 PYT 1 hplj01-2 plopez 2048 vie 09 oct 2009 09:44:47 PYT

Cancelando un trabajo de impresión

Otra útil característica para cualquier sistema de impresión es la capacidad de cancelar un trabajo que ha sido 'encolado' anteriormente. Para hacer esto, use el comando cancel. Por ejemplo, para cancelar el trabajo de 2 de la impresora hplj01 utilice el comando:

$ cancel hplj01-2

Es posible cancelar los trabajos de impresión propios, únicamente el usuario root puede cancelar trabajos de impresión de otros usuarios.

La variable de entorno PRINTER

Todos los comandos del sistema de impresión de Linux aceptan la opción -P. Esta opción permite que el usuario especifique que impresora usar como salida. Si un usuario no especifica la impresora a usar, entonces se asumirá que la impresora por defecto es el dispositivo de salida.

En lugar de tener que especificar la impresora a usar cada vez que se ejecuta un comando de impresión, puede configurar la variable de entorno PRINTER indicando la impresora que desea usar. Esto se hace de diferentes maneras por cada shell. Para el bash puede hacerlo con:

$ PRINTER="nombre_de_impresora"; export PRINTER

Estos comandos pueden ser situados en los scripts de inicio de sesión.

Enviar correo electrónico

Todo lo que hay que hacer es teclear “mail usuario" y escribir el mensaje.

Por ejemplo, supongamos que queremos enviar correo a un usuario que se llama sam:

$ mail samSubject: Documentacion del usuarioSolo estoy probando el sistema de correo.[Ctrl-d]

El programa mail es muy simple. Como cat, acepta texto de la entrada estándar, línea a línea, hasta que recibe un caracter de fin-de-texto como único caracter en una

línea: Ctrl-d . Así, para enviar nuestro mensaje, tuvimos que pulsar Intro y después Ctrl-d.

Usar mail es la manera más rápida de enviar correo, y es bastante útil cuando se usa con redirección de entrada y/o salida. Por ejemplo, si quisiéramos enviar por correo electrónico el fichero reporte1 a Sam, podríamos escribir

$ mail -s "Reporte Numero 1" sam < reporte1

Este comando enviaría un correo al usuario sam, el asunto del correo sería “Reporte Numero 1” y el contenido del correo sería el texto del archivo reporte1.

Leer el correo

Para leer el correo, debe ejecutar el comando:

mail

El símbolo petición de órdenes del programa mail es un “&”. Las órdenes básicas de mail son:

Opción Descripciónh Lista los mensajes recibidos.d <lista> Borra los mensajes seleccionados. La lista de mensajes

consiste en una serie de números separados por espacios, o un rango como 2-5, que equivale a 2 3 4 5.

s <lista> <archivo>

Guarda los mensajes seleccionados en el archivo indicado.

r Responder a un mensaje.q Salir y guardar los mensajes que han sido leídos y no hayan

sido borrados en un fichero llamado mbox en el HOME del usuario.

Para acceder a los mensajes guardados ejecute el comando:

$ mail -f

Un problema del comando mail es que si un mensaje es más largo que la pantalla, el programa mail no se detiene!. Habrá que guardar el mensaje en un fichero y usar more sobre él después.

Redirección de correo

También se puede tener un archivo .forward en su directorio personal. En este archivo puede especificar otra dirección de correo a la cual deberán ser reenviados

los mensajes que lleguen para usted en este sistema.

13Control de procesos y herramientas del sistema

Control de procesos y herramientas del sistema

El árbol de procesos

Al igual que con los archivos, todos los procesos que corren en un sistema GNU/Linux están organizados en forma de árbol. La raíz de este árbol es init. Cada proceso tiene un número (su PID, Process ID, Identificador de proceso), junto con el número de su proceso padre (PPID, Parent Process ID, Identificador del proceso padre).

El PID de init es 1, y también su PPID: init es su propio padre.

El comando ps es utilizado para mostrar la lista de procesos del sistema.Al enviar este comando sin un argumento se mostrarán solo los procesos iniciados por Ud. en la terminal que está utilizando:

$ psPID TTY TIME CMD5162 ttya1 00:00:00 zsh7452 ttya1 00:00:00 ps

El comando ps tiene una gran cantidad de opciones, y sólo veremos las más comunes:

Opción Descripcióna También muestra los procesos iniciados por los otros usuarios.u Muestra, para cada proceso, el nombre del usuario que lo inició y la

hora a la cual fue iniciado.x También muestra los procesos sin terminal de control alguna o con

una terminal de control diferente a la que Ud. está utilizando.w Salida amplia.-u <usuario>

Mustra los procesos de un usuario específico.

La salida de este comando está dividida en campos diferentes: el que más le interesará es el campo PID, que contiene el identificador del proceso. El campo CMD contiene el nombre del comando ejecutado.

Una forma muy común de invocar a ps es la siguiente:

$ ps aux | less

Esto le da una lista de todos los procesos que se están ejecutando corrientemente, entonces puede identificar uno o más procesos que estén causando problemas y, subsecuentemente, puede “matarlos”.

El comando pstree muestra los procesos en forma de estructura de árbol. Una

ventaja es que Ud. puede ver inmediatamente quien es el proceso padre de otro: cuando quiere eliminar toda una serie de procesos, y si son todos padres e hijos, es suficiente matar al ancestro común. Puede usar la opción -p, que muestra el PID de cada proceso, y la opción -u que muestra el nombre del usuario que inició el proceso. Como generalmente la estructura de árbol es grande, es más fácil invocar a pstree de la siguiente manera:

$ pstree -up | less

Esto le da una visión general de toda la estructura de árbol de los procesos.

Las señales

Cada proceso en Linux puede reaccionar a las señales que se le envían. La señal 15 es la señal que debe enviar a un proceso para finalizarlo normalmente. La señal 9 termina un proceso irrevocablemente, sin darle tiempo de finalizar adecuadamente. Esta es la señal que se deberá enviar a un proceso cuando el mismo está trabado o exhibe otros problemas.

Se encuentra disponible una lista completa de la señales usando el comando kill -l.

kill, killall

Estos dos comandos se usan para enviar señales a los procesos. El comando kill necesita el número de un proceso como argumento, mientras que el comando killall necesita el nombre de un comando.

Los dos comandos opcionalmente pueden recibir el número de una señal como argumento. Predeterminada-mente, ambos envían la señal 15 (TERM) a el o los procesos relevantes. Por ejemplo, si quiere matar el proceso con PID 785, Ud. ingresa el comando:

$ kill 785

Si quiere enviarle la señal 9, entonces ingresa:

$ kill -9 785

Supongamos que quiere matar un proceso del cual Ud. conoce el nombre del comando. En vez de encontrar el número de proceso usando ps, puede matar el proceso directamente:

$ killall -9 netscape

Pase lo que pase, sólo matará a sus propios procesos (a menos que Ud. sea root), por lo que no debe preocuparse acerca de los procesos “del vecino” que tienen el mismo nombre, ellos no serán afectados.

Usando el control de trabajos

Control de trabajos se refiere a la habilidad de poner procesos (esencialmente, otra palabra para programas) en background (segundo plano) y ponerlos de vuelta en foreground (primer plano). Esto es como decir, que se quiere ser capaz de ejecutar algo mientras se hacen otras cosas, pero que estén ahí otra vez cuando se les quiera decir algo o pararlos.

Los dos comandos más importantes en el shell son fg, para primer plano, y bg, para segundo plano. Para entender como funcionan, use el comando yes en el indicador del sistema.

$ yes

Esto produce el maravilloso efecto de desplazar una larga columna de yes por la parte izquierda de la pantalla, tan rápido que no se pueden seguir. Para pararlo, se podrá pulsar Ctrl-C y matarlo, pero esta vez Ud. oprimirá Ctrl-Z . Parece haberse detenido, pero habrá un mensaje antes del indicador de sistema, más o menos parecido a este:

[1]+ Stopped yes

Significa que el trabajo yes se ha suspendido en el segundo plano. Se puede hacer que siga ejecutándose tecleando fg en el indicador de sistema, que lo pondrá en primer plano otra vez. Si se desea, se pueden hacer otras cosas antes, mientras está suspendido.

Pongamos aparte el mensaje que obtuvimos del shell:

[1]+ Stopped yes

El número entre corchetes es el número de trabajo de este proceso, y se usará cuando se necesite referenciarlo específicamente. (Naturalmente, desde el momento que tengamos en ejecución múltiples trabajos, se necesita un modo de acceder a cada uno). El “+" siguiente indica que ése es el “trabajo actual" esto es, el proceso más reciente que se ha movido del primer plano al segundo.

Si se tecleara “fg", se pondrá el trabajo con el “+" en primer plano otra vez. (Más sobre esto después, cuando se discuta la ejecución de múltiples trabajos a la vez). La palabra Stopped significa que el trabajo está “parado". El trabajo no está muerto, pero actualmente no se ejecuta. Linux lo ha guardado en un estado especial de suspendido, listo para saltar a la acción cuando alguien lo solicite. Finalmente, el yes es el nombre del trabajo que se ha detenido.

Antes de seguir adelante, matemos este trabajo y lo arrancamos otra vez de forma diferente. El comando se llama kill y se usa del siguiente modo:

$ kill %1[1]+ Stopped yes$

Ese mensaje sobre el proceso que indica “parado" otra vez induce a error. Para saber

si aún está vivo (eso es, tanto en ejecución como congelado en un estado suspendido), teclee “jobs":

$ jobs[1]+ Terminated yes$

Ahora ya lo sabe: el trabajo ha terminado!.

Para enviar directamente un comando a segundo plano sin tener que detenerlo y ejecutar bg, simplemente agregue el símbolo & al final del comando. Por ejemplo:

$ find / -name "*tesis*" -ls > ls.out &

Agendando la ejecución periódica de procesos

crontab: reportar o editar su archivo cron

crontab es un comando que le permite ejecutar comandos a intervalos de tiempo regulares, con la ventaja adicional que no tiene que estar conectado al sistema y que el reporte de salida se le envía por correo electrónico.

Los intervalos se pueden especificar en minutos, horas, días, meses o días de la semana.

Dependiendo de las opciones, crontab actuará diferentemente:

crontab [-u usuario] [-e | -l | -r]crontab [-u usuario] archivo

Opción Descripción-l Mostrar su archivo cron corriente.-e Editar su archivo cron.-r Eliminar su archivo cron corriente.-u <usuario>

Aplicar una de las opciones de arriba para el usuario <usuario>. Sólo root puede hacer esto.

<archivo> Las entradas para el cron son leídas desde el archivo especificado.

Comencemos editando un cron. Si ingresa el comando:

$ crontab -e

Estará frente a su editor de texto favorito si tiene definida la variable de entorno EDITOR o la variable de entorno VISUAL, caso contrario se usará vi. Una línea de un archivo cron se compone de seis campos. Los primeros cinco campos son los intervalos de tiempo para los minutos, horas, días en el mes, meses y días en la semana. El sexto campo es el comando a ejecutar.

Las líneas que comienzan con un # se consideran como comentarios y serán ignoradas por crond (el programa que es responsable de ejecutar los archivos crontab). Aquí tiene un ejemplo de entradas cron:

# Si no quiere recibir correo electronico simplemente# "descomente" la siguiente linea# MAILTO=""## Cada Navidad, enviar un mail a los usuarios del sistema0 0 25 12 * /bin/mail -s "Feliz Navidad" [email protected] < $HOME/feliz_navidad## Borrar archivos viejos cada martes a las 17 hs...0 17 * * 2 /usr/bin/find -type f -mtime +7 -exec rm {} \; > /dev/null 2>&1## Ejecutar copias de seguridad todos los días a las 18:30 excepto domingos.30 18 * * 1-6 /usr/local/bin/user_backup.sh ## Verificar el estado de la aplicación cada 5 minutos*/5 * * * * /usr/local/bin/check_status.sh app1

Hay muchas otras maneras de especificar los intervalos aparte de las que se muestran. Por ejemplo, puede especificar un conjunto de valores discretos separados por comas (1,14,23) o un rango (1-15), o un intervalo determinado (*/5) que significa cada cinco.

Agendando procesos para su ejecución

at: programar un comando, pero solo una vez.

También podría querer ejecutar un comando un día dado, pero no regularmente. Por ejemplo, quiere que se le recuerde de una cita, hoy a las 18 horas. Ud. emplea X , y quiere que se le notifique, por ejemplo, a las 17:30 hs. que debe irse. at es lo que Ud. quiere aquí:

$ at 5:30pmat> xmessage "Hora de irse! Cita a las 6pm"CTRL-Dat> <EOT>

Se puede especificar la hora de diferentes maneras:

• now +<intervalo>: Significa eso, ahora, más un intervalo opcional. (Si no se especifica el intervalo significa ahora mismo). La sintaxis para el intervalo es <n> (minutes|hours|days|weeks|months). Por ejemplo, puede especificar now + 1 hour (dentro de una hora), now + 3 days (dentro de tres días) y así sucesivamente.

• <hora> <dia>: Especificar la fecha por completo. El parámetro <hora> es obligatorio. at es muy liberal en lo que acepta: por ejemplo, puede ingresar 0100, 04:20, 2am, 0530pm, 1800, o uno de los tres valores especiales: noon (mediodía), teatime (la hora del té, 16 hs.) o midnight (medianoche). El parámetro <dia> es opcional.

• También puede indicar una fecha específica en el formato MM/DD/AA, MM/DD/AA o MM.DD.AA.

at también acepta opciones diferentes:

Opción Descripción-l Imprime la lista de los trabajos que están programados; el primer

campo es el número de trabajo. Esto es equivalente al comando atq.-d <n> Quita el trabajo número <n> de la lista. Puede obtener los números

de los trabajos con el comando atq o con la opción anterior. Esto es equivalente al comando atrm <n>.

14Nociones básicas de red

Nociones básicas de red

Introducción a las redes IP

Una dirección IP es un número que identifica de manera lógica y jerárquica a una interfaz de red de un dispositivo (habitualmente una computadora) dentro de una red que utilice el protocolo IP.

En su version 4, una dirección IP se representa mediante un número binario de 32 bits (IPv4). 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.

Un ejemplo de representación de dirección IPv4 sería : 164.12.123.65

Domain Name System (DNS) es una base de datos distribuida y jerárquica que almacena información asociada a nombres de dominio en redes como Internet.

La asignación de nombres a direcciones IP es ciertamente la función más conocida de los protocolos DNS. Por ejemplo, si la dirección IP del sitio FTP de mercurio.linux.com.py es 200.64.128.4, la mayoría de la gente llega a este equipo especificando mercurio.linux.com.py y no la dirección IP.

El comando ping

El comando ping es una herramienta de diagnóstico para verificar la conectividad entre dos computadoras en una red. Envía paquetes ICMP con una solicitud de respuesta a una dirección IP remota y espera las respuestas ICMP.

El resultado de ping solía ser un muy buen indicador de la habilidad de una computadora para enviar paquetes IP en general. Si podías hacer ping a una computadora, también podrías hacer una conexión ftp o http. Con el advenimiento mayor de el filtrado de paquetes por cuestiones de seguridad, esto se está volviendo menos cierto. Muchos firewalls explícitamente prohíben a los paquetes de tipo ICMP bajo las bases de que,

El comando ping casi siempre es utilizado sin parámetros adicionales y terminado con un Ctrl +C. Los resultados se ven como sigue:

$ ping mercurio.linux.com.pyPING mercurio.linux.com.py (192.168.1.1) from 192.168.1.10 : 56(84) bytes of data.64 bytes from mango (192.168.1.1): icmp_seq=0 ttl=255 time=0.5 ms64 bytes from mango (192.168.1.1): icmp_seq=1 ttl=255 time=0.3 ms64 bytes from mango (192.168.1.1): icmp_seq=2 ttl=255 time=0.3 ms64 bytes from mango (192.168.1.1): icmp_seq=3 ttl=255 time=0.3 ms64 bytes from mango (192.168.1.1): icmp_seq=4 ttl=255 time=0.3 ms64 bytes from mango (192.168.1.1): icmp_seq=5 ttl=255 time=0.3 ms

--- mercurio.linux.com.py ping statistics ---6 packets transmitted, 6 packets received, 0% packet loss

round-trip min/avg/max = 0.3/0.3/0.5 ms

La salida puede dividirse en tres secciones. La primera sección, la línea empezando con la palabra "PING", muestra un vistazo del comando. La segunda sección, las líneas que empiezan con "64 bytes" muestran las respuestas obtenidas. La tercera sección, todo después de la línea "--- mercurio ping statistics ---", muestra un resumen de los resultados. En este caso, los resultados son buenos, ninguno de los paquetes fueron arrojados y todos pasaron suficientemente rápido.

$ ping 192.168.1.3PING 192.168.1.3 (192.168.1.3) from 192.168.1.114 : 56(84) bytes of data.From 192.168.1.114: Destination Host UnreachableFrom 192.168.1.114: Destination Host UnreachableFrom 192.168.1.114: Destination Host Unreachable

--- 192.168.1.3 ping statistics ---7 packets transmitted, 0 packets received, +6 errors, 100% packet loss

El resultado de este comando nos demuestra que el equipo remoto no ha podido ser alcanzado, esto puede ser por varias razones:

• El equipo remoto está apagado.

• El equipo remoto no tiene conectividad a la red por un problema de cable de red o adaptador de red.

• El equipo no tiene conectividad a la red por un error en la configuración TCP/IP.

• El equipo local no tiene la ruta para llegar al equipo remoto.

• El equipo local tiene problemas de red, pruebe hacer ping a otro equipo de la red que con seguridad está encendido y funcionando.

• El equipo local o remoto está protegido por un firewall.

Obteniendo información sobre interfaces

El comando ifconfig puede ser utilizado para configurar y mostrar información de los adaptadores de red del sistema. La configurar adaptadores de red con el comando ifconfig sólo puede ser realizada por el usuario root, sin embargo podemos utilizar el comando para obtener información útil.

El comando ifconfig acepta como argumento el nombre del dispositivo de red, si utilizamos la opción -a, se mostrará información de todos los adaptadores en el sistema:

$ /sbin/ifconfig -aeth0 Link encap:Ethernet HWaddr 00:50:BF:16:14:83 inet addr:192.168.1.114 Bcast:192.168.1.255 Mask:255.255.255.0 UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1

RX packets:4030418 errors:0 dropped:0 overruns:0 frame:0 TX packets:4765994 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:100 Interrupt:5 Base address:0xf000

lo Link encap:Local Loopback inet addr:127.0.0.1 Mask:255.0.0.0 UP LOOPBACK RUNNING MTU:16436 Metric:1 RX packets:859960 errors:0 dropped:0 overruns:0 frame:0 TX packets:859960 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:0

La interfaz lo (loopback) es una interfaz que siempre existirá y permite al computador comunicarse con sí mismo. Su dirección IP siempre es 127.0.0.1 y su máscara 255.0.0.0.

Con el comando ifconfig usted puede determinar la dirección MAC del adaptador de red, la dirección IP, la máscara de sub red, si está activa la interfaz (UP), si ha ocurrido errores o si ha habido colisiones.

Puede saber si está correctamente conectada la interfaz a la red observando los paquetes recibidos. En una red ethernet siempre existen paquetes viajando por la red, por lo tanto, al cabo de unos segundos, el contador de paquetes recibidos debería incrementar. Esto es un buen indicador de conectividad física.

Transfiriendo archivos a través de la red

El comando ftp es utilizado para transferir archivos de un sistema a otro. Para transferir archivos primero debe iniciar una sesión en el equipo remoto:

$ ftp equipo.remoto.com

$ ftp 192.168.1.1

Los comandos mas utilizados del ftp son:

• put: Copia un archivo local en el equipo remoto utilizando el tipo actual de transferencia de archivos.

Sintaxis:

put archivo_local [archivo_remoto]

– archivo_local: Especifica el archivo local que se va a copiar.

– archivo_remoto: Especifica el nombre que se asignará al archivo en el equipo remoto. Si no se especifica este parámetro, el archivo adoptará el nombre del archivo_local.

• get: Copia un archivo remoto en el equipo local utilizando el tipo actual de

transferencia de archivos.

Sintaxis:

get archivo_remoto [archivo_local]

– archivo_remoto: Especifica el archivo remoto que se va a copiar.

– archivo_local: Especifica el nombre que se asignará al archivo en el equipo local. Si no se especifica este parámetro, el archivo adoptará el nombre del archivo_remoto.

• ls, dir: Muestra una lista de todos los archivos y subdirectorios de un directorio remoto.

Sintaxis:

ls|dir [directorio_remoto] [archivo_local]

– directorio_remoto: Especifica el directorio cuyo contenido desea examinar. Si no se especifica ningún directorio, se utilizará el de trabajo actual del equipo remoto.

– archivo_local: Especifica un archivo local en el cual se guardará la lista del contenido del directorio. Si no se especifica este parámetro, el resultado aparecerá en pantalla.

• cd: Cambia el directorio de trabajo en el equipo remoto.

Sintaxis:

cd directorio_remoto

directorio_remoto: Especifica el directorio del equipo remoto al cual se desea cambiar.

• hash: Activa o desactiva la impresión del signo # para cada bloque de datos transferido. El tamaño de un bloque de datos es de 2048 bytes. De manera predeterminada, no se imprime este signo.

• binary: Establece el tipo de transferencia de archivos como binario.

Nota: FTP admite dos tipos de transferencia de archivos: ASCII e imagen binaria. Cuando se transfieran archivos ejecutables, deberá utilizarse el tipo binario. En modo binario, el archivo se transfiere byte a byte.

• ascii: Establece el tipo de transferencia de los archivos como ASCII, que es el valor predeterminado.

Nota: Cuando se transfieran archivos de texto deberá utilizarse el tipo ASCII. En modo ASCII las conversiones de caracteres al juego de caracteres estándar de la red, o desde éste, se realizan automáticamente. Por ejemplo, la conversión de los caracteres de fin de línea se efectúa según los requisitos del sistema operativo de destino.

• prompt: Activa o desactiva la aparición de un mensaje de confirmación. FTP, durante una transferencia de varios archivos, requerirá confirmación para seleccionar los archivos que va a recuperar o a almacenar. Los comandos mget o mput transferirán todos los archivos. De forma predeterminada, esta opción está activada.

• mget: Copia archivos remotos en el equipo local utilizando el tipo actual de transferencia de archivos

Sintaxis:

mget archivos_remotos [...]

archivos_remotos: Especifica los archivos remotos que se van a copiar en el equipo local.

• mput: Copia archivos locales en el equipo remoto utilizando el tipo actual de transferencia de archivos.

Sintaxis:

mput archivos_locales [...]

archivos_locales: Especifica los archivos locales que se copiarán en el equipo remoto.

• lcd: Cambia de directorio local.

Sintaxis:

lcd directorio

• Ejecución del comandos localmente: Cualquier comando ftp que ejecute precedido del signo de admiración, se ejecutará en el equipo local, por ejemplo, para mostrar el contenido del directorio local use:

!ls

Shell Seguro (ssh)

El comando ssh es un reemplazo seguro para los comandos rlogin, rsh, y telnet. Le permite iniciar sesiones y ejecutar comandos en máquinas remotas. El

shell seguro permite que la comunicación entre el cliente y el servidor sea encriptada, a diferencia de los comandos anteriormente mencionados.

Iniciar una sesión en una máquina remota con ssh que es muy parecido a utilizar el comando telnet. Para iniciar una sesión remota a una máquina llamada mercurio.linux.com.py, escriba el comando siguiente en el intérprete de comandos del shell:

$ ssh mercurio.linux.com.py

La primera vez que ejecute ssh a una máquina remota, verá un mensaje similar al siguiente:

The authenticity of host 'mercurio.linux.com.py' can't be established.DSA key fingerprint is 94:68:3a:3a:bc:f3:9a:9b:01:5d:b3:07:38:e2:11:0c.Are you sure you want to continue connecting (yes/no)?

Escriba yes para continuar. Esto le permitirá agregar el servidor en su lista de host conocidos como se muestra en el siguiente mensaje:

Warning: Permanently added 'mercurio.linux.com.py' (RSA) to the list of known hosts.

Luego, verá un indicador de comandos preguntándole por su contraseña. Después de ingresar su contraseña, se encontrará en el indicador de comandos de la máquina remota. Si no especifica un nombre de usuario, el nombre de usuario con el que se ha validado como la máquina local se validará en la máquina remota. Si quiere especificar un nombre de usuario use el comando siguiente: $ ssh [email protected]

$ ssh -l nombre_usuario mercurio.linux.com.py

El comando ssh se puede utilizar para ejecutar un comando en una máquina remota sin acceder al indicador de comandos. La sintaxis es:

ssh usuario@host comando

Por ejemplo, si quiere ejecutar el comando ls /usr/share/doc en la máquina remota penguin.example.net, escriba el comando siguiente en la línea de comandos del shell:

$ ssh mercurio.linux.com.py ls /usr/share/doc

Una vez que introduzca la contraseña correcta, visualizará el contenido del directorio /usr/share/doc, y regresará al shell de su equipo local.

Usando el comando scp

El comando scp puede ser usado para transferir archivos entre máquinas sobre una conexión encriptada y segura. Es parecido al comando rcp.

La sintaxis general para transferir el archivo local a un sistema remoto es como sigue a continuación:

$ scp archivo_local usuario@host:/ruta/

Siendo archivo_local el archivo origen local, y usuario@host:/ruta/ especifica el destino.

Para transferir un archivo local shadowman a su home en mercurio.linux.com.py, escriba en la línea de comandos (reemplace username con su nombre de usuario):

$ scp shadowman mercurio.linux.com.py:/home/jperez/docs

Esto transferirá el archivo local shadowman a /home/jperez/docs/shadowman en mercurio.linux.com.py.

Para transferir un archivo remoto a un directorio local la sintaxis sería:

$ scp mercurio.linux.com.py:/home/jperez/docs/* ./

Este comando transferirá todos los archivos del directorio /home/jperez/docs de mercurio al directorio actual en el equipo local.

La sintaxis general para transferir un archivo remoto al sistema local es como sigue:

$ scp [usuario@hostremoto|archivo_local] [usuario@host_remoto|archivo_local]

Uso del comando sftpLa utilidad sftp puede ser usada para abrir una sesión segura interactiva de FTP. Es similar a ftp excepto que ésta utiliza una conexión encriptada segura. La sintaxis general es sftp [email protected]. Una vez autentificado, podrá utilizar un conjunto de comandos similar al conjunto utilizado por el comando FTP.

LE101 - Linux Enterprise Operacional v1-5

Documents

Transcript of LE101 - Linux Enterprise Operacional v1-5