Los permisos de archivos en Linux

Extracto

@pedroruizhidalg― Cada archivo y directorio en Linux tiene asociado un conjunto de permisos de determina quiénes pueden acceder y en qué forma. Estos permisos se pueden establecer para restringir el acceso a tres entidades y de tres formas: a usted, al grupo al que perteneces y a otros ―es decir, todo el mundo―.

Descripción

Tres tipos de usuarios

Como dije en el extracto, hay tres categorías de permisos, el usuario, el grupo y otros. El propietario es quien ha creado el archivo y en Linux cualquier archivo que crees te pertenece como propietario.

Igualmente tienes perteneces a un grupo, es muy común que los usuarios se reúnan en grupos, por ejemplo: “desarrolladores”, “gráficos”, “marketing”, “dirección”, son grupos comunes en el tipo de empresas que mejor conozco.

Otros, permíteme la insistencia, es el permiso que asignamos a cualquier persona que tenga acceso a al archivo o directorio en cuestión.

permisosarchivos

Tres tipos de permisos

Existen tres tipos de permiso: Lectura, Escritura y Ejecución para cada uno de los tres tipos de usuario.

El primer tipo, Lectura, da derecho de lectura a uno de los conjuntos de usuarios. Es decir, podrías negarte a ti mismo el permiso de lectura y no el de escritura de un archivo que posees. Veamos el siguiente:

$ whoami
pedro
$ touch archivo
$ ls -l
total 0
-rw-rw-r-- 1 pedro pedro 0 oct 29 13:51 archivo
$ chmod u-r archivo
$ chmod g-r archivo 
$ chmod g-w archivo 
$ chmod o-r archivo 
$ ls -l
total 0
--w------- 1 pedro pedro 0 oct 29 13:51 archivo
$ echo "otra linea para archivo" >> archivo 
$ cat archivo 
cat: archivo: Permiso denegado

Veamos los pasos del anterior ejemplo:

  1. whoami responde a la pergunta ¿Quien soy? en Linux, es decir nos muestra el nombre de nuestro propio usuario.
  2. touch archivo crea un fichero vacío llamado archivo
  3. ls -l muestra el contenido del directorio con información ampliada. Aquí podemos comprobar cómo el propietario tiene permisos de lectura y escritura, el grupo, igualmente, lectura y escritura y otros sólo lectura.
  4. chmod u-r, elimina el permiso de lectura del usario.
  5. chmod g-r elimina el permiso de lectura del grupo.
  6. chmod g-w elimina el permiso de lectura del grupo.
  7. chmod o-r elimina el permiso de lectura de otros.
  8. ls -l, nos vuelve a mostrar los permisos. Ahora tan solo de escritura para el usuario, sin lectura.
  9. echo “otra linea para archivo” >> archivo, escribe un nuevo contenido en archivo.
  10. cat archivo muestra el archivo por la salida stándar. En esta ocasión sin éxito, ya que no tenemos permiso de lectura.

Ejecución

Por regla general yo nunca asigno los permisos a los ficheros de la forma que he indicado antes. Prefiero hacerlo con su valor numérico. Paso a explicar cómo.

$ chmod 751 archivo

Con esta orden estoy indicando lo siguiente:

  • El primer número siempre pertenece al propietario. El segundo al grupo y el tercero a otros.
  • Asigno todos los permisos al propietario.
  • Asigno al grupo los permisos de lectura y ejecución.
  • Asigno a otros el permiso de ejecución.

En la siguiente tabla os muestro el valor decimal correspondiente a su valor binario y el significado para cada grupo en concreto.

Valor binario

Valor decimal

Significado

000

0

Ningun permiso

001

1

Permiso de ejecucion

010

2

Permiso de escritura

011

3

Permiso de escritura y ejecucion

100

4

Permiso de lectura, sin escritura, sin ejecucion

101

5

Permiso de lectura y ejecucion sin escritura

110

6

Permiso de lectura y escritura sin ejecucion

111

7

Permisos de lectura, escritura y ejecucion

Epílogo

Estaré encantado de responder a vuestras cuestiones.

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública @pedroruizhidalg.pub.key

exlibri del autor
exlibri del autor
#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel

Google Inbox para gestionar mucho correo

Extracto

@pedroruizhidalg― Gestionar mucho correo se ha convertido en una tarea tan necesaria como desagradable. Seguramente os ocurrirá como a mí y recibís cientos de correos a la semana. La mayor parte de ellos totalmente inútiles, algunos de ellos interesante y pocos a los que prestar atención. Google tiene una buena solución para esto. Google Inbox.

inbox

Abreviaturas usadas

Descripción

La perfecta integración de Google Inbox con el móvil ―al menos con Android― es perfecta. Permite gestionar varias cuentas de correo, obviamente todas Gmail, con una interfaz ligera con la que puedes cambiar de usuario con un solo gesto, tanto en el navegador del equipo como en el móvil.

Ejecución

Lo primero que tienes que hacer cuando entras en Inbox es entrar al menú,, a la izquierda de Recibidos.inbox1

Tras esto entras en configuración→otros.

inbox2

Y puedes redireccionar todo el tráfico de Gmail a Inbox marcándolo como indico. Si luego no te agrada o quieres dejar de probarlo, tan solo desactiva la redirección eliminando la marca.

Inbox, viene preparado para filtrar, filtrar mucho. Por defecto todos vienen creados unos contenedores para viajes, compras, finanzas, social, notificaciones, foros, promociones y la posibilidad de crear nuevos según tu conveniencia. No obstante yo los tengo desactivado, pues prefiero que me llegue todo al área de Recibidos. Verás por qué. El tratamiento correos de inbox es tan sumamente útil que de una vez por todas vas a tener la bandeja de entrada (Recibidos) vacía.

inbox3

Cuando pases el ratón por encima de cada email aparecen los manejadores que puedes ver a la derecha. El primero es para fijar el email a Recibidos mientras no elimines la chincheta. El segundo es para posponer. Una pasada. Puedes posponerlo para una hora, para otro día, incluso para otro lugar; yo lo he probado incluso con distintas provincias, funciona de maravilla. El tercero envía el email a la bandeja de completados, sin tener que leerlo si no te apetece. El cuarto es para clasificarlo si te apetece o moverlo a otro lugar.

Siempre podrás consultar los archivos pospuestos en su bandeja correspondiente. Igualmente con completados. Que lo elimines de la bandeja de Recibidos no significa que lo hayas eliminado. En absoluto. No obstante, esto también es configurable.

Verás que bajo la bandeja de Enviados, aparece un icono de Recordatorios.

inbox4

Otra maravilla. Olvídate de enviarte correos a ti mismo para acordarte de las cosas. Esto se integrará perfectamente con tu Google Calendar. Todos los recordatorios que tú actives estarán por defecto con la chincheta en la bandeja de recibidos y perfectamente clasificados en tu calendar, tanto en el ordenador como en tu móvil.

Tienes que saber que la «gestualidad» en el móvil es distinta a la del entorno en un navegador. En el móvil cuando recibes un correo lo mandas a completado desplazándolo a la derecha. Mientras que si lo desplazas a la izquierda estarás mandándolo a Pospuestos, listo para ser programado.

Mi táctica personal es como antes dije mantener la bandeja de entrada vacía. Nunca antes lo había conseguido con tanta comodidad.

Epílogo

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública @pedroruizhidalg.pub.key

exlibri, sapere aude
exlibri, sapere aude
#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel

Comando ln para crear vínculos de archivos

Extracto

@pedroruizhidalg― Linux puede dar a un archivo más de un nombre usando la orden ln. Tal vez te interese hacer referencia a un archivo usando diferentes nombres para acceder a él desde diferentes directorios. A estos nombres adicionales se les conoce como vínculos.

Abreviaturas usadas

Descripción

