Archivos en la Categoría: Comandos Unix

El comando wall. Un mesaje a los usuarios del sistema.

El comando wall es usado por el usuario root para alertar a los usuarios acerca de algún evento importante. Por ejemplo

$ wall 
Hola a todos, este es un mensaje de el administrador.
Ctrl + D
$

produce

Broadcast message from root@localhost.localdomain (pts/0) (Wed Apr 17 
21:01:5Hola a todos, este es un mensaje del admnistrador.

en la consola de los usuarios conectados al sistema.

El Comando uptime

Un dato que puede ser indicativo de la calidad o estabilidad del sistema es el tiempo que la computadora ha pasado encendida sin ser reiniciada. Para ésto tenemos el comando uptime, que presenta, en mi caso, la siguiente salida:

$ uptime
 18:45:32 up  6:26,  3 users,  load average: 0.17, 0.80, 1.12

Se despliegan tres campos:
* La hora actual.
* El tiempo que ha permanecido el equipo conectado ininterrumpidamente. Para mi computadora, son 6 horas y 26 minutos, aunque para un servidor pueden ser muchos días.
* El número de usuarios conectados en el momento.
* Carga del sistema. Ésto es el número promedio de trabajos que se han realizado en los últimos 1, 5 y 15 minutos.
El comando top es similar a uptime, y ambos despliegan información de los archivos /proc. Por ejemplo, la instrucción

cat /proc/uptime

que da como resultado, en mi máquina

25563.82 11758.55

que es el tiempo sin reinicio en segundos.
También es posible ver el promedio de trabajos con la instrucción

cat /proc/loadavg

Secuencias Numéricas Usando Dos Puntos En Perl

En el lenguaje de programación perl, podríamos escribir los números del 1 al 15, usando al forma básica con un arreglo:

#!/usr/bin/perl
#Este script imprime una 
#secuencia de numeros del 1 al 15

print(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15);

O bien, podríamos hacer uso de la forma más económica siguiente, usando el operador de rango ..

#!/usr/bin/perl
#Este script hace uso del operador
#de rango .. para imprimir una 
#secuencia de numeros

print(1..15);

Ambos casos dan como resultado la salida

123456789101112131415

Vamos a revisar cada línea del programa:

#!/usr/bin/perl

Ésa es, como hemos visto, la llamada al intérprete de perl, y debe ir al principio de cada script.

#Este script hace uso del operador
#de rango .. para imprimir una 
#secuencia de numeros

Éstas líneas son unos comentarios, que indican de qué va el programa.

print(1..15);

Ésta línea es la parte importante del script. Un arreglo es un tipo de datos adecuado para almacenar una serie de elementos, creando así una lista. Los elementos de un arreglo son incluidos dentro paréntesis (). Dentro de ésos paréntesis, hemos escrito, en el primer programa, los números 123456789101112131415, en tanto que en el siguiente aparece 1..15. Esos dos puntos se llaman operador de rango. Éste operador funciona tomando el valor de la derecha y sumando 1 sucesivamente hasta alcanzar el valor numérico de la derecha. El siguiente script es un ejemplo de un uso distinto:

#!/usr/bin/perl
#Este script hace uso del operador
#de rango .. para imprimir una 
#secuencia de numeros

print(1,2,3,4..10,11);

Cada elemento del arreglo se separa por medio de una coma. Al llegar al elemento 4, aparece el operador de rango dos puntos, a partir de ahí se imprimen sucesivamente 5,6,7,8,9 y 10.
También es posible usar el operador con literales:

#!/usr/bin/perl
#Este script hace uso del operador
#de rango .. para imprimir una 
#secuencia de valores literales

print("A", "B".."z");

y la salida de éste script es la siguiente:

ABCDEFGHIJKLMNOPQRSTUVWXYZ

La razón de que ocurra ésto es que en el código ASCII, las letras del alfabeto se representan con números consecutivos.

Diagramas de Flujo y Esquemas Utilizando Dia

Dia es una herramienta diseñada para generar diagramas de flujo y en general circuitos: eléctricos, electrónicos, de redes de computadoras, cibertnéticos, UML, etc. Esta una herramienta que no viene incluída por default en la mayoría de las distribuciones linux, pero que viene en los repositorios y es fácil de instalar. En Ubuntu, basta con

sudo apt-get install dia

o en mandriva:

urpmi dia

Dia es lo más cercano a Raptor disponible para todas las distribuciones. Quienes tengan que escribir algoritmos usando diagramas de flujo, encontraran a dia bastante util. Además es posible exportar en formatos de imagen como PostScript, jpg, png, fig y otros.

Diagrama generado con dia


Para crear conectores entre los elementos del diagrama, basta con pulsar la opción línea en el menú y después dar click en el origen y en el destino.
Para crear un conector en zigzag (en forma de z) basta con pulsar la opción línea en zig-zag.
Para crear un conector en forma de L (o en forma arbitraria) basta usar la opción polinínea. Hacer click en el orígen, click en el primer vértice y luego click derecho y seleccionar la opción “Añadir Esquina”.
Aquí una página con un buen Manual de DIA

Cómo concatenar documentos pdf en linux

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

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

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

sudo apt-get install pdftk

O en Mandriva, como root:

urpmi pdftk

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

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

grep Cervantes Archivo.dat

que produce la salida:

Mario Cervantes
Carmen Cervantes

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

grep Patron Archivo1 Archivo2

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

grep Cervantes Archivo.dat Archivo.txt

produce

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

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

grep Cervantes Archivo*

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

who | grep elisa

y podríamos obtener algo como:

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

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

grep -i Cervantes Archivo.dat

y obtenemos la salida

Josefina Cervantes
Jose Luis Cervantes
Fernando cervantes

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

grep 'Elisa Griensen' -i Archivo.dat

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

Elisa griensen

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

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

grep 'Elisa Griensen' -in Archivo.dat

y obtenemos:

6:Elisa griensen

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

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

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

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


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

lspci

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

lspci | grep -r Ethernet

que en mi computadora presenta:

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

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

lspci | grep -r Audio

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

dmesg | grep eth

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

El comando finger

Para saber cuántos usuarios tiene el sistema, se puede ver el directorio /etc/passwd. El comando finger muestra información del usuario. Si somos administradores, entonces como root podemos conocer el nombre de login, el directorio, el nombre completo y otros datos de los usuarios. Supongamos que tenemos un usuario llamado elisa; la instrucción

finger elisa 

produce:

Login: elisa     			Name: Elisa Griensen
Directory: /home/elisa         	Shell: /bin/bash
On since Sun Jun 10 15:44 (CDT) on pts/0 from :0
   1 hour 52 minutes idle
On since Sun Jun 10 17:31 (CDT) on pts/1 from :0
   58 seconds idle
     (messages off)
On since Sun Jun 10 17:36 (CDT) on pts/2 from :0 (messages off)
No mail.
No Plan.

que muestra el login, la shell por defecto, el nombre de la persona, el tiempo que lleva conectado y si tiene o no mensajes de correo.
Es posible acceder a esta información de manera remota por medio de la siguiente instrucción:

finger elisa@(direccionIP)

Sin embargo, es posible que al hacer eso simplemente se muestre la siguiente línea:

finger: conect: conection refused

Esto es porque la mayoría de las distribuciones tienen desactivado el servicio de acceso a finger vía remota por razones de seguridad.¿Por qué se desactiva el acceso a finger? Porque es muy probable que aquí se encuentren teléfonos, direcciones, nombres e información personal en general. Lo que hay que hacer es instalar el paquete inetutils-inetd fingerd, digamos con apt-get:

apt-get install inetutils-inetd fingerd

Con lo cual será posible acceder a la información desde una terminal remota.

¿Cómo puedo cambiar la hora en linux?

Cada uno de las distribuciones proporciona un método gráfico para hacer el cambio de hora y fecha. Sin embargo, hacerlo desde la consola funciona para todos los sistemas Unix. Para esto existe el comando date.
Para establecer una nueva fecha y hora, es necesario escribir como root la instrucción

date -s "2012/03/24 23:11"

Si ahora escribimos la instrucción

date

se muestra la fecha y la hora actualizadas

sáb mar 24 23:11:11 CST 2012

El comando Unix pg

Una de las características más elegantes del sistema operativo Unix, es que cuando ejecuta un comando o utilidad, no supone que la salida y entrada estándar son la pantalla y el teclado. En realidad los programas y utilidades no saben de dónde viene y hacia dónde se dirigen los datos. Por esta razón los comandos pueden resultar poco amables con el usuario (considere por ejemplo el editor ed). Pero como ventaja, esto permite que la salida estándar de un comando pueda ser redireccionada y usada como la entrada estándar de otro comando, creando una especie de “tubería” o vía de comunicación entre ellas. Para crear esta conexión o tubería (los creadores del término son los estadounidenses, que usan la palabra pipeline) se usa el metacaracter barra vertical (|). Uno de los comandos más propiamente usados como conexión por tubería con otras utilidades es el comando pg. pg indica paginación. Cuando se lista el contenido de un directorio con el comando ls, o cuando se ve el contenido de un archivo cualquiera, por ejemplo con el comando cat, puede ocurrir que, si los datos ocupan más de lo que puede presentar nuestra pantalla, la velocidad a la que se despliegan no permita leerlos. El comando pg hace que los datos se presenten por páginas. Para avanzar sólo es necesario teclear enter. Al final del archivo se muestra el mensaje (EOF) y se hace una pausa.
Supongamos que tenemos un archivo llamado Octal.c
La instrucción

cat Octal.c

hace que en mi pantalla se presente lo siguiente:

 potencia *= 8;
 break;
 case '4':
 decimal += 4*potencia;
 potencia *= 8;
 break;
 case '5':
 decimal += 5*potencia;
 potencia *= 8;
 break;
 case '6':
 decimal += 6*potencia;
 potencia *= 8;
 break;
 case '7':
 decimal += 7*potencia;
 potencia *= 8;
 break;
 default:
 if ( '\n' != b[i])
 {  // Abre if
 printf("\nERROR. LA CADENA NO ES VALIDA!\n");
 valido = 0;  // El octal recibido no
              // es valido
 printf("\nEste caracter no es valido: ");
 putchar(b[i]);
 printf("\n");
 } // Cierra if
 break;

 }   // Cierra switch
 }  // Cierra for  

 if ( 1 == valido )
 printf("\nEl valor decimal es: %d\n", decimal);
 else
 printf("\nEl numero introducido no es valido.\n");
 }  // Cierra Imprime