La orden ln lleva dos argumentos: el nombre del archivo original y el nuevo nombre del archivo adicional. La operación ls listará ambos nombres de archivo, si bien, en realidad, físicamente ser trata de un solo archivo.

Existen dos tipos de vínculos, los vínculos simbólicos y los vínculos duros.

Ejecución

Vínculos duros:

Como forma general:

$ ln nombre-del-archivo-original nombre-añadido-del-archivo

Veamos un ejemplo práctico.

$ touch archivoOriginal
$ echo "este es el contenido del archvivo Original" > archivoOriginal 
$ cat archivoOriginal 
este es el contenido del archvivo Original
$ ln archivoOriginal otroarchivo
$ ls
archivoOriginal otroarchivo
$ cat otroarchivo 
este es el contenido del archvivo Original
$

Puede parecer que se trate de una copia, pero no lo es. Realmente estamos accediendo al mismo archivo con otro nombre. Si ahora estuviera dando clases pondría el ejemplo. Yo contesto a mi esposa cuando me llama “Pedro” y a mi hija cuando me llama “papá”, si bien yo sigo siendo el mismo. Pasemos a otra cosa:

En el ejemplo anterior he puesto en negrita lo que tenemos que teclear y he dejado en texto normal el resultado que nos ofrece el ordenador. Pasemos a explicar los pasos.

  1. Con touch archivoOriginal creamos un archivo vacío.
  2. Con la siguiente orden echo introducimos en el archivoOriginal la cadena de texto que está entre comillas.
  3. Con la orden cat comprobamos el contenido de archivoOriginal.
  4. El comando ln crea un vínculo a archivoOriginal.
  5. Mediante ls vemos que ahora disponemos de dos archivos diferentes.
  6. Con cat otroarchivo listamos su contenido y comprobamos que es idéntico al archivoOriginal.

¿Cómo estar seguros que se trata en realidad del mismo archivo?

Usando el comando ls con la opcion -li nos muestra el número de inodo que indica que en realidad apunta al mismo lugar físico.

$ ls -li
total 8
4980891 -rw-rw-r-- 2 pedro pedro 43 oct 26 19:59 archivoOriginal
4980891 -rw-rw-r-- 2 pedro pedro 43 oct 26 19:59 otroarchivo
$

Observamos en los números en negrita que se trata de idéntica localización de inodo.

Un vínculo duro puede fallar en linux si está colocado en otro directorio, esto es debido a la segmentación que puede sufrir ―de hecho sufre― el sistema de archivos.

Vínculos simbólicos

Un vínculo simbólico indica un acceso a un directorio o fichero que se encuentra en un lugar distinto dentro de la estructura de directorios. Una modificación realizada utilizando este enlace se reflejará en el original; pero, por el contrario, si se elimina el enlace, no se eliminará el auténtico. Veamos el ejemplo:

$ ln -s archivoOriginal otroarchivo
$ ls -l
total 4
-rw-rw-r-- 1 pedro pedro 43 oct 26 19:59 archivoOriginal
lrwxrwxrwx 1 pedro pedro 15 oct 26 20:47 otroarchivo -> archivoOriginal

Si otroarchivo fuera movido a otro directorio seguiría apuntando al mismo archivo de forma efectiva al archivo al que pertenece.

Comprobamos que ambos apuntan al mismo inodo.

$ ls -li
total 4
4980891 -rw-rw-r-- 1 pedro pedro 43 oct 26 19:59 archivoOriginal
4981228 lrwxrwxrwx 1 pedro pedro 15 oct 26 20:47 otroarchivo -> archivoOriginal

Una práctica interesante, sería colocar en nuestro directorio .bin, un enlace simbólico al comando whish con el nombre «donde».

La orden which busca el directorio donde se encuentra un comando determinado. Por ejemplo which php en mi sistema responde /usr/bin/php

Ejecutamos lo siguiente:

$ which which
/usr/bin/which
$ cd ~/.bin
$ ln -s /usr/bin/which donde
  1. Usamos la orden which para obtener la localización del comando which.
  2. Nos situamos en nuestro directorio de ejecuciones de scripts.
  3. Realizamos un enlace simbólico al comando which desde ~/.bin/donde

A partir de este momento siempre que tengamos bien configurado el directorio de ejecuciones de scripts, podemos acceder al comando which mediante donde.

 $ donde php
/usr/bin/php
Tux: orden ln
comando ln

Epílogo

Como truco, la práctica totalidad de los enlaces que se realizan son enlaces simbólicos.

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública @pedroruizhidalg.pub.key

#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel

Linux, comando file

linux shell bash

Extracto

@pedroruizhidalg― En ocasiones necesitamos clarificar el contenido de un directorio. En Linux todo es archivo. Es decir, el sistema operativo no necesita ni requiere las extensiones de los archivos. En otras palabras, podemos dar la extensión .mp3 a un archivo de python, o bien .txt a un archivo de sonido. Las extensiones para Linux «son cosas de humanos».

El comando file sirve para clarificar a qué tipo, o cómo se ejecuta ―qué papel juega― un archivo dentro del sistema. Bien usado puede ser una herramienta interesante.

Abreviaturas usadas

mp3― Formato de compresión digital para la transmisión rápida de archivos de audio y vídeo a través de Internet.

txt―Un archivo de texto llano, texto simple, texto plano, texto sencillo o texto pelado es un archivo informático compuesto únicamente por texto sin formato, sólo caracteres, lo que lo hace también legible por humanos. …

Descripción

El comando file determina el tipo al que pertenece un archivo. Este comando acepta la opción -f para poder leer la entrada desde un archivo. Algunas veces tenemos tal pollo formado en un directorio que esto termina por poner algo de luz en él.

$ file archivos
archivos: ASCII text
$

Ejecución

Por regla general, uso este comando de la siguiente forma:

$ ls > archivos
$ file -f archivos >> archivos
$ cat archivos
archivos
lexico.l
sintactico.tab.c
sintactico.tab.h
sintactico.y
archivos:         ASCII text
lexico.l:         UTF-8 Unicode text
sintactico.tab.c: C source, ASCII text
sintactico.tab.h: C source, ASCII text
sintactico.y:     C source, UTF-8 Unicode text
$
  1. Introducimos el listado del directorio en un archivo (al que llamo «archivo»).
  2. Ejecutamos el comando file con -f para que pueda tomar como entrada el archivo que hemos generado. Haciendo que él escriba añadiendo al archivo el análisis de tipo de los ficheros del directorio.
  3. Mostramos por la salida estándar el contenido de «archivo» y comprobamos que la primera parte corresponde a la descripción de los componentes del directorio y la segunda a su análisis de tipo.

Epílogo

 

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

9cf76-ubuntu

Clave pública @pedroruizhidalg.pub.key

#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel

Leer argumentos en scripts en bash

keep calm and #!/bin/bash

Extracto

@pedroruizhidalg― Como venimos escribiendo acerca del entorno de terminal bash sobre sus variables, las posibilidades del entorno y preparar nuestro sistema para ejecutar scripts incluso con algún ejemplo sobre criptografía en este artículo vamos a ver la forma de recibir argumentos desde la linea de comandos para ser leídos en un script bash.

Abreviaturas usadas

Descripción

Como describimos en el artículo sobre bash  los comandos en Linux por regla general se ajustan al siguiente esquema.

$ Orden Opciones Argumentos

También por regla general los argumentos en Linux suelen ser nombres de archivos. Pero nosotros podemos crear scripts conforme a nuestros gustos, apetencias, forma de trabajar…

Ejecución

Una vez creado ambiente para ejecutar scripts, a modo de ejemplo vamos a crear un script para copiar archivos a un directorio que vamos a crear para tener un repositorio de los archivos que nos interese.

$ cd ~/
$ mkdir sandbox
  1. Nos situamos en nuestra directorio home.
  2. Creamos el directorio sandbox en nuestro home.

Ahora nos dirigimos al directorio que hemos preparado para ejecutar scripts ―en mi caso ~/.bin―. Allí vamos a crear un script que copie automáticamente a sandbox.

$ cd ~/.bin
$ touch tosandbox
$ chmod u+x tosandbox
$ gedit tosandbox &
  1. Cambiamos el directorio a .bin.
  2. Creamos el archivo “tosandbox” vacío.
  3. Le damos permisos de ejecución para el usuario (o sea, nosotros)
  4. Editamos con gedit el archivo en background. Por supuesto puedes usar el editor que más te guste. Guardamos el archivo.
#!/bin/bash
cp $1 ~/sandbox/
  1. En la primera linea informamos al sistema que este script debe ser ejecutado en bash.
  2. En la segunda $1 corresponde al argumento ―es decir, en este caso al nombre del fichero que queremos copiar― en la carpeta sandbox. Es decir, los argumentos, por orden de aparición, adquieren dentro del script como nombre para referirnos a ellos $1, $2, $3
Probamos que funciona
$ cd ~/
$ touch archivodeprueba
$ tosandbox archivodepueba
$ ls -l sandbox
$ ls -l
total 0
-rw-rw-r-- 1 pedro pedro 0 oct 24 16:25 archivodeprueba

Como podemos comprobar, y era previsible, tosandbox a enviado nuestro archivo de prueba a la carpeta deseada.

Usar un número desconocidos de argumentos

Sí. Se puede hacer así. Modificamos nuestro ~/.bin/sandbox

#!/bin/bash
cp $* ~/sandbox/

En la segunda línea hemos sustituido 1 por *. Esto significa que “todos los argumentos que enviemos serán copiados a la carpeta sandbox. Lo probamos.

$ cd ~/
$ touch unfichero otrofichero
$ tosandbox unfichero otrofichero
$ ls -l sandbox
total 0
-rw-rw-r-- 1 pedro pedro 0 oct 24 16:25 archivodeprueba
-rw-rw-r-- 1 pedro pedro 0 oct 24 16:35 unarchivo
-rw-rw-r-- 1 pedro pedro 0 oct 24 16:35 otroarchivo

Epílogo

Con esta entrada del blog podéis empezar a crear vuestros propios scripts aportándoles argumentos desde la linea de comandos.

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública @pedroruizhidalg.pub.key

#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel

variables en shell bash de Linux

keep calm and #!/bin/bash

Extracto

@pedroruizhidalg―Dentro del shell se definen variables. Éstas son conocidas como variables de shell ―no hicieron aquí un alarde de imaginación―, cada usuario puede elegir su propio shell y en cada shell las asignaciones y el tratamiento de variables puede diferir en cuanto a su sintaxis. Nosotros vamos a ver las variables para el shell bash.

Abreviaturas usadas

Descripción

Cuando empezamos a usar nuestro shell bash frecuentemente necesitamos automatizar algunas tareas o bien, simplemente, facilitarnos la vida en un trabajo que creamos que va a ser muy repetitivo. Existen varios tipos de variables shell, numéricas, alfanuméricas y array.

Definición de variables en shell  bash

Definir una variable en bash es tan simple como asignarle un valor con el signo igual y sin espacios desde el prompt de nuestro sistema.

$ variable=77
$ echo $variable
77
$

Ejecución

Como vemos en el ejemplo anterior para la llamada a la variable tenemos que precederla del signo dolar. En otras palabras, para definirla simplemente la nombramos, sin espacios escribimos el signo igual y sin espacios asignamos el valor.

Lo que asignemos a la variable no puede contener espacios que no estén delimitados por comillas simples, dobles o comillas invertidas.

Eliminación de variables
$ unset variable
$ echo $variable
bash: variable: variable sin asignar
$

Mediante la orden unset y el nombre de la variable, esta es eliminada del sistema. Asignar un valor vacío a la variable no la destruye, simplemente la iguala a valor vacio. Como podemos ver en el siguiente ejercicio tan solo unset destruye la variable.

$ciudad=Granada
$ echo $ciudad
Granada
$ ciudad=''
$ echo $ciudad

$ unset ciudad
$ echo $ciudad
bash: ciudad: variable sin asignar
$
Delimitación de cadenas: apóstrofos, comillas y barras invertidas

La cadena literal: entendemos como cadena literal cualquier contenido alfanumérico que no va a ser alterado nunca. Su evaluación será por tanto, una constante. En el siguiente ejemplo usamos Ciudad Real porque consta de dos palabras. Esto siempre será evaluado como ‘Ciudad Real’ mientras no alteremos su contenido.

$ ciudad='Ciudad Real'
$ echo $ciudad
Ciudad Real
$

La cadena evaluada: Para producir cadenas literales con una parte variable usamos las dobles comillas. Este tipo de cadenas al ser evaluadas contiene tanto la parte literal como la parte variable:

$ ciudad='Ciudad Real'
$ visitado="he visitado $ciudad"
$ echo $visitado
he visitado Ciudad Real
$ ciudad=Madrid
$ echo $visitado
he visitado Ciudad Real
$ visitado="he visitado $ciudad"
$ echo $visitado
he visitado Madrid
pedro@Makina:~$
  • En la primera orden asignamos a ciudad el valor de ‘Ciudad Real’.
  • En la segunda orden asignamos con comillas dobles el valor a visitado que contiene una parte literal y otra parte que corresponde al valor de la variable ciudad en el momento de la asignación.
  • En la tercera podemos comprobar cómo visitado muestra tanto su parte literal como su parte variable.
  • En la cuarta orden cambiamos el contenido de la variable ciudad.
  • En la quinta volvemos a mostrar visitado, pero no es alterado su contenido ya que no hemos hecho de nuevo la asignación.
  • En la sexta volvemos a efectuar la asignación a la variable visitado.
  • Comprobamos que la nueva evaluación de la cadena visitado ha surtido efecto con su nuevo valor.

Para alterar el valor de una cadena evaluada hemos de volver a realizar la asignación.

Una demostración de CÓMO NO FUNCIONA una cadena evaluada.

$ ciudad=Madrid
$ visitado='he visitado $ciudad'
$ echo $visitado
he visitado $ciudad
$

Vemos que el mismo procedimiento pero con los apóstrofes produce un resultado literal. La cadena no es evaluada.

Órdenes en variables

Con las comillas invertidas asignamos una orden a una variable. Mediante el comando pwd se averigua el directorio de trabajo en el que estamos actualmente trabajando. Asignemos esto a una variable en el siguiente ejercicio.

$ orden=`pwd`
$ echo $orden
/home/pedro/sandbox
$
Trabajar con arrays

Si sabes programar no te hace falta leer el siguiente párrafo.

Un array es formalmente un vector de memoria. Es decir, es una variable donde vamos a almacenar datos independientes. Estas variables siempre hay que expresarlas con un índice ―el índice del array― que determina su posición dentro del vector. En muchas ocasiones un programador necesita que una sola variable contenga distintos valores por ejemplo una lista de ciuades como en el ejemplo.

Los arrays se definen en bash con una asignación entre paréntesis y los elementos separados por espacio.

$ ciudad=(París 'Nueva York' 'Roma' Santiago)
$ echo ${ciudad[*]}
París Nueva York Roma Santiago
$ echo ${ciudad[0]}
París
$ echo ${ciudad[1]}
Nueva York
$ echo ${ciudad[2]}
Roma
$ echo ${ciudad[3]}
Santiago
$ echo ${ciudad[4]}

$
  1. Hemos asignado a la variable ciudad los elementos París, ‘Nueva York’ ―entre comillas pues son dos palabras―, Roma y Santiago.
  2. Vemos cómo listar todos los elementos del array ciudad. Observamos que para trabajar con arrays la sintaxis además del signo dolar tenemos que encerrar el nombre de la variable entre llaves {} y el número de elemento ―que siempre empieza por el elemento cero― entre corchetes [].
  3. Obtenemos el elemento 0.
  4. Vemos el contenido del elemento 1.
  5. Mostramos el elemento 2.
  6. Vemos el elemento 3.
  7. No existe nada en el elemento 4.