Lo cual es la última parte del archivo. En cambio con el uso de la instrucción

 cat Octal.c | pg

se obtiene:

 /*Este programa convierte de octal
  a decimal */

 #include <stdio.h>
 #define Tamano 35
 // La variable Tamano se fija en 35
 // porque los enteros de cuatro bytes
 // ocupan 32 bits y la ultima entrada
 // de una cadena en un arreglo es \n

 /*Prototipo de funcion Recibe*/
 /* Esta funcion recibe la cadena
    pero no verifica que sea valida */
 void Recibe( int a[]);

 /*Prototipo de funcion Imprime*/
 /* Si la cadena es valida se calcula
 e imprime su equivalente decimal, si no
 se manda un mensaje al usuario y se termina
 el programa */

 void Imprime( int b[]);

 /*///////////////////////////////
 // MAIN
 ////////////////////////////////*/  

 int main()

 {       // Abre main
 int arreglo[Tamano];
 // En este arreglo se recibiran los valores
 // de la cadena octal
 int evaluar;
 // La variable evaluar lleva el control
 // de la legalidad de la cadena, es decir
 // se introducen digitos validos como 2, 1
 // o se introducen valores invalidos como
 // 9, e, h, etcetera

 // Un  mensaje que avisa al usuario que
 // hace el programa
 printf("\nEste programa recibe un numero "
         "octal y lo convierte a decimal.\n");

:

Lo cual es la primera parte del archivo. Los dos puntos del final indican que se debe teclear enter para ver la siguiente pantalla. Si sucesivamente tecleo enter, puedo ver todo el contenido del archivo.

EL COMANDO PG ACEPTA LAS SIGUIENTES OPCIONES:
– n (donde n debe sustituirse por cualquier número) indica el número de líneas a desplegar. La instrucción

 cat Octal.c | pg - 10

muestra el contenido del archivo Octal.c en pantallas de 10 líneas cada vez.
– c limipia (clear) la pantalla antes de presentar el contenido del archivo.

 cat Octal.c | pg -c

– e no hace pausa al final del archivo.
– p CADENA cambia el prompt por defecto (:) por la CADENA.
Así que con

 cat Octal.c | pg -10 -c -p ELISA

se limpia la pantalla, se muestra el contenido de Octal.c en pantallas de 10 líneas al final de las cuales aparece como promt la palabra ELISA:

 /*Este programa convierte de octal 
  a decimal */

 #include <stdio.h>
 #define Tamano 35
 // La variable Tamano se fija en 35
 // porque los enteros de cuatro bytes
 // ocupan 32 bits y la ultima entrada
 // de una cadena en un arreglo es \n
 
 ELISA

Se puede paginar el archivo con la opción
– p %d que numera las páginas.

 cat Octal.c | pg -10 -c -p %d

produce como salida

 /*Este programa convierte de octal 
  a decimal */

 #include <stdio.h>
 #define Tamano 35
 // La variable Tamano se fija en 35
 // porque los enteros de cuatro bytes
 // ocupan 32 bits y la ultima entrada
 // de una cadena en un arreglo es \n
 
 1

+ n (donde n es cualquier número de línea)
empieza el despliegue desde la línea n.
BUSCAR UNA CADENA CON EL COMANDO PG
+ /CADENA/
empieza el despliegue desde la primera aparición de CADENA.
Por ejemplo,

cat Octal.c | pg -10 -c -p %d +/main/

presenta en pantalla

 int main()

 {       // Abre main 
 int arreglo[Tamano];
 // En este arreglo se recibiran los valores
 // de la cadena octal 
 int evaluar; 
 // La variable evaluar lleva el control
 // de la legalidad de la cadena, es decir
 // se introducen digitos validos como 2, 1
4