Lo vemos con otro ejemplo. Ahora vamos a introducir en una cadena evaluada un elemento del array.

$ ciudad=(París 'Nueva York' 'Roma' Santiago)
$ visitado="he visitado ${ciudad[$b]}"
$ b=1
$ echo $visitado
he visitado Nueva York
$ b=2
$ visitado="he visitado ${ciudad[$b]}"
$ echo $visitado
he visitado Roma
$

Podemos comprobar cómo con una sola variable almacenamos distintos valores.

Epílogo

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública @pedroruizhidalg.pub.key

#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel

Linux shell bash básico para principiantes

logo bash Bourne again shell

Extracto

@pedroruizhidalg― El shell es un intérprete de órdenes que proporciona una interfaz interactiva orientada a línea entre el usuario y el sistema operativo. Si bien existen varios shells, quizás es más común es Bash. Conocer desde un principio la estructura y posibilidades de este shell hará que adquieras unas habilidades en Linux que te mostrará su auténtica potencia.

Abreviaturas usadas

Bash: Bourne again shell.
EOF: End of file. Fin de fichero.

Descripción

Cuando en Linux abrimos un terminal desde nuestro entorno gráfico, o bien fuera de éste, queda a nuestra disposición una interfaz de linea de órdenes ―comandos― esta consola de linea de texto queda dispuesta para órdenes con sus opciones y argumentos. El el inductor shell es representado por el símbolo dolar como muestro a continuación:

$

Linux instala por defecto el shell bash, cuyo inductor es el símbolo dólar, no obstante cada shell en Linux puede tener su propio inductor. En este manual nos centraremos en Bash.

El shell bash es case sensitive, es decir distingue entre mayúsculas y minúsculas.

Ejecución

Empecemos poco a poco. La primera orden que vamos a introducir es «date», que obtiene la fecha y hora del sistema.

$ date
mié oct 21 14:16:37 CEST 2015
$

Esto muestra la hora y fecha en la que ha sido ejecutada esta orden. Dejando tras su ejecución de nuevo el inductor a la espera del siguiente comando.

Como forma general los comandos Linux tendrán la siguiente estructura:

$ Orden Opciones Argumentos
Opciones y argumentos

Una opción es un código seguido de una letra, o dos guiones seguidos de una palabra o palabras separadas por guiones. El comando ls, sin opciones, visualiza todos los archivos del directorio actual.

$ ls
carta1  carta2  micarta  todaslascartas
$

Con “-l” el comando ls modifica su salida y muestra una linea de información acerca de cada archivo.

$ ls -l
total 0
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta1
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 micarta
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 todaslascartas
$

Con la opción “a” muestra una lista de todos los archivos que haya en el directorio, incluso aquellos archivos que sean archivos ocultos. Los archivos ocultos llevan un punto al principio de su nombre.

Podemos unir las opciones “l” y “a” así “-l -a” o así “-la”.

$   ls -la
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 15:23 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

La mayoría de las órdenes han sido diseñadas para llevar argumentos. Como vimos arriba un argumento es una palabra que se teclea en la linea de órdenes tras las opciones. Veamos cómo se comporta el comando “ls” con las opciones “-la” y el argumento carta1.

$ ls -la carta1
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta1

En este caso hemos pedido al sistema la restricción de su salida haciendo que únicamente nos muestre el contenido del directorio que coincide con carta1. En este caso carta1 no es un archivo oculto. Hubiera producido el mismo resultado que la orden “ls -l carta1”.

Caracteres comodín y argumentos que son nombres de archivo

Los nombres de archivo son los argumentos más comunes en las órdenes. Es frecuente que sólo sepa ―recuerde― una parte del nombre, o tal vez le interese listar aquellos archivos que coinciden con un patrón determinado. Los caracteres comodín sirven para informar al sistema que la orden que estamos solicitando debe cumplir algunas coincidencias.

Carácter comodín *

Se usa para expresar como variable una parte de la cadena que estamos expresando.

$ ls -la carta*
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta1
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2

En otras palabras lista los archivos contenidos en el directorio cuyo nombre comience por “carta”.

¡Cuidado! determinadas órdenes y los comodines pueden producir una mezcla explosiva. Por ejemplo el comando “rm” sirve para eliminar archivos del directorio en que se está trabajando.

$ rm carta*

Borraría, en este caso, carta1 y carta2.

Seleccionar por extensiones

En Linux las extensiones de los archivos no son necesarias. No lo son para Linux, pero qué duda cabe que para los humanos sí, pues nos permite aislar fácilmente ese tipo de fichero del resto. Podemos usar el carácter comodín asterisco como discriminador por extensión.

$ ls -l *.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:10 documento.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc

Nos muestra todos los archivos cuya extensión es “doc”.

El carácter comodín ?

Este comodín sirve para hacer coincidir una sola posición variable por cada aparición del carácter “?”. Veamos detenidamente el siguiente ejemplo:

$ ls -l *.?oc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:10 documento.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:20 factura.moc
$ ls -l factura.?oc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:20 factura.moc
$ ls -l factura.*
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:20 factura.moc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:22 factura.xls

En la primera orden solicitamos el listado de todos los archivos, sin importar su nombre, cuya extensión termine en “oc”: coinciden tres, documento.doc, factura.doc, factura.moc.

En la segunda orden pedimos todos los archivos cuyo nombre sea factura y su extensión termine en “oc”, coinciden factura.doc y factura.moc.

En la tercera queremos conocer todos los archivos cuyo nombre sea factura sin importar su extensión.

Caracteres comodín [ ]

Estos caracteres comodín se usan para indicar series. Por ejemplo:

$ ls -l carta[2-4]
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:23 carta3
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:23 carta4

Hemos seleccionado los documentos carta que terminan con los caracteres del 2 al 4, ecluyendo el 1. Otro ejemplo: pedimos listar los archivos carta2 y carta3 excluyendo los archivos carta1 y carta4.

 $ ls -l carta[2-3]
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:23 carta3
La entrada/salida estándar y redirección

Cuando fue diseñado Unix, se tomó la decisión de considerar la implementación física y la organización lógica de un archivo como cosas independientes. Físicamente se accede a los archivos de Unix como bloques que están dispuestos de forma aleatoria, si bien, lógicamente los archivos están dispuestos son un flujo continuo de bytes. Linux como versión de Unix mantiene la misma organización.

Por tanto cualquier archivo, a excepción de  algunas llamadas especiales al sistema, podrá ser copiado a otro archivo fácilmente. Para Linux no hay ninguna diferencia entre un archivo de caracteres y otro de registros, ni entre un archivo de texto y otro binario.

Esta organización lógica de archivos se extiende a las operaciones de entrada y salida. Los datos son organizados como en un archivo. De tal forma que la entrada para por teclado para Linux es un flujo continuo de datos. Igualmente, la salida estándar ―que es la pantalla― es otro receptor de flujos continuos de datos provenientes del sistema.

Esta característica hace de Linux un sistema en que es muy fácil crear salidas y entradas diferentes.

Redirección de la salida estándar: > y >>

Supongamos que en vez de ver el resultado de un comando por pantalla queremos, para observarlo más tranquilamente,  alterar la salida y crear un fichero con el resultado de un comando.

$ls -la > fichero.dir

$ cat fichero.dir 
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 16:41 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 16:41 fichero.dir
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

Con la primera orden efectuamos la redirección de la salida por pantalla hacia un archivo llamado “fichero.dir”. Con la segunda orden “cat” examinamos el contenido de dicho archivo. Como se puede observar se ha creado el archivo que consta con 864 bytes.

$ ls -l fichero.dir 
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:41 fichero.dir

Esto ha sido posible por el operador “>” puesto tras la orden “ls -l”. De igual forma podemos redireccionar la salida por pantalla de un archivo hacia otro archivo. Aunque hay un método más sencillo con el comando “cp” para copiar archivos, vamos a efectuar la una copia del archivo fichero.dir hacia otro archivo llamado copia.dir. Luego consultaremos cuántos archivos tienen la extensión .dir.

$ cat fichero.dir > copia.dir

$ ls -l *.dir
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:52 copia.dir
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:41 fichero.dir

Como se puede observar tanto los archivos copia.dir como fichero.dir tienen 864 bytes y fichero.dir fue creado a las 16:41 y copia.dir a las 16:52 horas.

Adición de la salida estándar: >>

Una vez asimilado el concepto de redirección de la salida, veamos el de adición. Si se repite la salida redirección de la salida estándar el fichero receptor de la salida es borrado y creado de nuevo. Pero tenemos la oportunidad de añadir información sin borrar la anterior. Esto se hace con el operador “>>”. Veamos un ejemplo. Vamos a volver a crear el archivo fichero.dir con el resultado de los archivos del directorio y le añadiremos el calendario del año 2015 con la orden “cal 2015”. Luego comprobaremos que el fichero ha cambiado de hora de creación.

$ ls -l > fichero.dir 

$ cal 2015 >> fichero.dir 

$ cat fichero.dir 
total 4
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 carta1
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:23 carta3
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:23 carta4
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:52 copia.dir
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:10 documento.asc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:10 documento.doc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:20 factura.moc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:22 factura.xls
-rw-rw-r-- 1 pedro pedro   0 oct 21 17:01 fichero.dir
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 micarta
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:04 texto2
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 todaslascartas
                            2015
       Enero                Febrero                Marzo          
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
             1  2  3   1  2  3  4  5  6  7   1  2  3  4  5  6  7  
 4  5  6  7  8  9 10   8  9 10 11 12 13 14   8  9 10 11 12 13 14  
11 12 13 14 15 16 17  15 16 17 18 19 20 21  15 16 17 18 19 20 21  
18 19 20 21 22 23 24  22 23 24 25 26 27 28  22 23 24 25 26 27 28  
25 26 27 28 29 30 31                        29 30 31              
                                                                  

       Abril                  Mayo                 Junio          
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
          1  2  3  4                  1  2      1  2  3  4  5  6  
 5  6  7  8  9 10 11   3  4  5  6  7  8  9   7  8  9 10 11 12 13  
12 13 14 15 16 17 18  10 11 12 13 14 15 16  14 15 16 17 18 19 20  
19 20 21 22 23 24 25  17 18 19 20 21 22 23  21 22 23 24 25 26 27  
26 27 28 29 30        24 25 26 27 28 29 30  28 29 30              
                      31                                          

       Julio                 Agosto              Septiembre       
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
          1  2  3  4                     1         1  2  3  4  5  
 5  6  7  8  9 10 11   2  3  4  5  6  7  8   6  7  8  9 10 11 12  
12 13 14 15 16 17 18   9 10 11 12 13 14 15  13 14 15 16 17 18 19  
19 20 21 22 23 24 25  16 17 18 19 20 21 22  20 21 22 23 24 25 26  
26 27 28 29 30 31     23 24 25 26 27 28 29  27 28 29 30           
                      30 31                                       

      Octubre              Noviembre             Diciembre        
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
             1  2  3   1  2  3  4  5  6  7         1  2  3  4  5  
 4  5  6  7  8  9 10   8  9 10 11 12 13 14   6  7  8  9 10 11 12  
11 12 13 14 15 16 17  15 16 17 18 19 20 21  13 14 15 16 17 18 19  
18 19 20 21 22 23 24  22 23 24 25 26 27 28  20 21 22 23 24 25 26  
25 26 27 28 29 30 31  29 30                 27 28 29 30 31        
                                                                  
$ ls -l fichero.dir 
-rw-rw-r-- 1 pedro pedro 2936 oct 21 17:01 fichero.dir

La primera orden ha rehecho el archivo fichero.dir nuevamente con el listado de archivos. La segunda añade a archivo.dir el resultado de la orden “cal 2015” sin borrar, es decir añadiendo, los datos. La tercera orden muestra el contenido de archivo.dir con ambos resultados y en la cuarta orden podemos observar que fichero.dir ahora tiene 2936 bytes y ha sido creado a las 17:01 horas.

La entrada estándar

Muchas órdenes de Linux reciben los datos de la entrada estándar. Esa es la situación normal. La entrada estándar es el teclado. La entrada estándar como flujo de datos son introducidos por el teclado y dirigidos a la orden Linux. La orden “cat” sin argumento de nombre de archivo lee la entrada estándar y la redirige a la salida estándar ―pantalla―.

Antes de realizar el siguiente ejercicio tenemos que aprender que para todo linux la señal de fin de fichero (EOF) se realiza desde el teclado con “control-d” o “^D”.

$ cat 
estoy creando
estoy creando
una salida 
una salida 
desde la entrada estandar
desde la entrada estandar
^D
$

Como vemos lo que hace el comando cat sin argumentos es copiar lo que hemos tecleado desde la entrada estándar. Cuando pulsamos “control-d” acabamos la entrada y termina el proceso cat.

Vamos ahora a usar cat como recetor de un archivo. Es decir redireccionamos la entrada a cat desde el archivo copia.dir

$ cat < copia.dir 
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 16:41 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 16:41 fichero.dir
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

Vemos cómo hemos usado cat haciendo que la entrada fuera procedente del contenido del archivo copia.dir.

Se puede combinar las operaciones de redirección de la entrada como la salida estándares. En el siguiente ejemplo la orden cat no tiene argumentos de nombres de archivo. Sin argumentos toma la entrada desde el archivo copia.dir y redirecciona la salida a otracopia.dir.

$ cat < copia.dir > otracopia.dir
$ cat otracopia.dir 
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 16:41 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 16:41 fichero.dir
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

Mostrando a la vez el contenido de copia.dir y creando otro archivo llamado otracopia.dir.

Canalizaciones: |

Hay muchísimas ocasiones en las que se necesita enviar el resultado de una orden hacia otra orden. En otras palabras, se envía la salida estándar de una orden a la entrada de otra y no a un archivo. La canalización lpr se usa para enviar datos a la impresora.

$ ls -la | lpr

Hacemos que la salida estándar de ls -la la tome como entrada la orden lpr, como resultado esto llegará a la impresora.

Enviar un archivo a la impresora con cat -n imprimirá el archivo con el número de cada una de las líneas.

$ cat -n fichero.dir | lpr
Las canalización a more

Es una operación muy común canalizar el resultado de ls a la orden more ya que si el resultado prevemos que el resultado del listado de directorios sea demasiado grande, no nos dará tiempo a leerlo. El recurso ls -la | more, entrega al comando more el resultado de la orden ls, lo que permitirá que se detenga el listado hasta que llegue al final de la pantalla y esperará a que pulsemos la barra espaciadora para presentarnos otra página completa o intro para avanzar una sola linea.

$ ls -l /usr/bin | more

Presiona “q”, escape o “control-c” para salir.

Una canalización un poco más compleja. Usamos la orden sort para clasificar el contenido de un fichero dado, llamaremos a este fichero milista, la calalización de la salida estándar de sort se la entregamos a cat -n para que numere las líneas clasificadas, y esto lo canalizamos a la impresora. Así:

$ sort milista | cat -n | lpr

Otra canalización frecuente, se realiza con el comando tee, que se encarga de recoger la salida estandard y dirigirla al fichero especificado en tiempo real ―quiero decir conforme se efectúa la salida estándar―, en otras palabras, gravo en un fichero todo lo que sale por pantalla.

$ cat milista | tee nuevalista
Redirección y canalización del error estándar: >&, 2>

Observemos la siguiente secuencia de órdenes. Luego las explicaré.

$ cat ficheronoexiste
cat: ficheronoexiste: No existe el archivo o el directorio

$ cat ficheronoexiste > ficheronoexiste.err
cat: ficheronoexiste: No existe el archivo o el directorio

$ cat ficheronoexiste.err 

$ cat ficheronoexiste 2> ficheronoexiste.err

$ cat ficheronoexiste.err 
cat: ficheronoexiste: No existe el archivo o el directorio

En la primera orden intento obtener la salida estándar de ficheroquenoexiste ―de hecho no existe :-)― por eso Linux contesta indicándolo.

En la segunda de orden redirijo el flujo de la salida al fichero ficheronoexiste.err, que como vemos en este caso se crea, pero vacío, no contiene nada, porque nada produjo la orden cat.

En la tercera redirigimos el error con los caracteres “2> “ hacia fichernoexiste.err, en esta ocasión se crea con el contenido de la salida de errores producida por la orden cat.

No obstante si deseamos guardar los mensajes de error en el mismo archivo que use para la salida estándar, se necesita redireccionar el error estándar a la salida estándar. Es un poco lioso, lo vemos y lo explico.

$ cat fichernoexiste 1> otrofichero.err 2>&1

$ cat otrofichero.err 
cat: fichernoexiste: No existe el archivo o el directorio

La primera redirección la efectúo a otrofichero.err, la segunda redirección de error la devuelvo a &1, que es otra vez la salida estándar. Pero podemos simplificarlo:

Redirección de todo error a la salida estándar:

$ cat fichernoexiste >& ficheronoexiste.err
linux shell bash
linux shell bash

Epílogo

Esto sólo un compendio de lo que puede hacerse con bash. En el proyecto Lucas Bash podéis ampliar más. En una siguiente entrega describiré las variables en Bash.

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública @pedroruizhidalg.pub.key

#aboutpedroruizhidalgo
[aquí la encuesta]
♻ miotroblogsite ahorra papel

data mining: técnicas y procedimientos

técnicas de data mining

@pedroruizhidalg― A principios de 2002, el director del FBI, John Aschcroft, anunciaba que el Departamento de Justicia comenzaría a analizar las bases de datos comerciales referentes a los hábitos de consumo y preferencias de compra de los consumidores estadounidenses. Expertos aseguran que la intención del FBI es aunar toda la información que dispongan en una mega base de datos con el fin de poder hacer el seguimiento ―en USA es casi sospechoso pagar con efectivo repetidas veces, siempre lo hacen con tarjeta― del reguero de información que vamos dejando en nuestro día a día.

Permitidme ilustrarlo con un ejemplo. Fulano de Tal se levanta un sábado y mira su Facebook, contesta a lo que le ha llamado la atención. Consulta su cuenta de Twitter y retuitea la cosa tan graciosa que ha visto. Luego mira su email. Tras esto desayuna, se ducha y se va en moto hacia una gasolinera para poner 10€ de carburante. Va a unos grandes almacenes, en la búsqueda mira una gorra, la fotografía y la envía a su novia a ver qué le parece; se compra un pantalón vaquero y una camiseta para la playa. En la esquina de siempre, le espera su novia, con la que van a tomar algo a un bar de moda. Fotografían ambos la tapa, la mandan a sus redes sociales, algunos amigos contestan con un «like» otros retwitean. Aquí paramos el ejemplo. Ahora vamos a verlo desde el punto de vista de las redes sociales y quien tenga acceso a ellas.

Cuando accedemos a una de nuestras redes sociales, se graba todo, se graba, por ejemplo, si accedemos con móvil, tablet u ordenador de sobremesa, la hora y el lugar desde el que accedemos, el sistema operativo que usamos, el tipo de navegador, el ancho de nuestra página, la última página que hemos visitado, y, desde luego, nuestra IP, por tanto, también se está grabando si accedemos desde wifi o por conexión directa 3 ó 4G. Así que puede reconstruirse la historia que antes he descrito desde la siguiente óptica:

Nuestro protagonista se conecta el sábado a las 8:35 desde una ubicación determinada ―su casa― accedió mediante la aplicación de Facebook que tenía en el móvil, contestó a su amigo de la primo ―nosotros somos quienes describimos las relaciones en facebook― algo relacionado con Messi ―sí, esto también es catalogado, pues es muy importante para los gurús del márketing―, en Twitter se hace eco del chiste del presidente de gobierno ―ya conocemos su tendencia política―, conocemos quienes le han escrito a su cuenta de Google y cuál ha sido su reacción ante ese mail. Ha puesto 10€ de gasolina 98 a las 9:43 ―llegado el caso la gasolinera tiene cámaras― y lo ha pagado con la tarjeta de crédito de su banco número tal. No ha ido al centro comercial por el camino más corto, lo sabemos por el GPS de su móvil, aparca en la puerta de un bar. Usa la talla XXL de camiseta y de pantalón la XL en lo que ha invertido 44.54€ en total, pero con su tarjeta de crédito ―que caduca el próximo enero― lo pagará el mes que viene. En la puerta del bar donde tiene aparcada la moto, se encuentra con su novia a las 11:17 horas, y tomaron unas patatas bravas con cerveza ―ellos mismos lo tuitearon― a su amigo, Fran ―el de Huelva― le gusta la foto de las patatas bravas.

Y así… podíamos seguir hasta obtener un perfil completo de ese Don Nadie, que si bien no nos aporta nada especial, sí que unido al ejército de «donnadies» que, es verdad, llevan vidas grises aburridas y previsibles, sí podemos coleccionar todos esos datos porque a las empresas de márketing les interesa muchísimo.

Clave pública @pedroruizhidalg.pub.key
#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel

manual de gpg (PGP)

Extracto

@pedroruizhidalg― PGP,  fue considerada por el gobierno de Estados Unidos como el mayor de los secretos. Tan secreto como el código de lanzamiento de los misiles nucleares. En buena medida, los códigos de los misiles dependían del código PGP. Un día, alguien publicó este código en una web. Aunque hubieron sospechosos no se pudo determinar quien era el «culpable».  La historia es apasionante, y algo farragosa. GPG es un sistema multiplataforma de gestión de llaves utilizado para el cifrado y firma digital de mensajes y archivos. Es un software libre liberado bajo la licencia GPL e implementa el estándar OpenPGP. GPG puede comunicarse con la versión actual de PGP y con cualquier otro sistema que implemente el estándar OpenPGP. GPG es un software híbrido de cifrado que combina tanto criptografía simétrica o de clave privada y criptografía asimétrica o de clave pública.

Nomenclatura y abreviaturas usadas

Criptografía simétrica.
Criptografía asimétrica.
RSA: En criptografía, RSA (Rivest, Shamir y Adleman) es un sistema criptográfico de clave pública desarrollado en 1977. Es el primer y más utilizado algoritmo de este tipo y es válido tanto para cifrar como para firmar digitalmente.
GPG: GnuPG.

Descripción

GPG es un sistema de criptografía de clave pública. Su código es libre, abierto y gratuito. Es multiplataforma, puede ser instalado en Linux, Windows y otros sistemas. De facto viene instalado en la mayoría de las distribuciones Linux. La instalación, si fuera necesario, en ubuntu sería así:

$ sudo apt-get install gnupg
$ gpg < /dev/null

Esta última línea dará un error. Gracias a la ejecución con ese error se han creado los directorios y los archivos de configuración necesarios. Continuamos con la instalación:

$ cp /usr/share/gnupg/options.skel ~/.gnupg/gpg.conf
$ gedit ~/.gnupg/gpg.conf &

Esto debería abrir el archivo de configuración de nuestro usuario. Buscamos la línea keyserver-options auto-key-retrieve y eliminamos el símbolo «#» que debe tener a la izquierda. Si no lo tuviera lo dejamos tal cual. Guardamos y salimos.

Creación de la pareja de claves
$ gpg --gen-key
gpg (GnuPG) 1.4.16; Copyright (C) 2013 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Por favor seleccione tipo de clave deseado:
 (1) RSA y RSA (predeterminado)
 (2) DSA y Elgamal
 (3) DSA (sólo firmar)
 (4) RSA (sólo firmar)
¿Su selección?: 

Si nuestra intención es tan solo firmar, cualquiera de las opciones nos sirve. Si, como es lógico, ademas, queremos cifrar mensajes de forma que únicamente el receptor pueda descifrarlo y trabajar con el contenido que le enviamos, recomiendo la opción 1.

DSA keypair will have 1024 bits.
ELG-E keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048)
Requested keysize is 2048 bits

Una clave de 1024 es considerada como débil. 4096 puede ser lento. Mi clave personal es de 2048. Seguidamente nos reguntará acerca de la caducidad de la clave.

Please specify how long the key should be valid.
0 = key does not expire
<n> = key expires in n days
<n>w = key expires in n weeks
<n>m = key expires in n months
<n>y = key expires in n years
Key is valid for? (0)
Key does not expire at all
Is this correct? (y/N) y

Supongamos que se usa la clave para enviar trabajos de un curso que terminará en un año, nuestra respuesta sería 1y. 0 para que la clave no expire jamás.

Tras esto nos pedirá algunos datos personales. Es importante dar los correctos, ya que como veremos más adelante, nuestra clave terminará en servidores de claves a nivel mundial. Si nuestra clave no nos representa, simplemente no es confiable. En Linux, generalmente no vas a tener problemas. Si trabajas en Windows te recomiendo no usar acentos tanto en el nombre como en el resto de la información que suministres. Cuando suministres la información el programa te insta a que lo revises cuidadosamente. Así:

You need a user ID to identify your key; the software constructs the user ID
from the Real Name, Comment and Email Address in this form:
"Fulano De Tal (Mi empresa) <fulanodetal@miempresa.com>"
Real name: Fulano De Tal
Email address: fulanodetal@miempresa.com
Comment:
You selected this USER-ID:
"Fulano De Tal <fulanodetal@miempresa.com>"
Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o

Podemos encontrar que en vez de pedir (O)kay pide (V)ale.

You need a Passphrase to protect your secret key.
Enter passphrase:
Repeat passphrase:

Si estamos trabajando desde un terminal gráfico, vuestro sistema os podría solicitar la contraseña en una ventana emergente. En cualquier caso, suministrar una contraseña que sea segura, que contenga números y símbolos, que no sea una palabra del diccionario, una fecha de nacimiento, o una matrícula. Esta palabra de paso es tu única defensa ante los posibles usos inadecuados. De ahí la importancia de que sea segura.

Ahora viene la parte que me gusta, GPG te invita a que hagas cosas con las ventanas, con el ratón con los discos duros, que abras carpetas, que mires fotos, compiles programas y cosas así. Es porque está calculando números aleatorios con nuestros procesos. Pudiera darse el caso que tengas que volver a repetir ver carpetas porque le falten datos aleatorios, tú simplemente sigue las instrucciones. Un comando que crea bastante entropía es:

$ ls / -laR

Ábrelo en otro terminal. Finalmente:

gpg: key E0CABB25 marked as ultimately trusted
public and secret key created and signed.
gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0 valid:
2 signed:
0 trust: 0-, 0q, 0n, 0m, 0f, 2u
pub
1024D/E0CBB25 2005-12-22
Key fingerprint = CEDB 1451 1F26 83D9 DB69 7ADA FFEE 1F18 E0CA 9E25
uid
Fulano De Tal <fulanodetal@miempresa.com>
sub
2048g/88885614 2016-12-31

Aquí es importante el número de usuario: E0CBB25, que es tu identidad en el anillo de claves. No te preocupes, siempre puedes volver a recuperarlo. No obstante también puedes usar como identidad tu correo o tu nombre.

¡IMPORTANTÍSIMO: Creación del certificado de revocación!

Seguidamente debes crear un certificado de revocación. Ya que en caso de que tus claves se vieran comprometidas, o tu contraseña averiguada (violada), debes tener las herramientas suficientes para revocar tus claves, tanto en tu propio ordenador con en los servidores de claves mundiales.

$ gpg --gen-revoke -armor --output revoke.key.asc E0CBB25

otra forma sería:

$ gpg --gen-revoke -armor --output revoke.key.asc fulanodetal@miempresa.com

y otra:

$ gpg --gen-revoke -armor --output revoke.key.asc 'Fulano de Tal'

Como resultado obtendrás un archivo llamado revoke.key.asc. La extensión asc es para indicarnos que la revocación la hemos creado en ascii y eso es debido a que hemos incluido en el comando el argumento –armor. Sin ese argumento la clave de revocación sería en formato binario, lo que nos supondría un problema para revocar mediante Internet, en caso de que nuestra clave esté en un servidor público.

Ya tenemos creada nuestro par de claves con el certificado de revocación.

Ejecución

La primera acción a realizar sería proteger nuestro certificado de revocación. Como nunca sabemos en qué circunstancias vamos a tener que realizar la revocación, si desde nuestro ordenador, desde otro, con nuestro sistema operativo, con Windows… en fin, hablamos de una circunstancia futura. Vamos a crear un archivo zip al que vamos luego cifraremos de forma simétrica.

$ zip revoke.zip revoke.key.asc
$ gpg -c revoke.zip

Desgraciadamente, el cifrado simétrico es el más débil de los cifrados, se trata de un archivo con una clave. Quien sepa la contraseña tendrá acceso al contenido. Esto lo realizamos para guardar el archivo en un dispositivo seguro, un cd, un dvd, un pen drive… Algo al que no tenga acceso nadie.

Ahora debemos borrar nuestro archivo revoke.key.asc de forma cuidadosa. Ya que un simple borrado no nos garantiza la eliminación del contenido del archivo en disco. Tan solo, lo elimina de los índices, si bien la información sigue ―o puede seguir― estando ahí.

Difusión de la clave pública

Vamos a crear un archivo en ascii para la difusión de la clave pública. Mediante el siguente comando.

$ gpg -a --export --output mi.pkey.asc fulanodetal@miempresa.com

o bien listando las claves que existen en nuestro sistema y eligiendo el id de usuario. Así:

$ gpg --list-keys
$ gpg -a --export --output mi.pkey.asc E0CBB25

El archivo mi.pkey.asc es nuestra clave. Obviamente el nombre es arbitrario, puedes elegir otro que te guste o se adecúe mejor a tus nemotécnicos.

Ahora tenemos varias opciones:

  • Copiar el archivo en un CD para entregar en mano a nuestros contactos.
  • Enviar nuestro archivo como adjunto a nuestros contactos como adjunto en emails.
  • Publicar en nuestra web nuestra clave pública. Mira la mía.
  • Enviar la clave a un servidor de claves.
    • Yo uso pgp.rediris.es. Redirige a http://www.rediris.es/keyserver/
    • Si en la cadena de búsqueda introducís mi nombre ‘Pedro Ruiz Hidalgo’ aparecen dos entradas. Ambas son mías. La que corresponde a 6-9-2003 ya no me pertenece porque perdí la clave de revocación. Eso estará ahí por los siglos de los siglos.
    • El servidor de rediris, igual que otros, comunica todas las identidades a otros servidores. De esta forma es fácil identificarnos para poder enviarnos mensajes cifrados.
    • Podemos crear nuestra identidad copiando la totalidad de nuestro archivo de clave pública y enviarlo desde web. Otra forma sería así:
$ gpg --keyserver pgp.mit.edu --send-keys E0CABB25
gpg: sending key E0CABB25 to hkp server pgp.mit.edu

La mayoría de los servidores de claves están conectados entre sí. Siempre puedes revocar la clave con el certificado de revocación. Si lo perdieras, la clave deja de pertenecerte. Así de crudo.

Importar la clave de pública de un amigo a nuestro anillo de claves

Supongamos que Silvia me envía un certificado. La voy a incluir en mi anillo de claves, pero como no la conozco en persona no firmaré su clave.

$ gpg --import silvia.pkey.asc
gpg: key E02BF32C: public key "Silvia Pérez <silvia.perez@empresadesilvia.com>" imported
gpg: Total number processed: 1
gpg:
imported: 1

En todo esto hay un punto débil. Que sería fabricar una clave con una identidad falsa y hacerla circular. De forma que os recomiendo que hagáis un uso muy paranóico de la seguridad de las claves.

La huella digital

Cuando importemos el certificado, antes darle carta de credibilidad, usamos la huella digital. Esta huella digital es fácil ser leída por teléfono ―siempre que la llamada la efectuémos nosotros―, entregada en mano, o por cualquier «canal seguro» que no nos dé absoluta confianza.

Listar una huella digital:

$ pgp --fingerprint 'Silvia'
pub   2048R/E02BF32C 2015-10-17
      Huella de clave = AC9E F5FD 1888 5BDE 0C6A  CAB· CE69 CDEF 20BA 9950
uid                  Silvia (Para propósitos de encriptación del sistema) <silvia.perez@laempresade silvia.com>
sub   2048R/E02BF32C 2015-10-17

Si la huella de la clave, transmitida por un «canal seguro» es correcta (AC9E F5FD 1888 5BDE 0C6A CAB· CE69 CDEF 20BA 9950) podemos firmar la clave de Silvia. Así:

$ gpg --sing-key silvia.perez@laempresadesilvia.com

O bien con su ID de usuario. GPG nos mostrará en pantalla información de Silvia, si estamos seguros pulsamos “sí”, no obstante, aún gpg duda de que quien esté tratando de firmar la clave sea realmente el usuario de así que pedirá la palabra de paso de quien está firmando. A partir de este momento la clave de Silvia queda unida a la mía, y, si yo envío mi clave pública estaré también enviando la de Silvia.

Firmar un documento
$ gpg --sign midocumento.doc

Pedirá la clave del usuario. Esto genera un documento llamado “midocumento.doc.gpg”. Este archivo .gpg  podemos entregarlo. Para comprobar la firma:

$ pgp midocumento.doc.gpg
gpg: Signature made vie 23 feb 2015 19:00:43 CET using DSA key ID E0CAFE95
gpg: Good signature from "Fulano de tal <fulanodetal@miempresa.com>"

Tras la comprobación de la firma tenemos otra vez los dos documentos. El original y el firmado pues gpg lo ha separado.

Cifrado para un destinatario en concreto

Expresamos en el recipiente “-r” la identidad del destinatario, bien mediante su Id. de usuario, su correo o simplemente su nombre. Si quiero encriptar un documento para que sea leído exclusivamente por Silvia:

$ gpg --encript -r Silvia documento.doc
Cifrado para varios destinatarios determinados

Ahora, además de cifrar para Silvia, voy a hacer que Antonio tenga también una copia de ese documento cifrado, pues se lo enviaré a ambos por correo. Así:

$ gpg --encrypt -r Silvia -r Antonio [-r otro] documento.doc

Epílogo

Estas son las operaciones básicas con gpg (PGP). Incluyo un buen manual de José Luis Díaz, GnuPG, realizado en 2006.

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública: @pedroruizhidalg.pub.key

#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel

procesos en Linux

linux shell bash

Extracto

@pedroruizhidalg― Linux tiene una forma más completa de ejecutar los procesos si lo comparamos con otros sistemas operativos. Nuestros procesos pueden ser parados, enviados al background, traidos de nuevo al foreground, abortados, y todo ello obteniendo una lista de los procesos que tenemos en ejecución. Veamos cómo.

Abreviaturas usadas

PID, abreviatura de Process ID. Identificación del proceso.
CPU, Unidad Central de Procesos del inglés “Central Process Unit”.

Descripción

Algunas ocasiones solicitamos un proceso en el terminal de Linux y tarda más de lo que habíamos previsto. En otras ocasiones, sabemos que lo que vamos a ejecutar va a tardar un buen rato y decidimos ejecutarlo en segundo plano (a esto lo llamaremos background). Otras veces simplemente queremos detener un proceso. Llamaremos al primer plano (foreground) a lo que se está ejecutando en el terminal. Veamos cómo.

Enviar un proceso directamente al segundo plano
$ [comando de linux] &

Como podéis observar al terminar el comando en andpersand (&) le indicamos a Linux que esa orden ha de ser ejecutada directamente en segundo plano. Independientemente de la duración de ese comando, nuestro terminal debe quedar libre para seguir trabajando. Automáticamente nos saldrá un número entre corchetes y otro junto a él. Este número entre corchetes es el número de tarea que como usuarios tenemos pendientes en segundo plano. El número que hay a continuación es el número de tarea que ese comando ocupa en el sistema.

Conocer los procesos que tenemos activos como usuario.
$ jobs
Traer un proceso de background a foreground
$ fg %numero-de-proceso-usuario

Siendo el número de proceso el número que aparece con el comando “jobs” entre corchetes. Por ejemplo para pasar de background a foreground el proceso 3:

$ fg %3

Se detiene inmediatamente un proceso mediante control-c. No obstante también podemos ordenarlo conociendo su número de proceso. Lo veremos más adelante.

Un proceso tan solo puede ser parado en foreground , la forma de detener un proceso es pulsando control-Z mientras está activo en primer plano. Veamos un ejemplo. Vamos a crear un proceso largo y lo paramos así:

$ ls / -laR > qqq

Esto empezará a incluir el contenido de todos los archivos del disco duro desde la raíz en un archivo que hemos llamado qqq. La forma de detener el proceso es pulsar control-Z. Debe aparecer el siguiente mensaje:

[1]+  Detenido                ls --color=auto / -laR > qqq

En ese momento este proceso no está ni en foreground ni en background. Está detenido.

Activar en background un proceso detenido.
$ bg %numero-proceso-usuario

En el caso del comando que tenemos ahora detenido sería así:

$ bg %1

Ejecución

La orden top nos lista en tiempo real todos los procesos que están activos en el sistema, aportándonos además más información. Para más información “man top”.

$ top

Una forma de obtener una “foto fija” de los procesos activos es así:

$ ps -aux

Como verás aporta, básicamente, la misma información que top pero no en tiempo real.

Parar un proceso conociendo su numero de tarea de usuario

Si deseamos eliminar un proceso conociendo su número de tarea de usuario lo hacemos de la siguiente forma. Supongamos que deseamos eliminar la tarea 5.

$ kill %5

O bien eliminarlo inmediatamente conociendo su PID que nos aporta los comandos top o ps -aux. Supongamos que queremos eliminar el proceso 5443

$ kill -9 5443

 Epílogo

Esto puede daros bastante juego a la hora de trabajar con procesos en Linux. Deberíamos desconfiar sistemáticamente de los procesos largos, de los que ocupen mucha memoria, y de los que ocupen mucha CPU. Esta información puede ser obtenida tanto con top como con “ps -aux”. Normal mente podemos echar un vistazo a los procesos copiándolos a un archivo de la siguiente forma.

$ ps -aux > procesos
$ gedit procesos &

Espero que este artículo os haya ayudado en vuestras dudas acerca de los procesos. Estaré encantado de atender vuestros comentarios.

Si te ha parecido que este artículo es de utilidad, puedes compartirlo, dar me gusta, incluirlo en tus redes sociales, rellenar la encuesta o todo junto.

#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel