martes, 28 de febrero de 2012

Curso Basico de Linux

Como ya saben soy usuario linux pero a un nivel muy basico y siempre he leido manuales sobre linux pero a veces en ingles y los de español ya con un nivel medio avanzado asi que rezandole a san google encontre este que a mi gusto es de los mas sencillo y explicados que hay, me ha servido de mucho, aqui lo comparto con ustedes y con los que quieran saber y meterse a este potente sistema operativo.
Te recomiendo que lo leas despacio por partes para que le saques mas provecho 

                                     CURSO BASICO DE LINUX


Linux da soporte a varios usuarios, cada uno tiene su nombre de usuario (username) y su contraseña (password).
En Linux debe haber, por lo menos, un usuario llamado "root", a este usuario se le llama "super-usuario" por que tiene permisos para hacer absolutamente todo.
Pero lo normal es que, aparte del root, haya otro usuario, para los asuntos cotidianos.
Solo se puede añadir un usuario siendo root, con los comandos "useradd" y "adduser" que veremos mas adelante.
Para cambiar la contraseña del usuario con el que estamos logeado tecleamos "passwd" escribimos la contraseña actual, la nueva y volvemos a meter la nueva, si la nueva es muy pequeña nos mostrara el mensaje "Bad: new password is too simple", entonces debemos escribir una contraseña mas larga, cuando todo sea correcto mostrara el mensaje "passwd: password updated successfully".
Aquí tenemos un ejemplo (no se mostraran el numero de caracteres según vayas escribiéndolos):
$ passwd
Changing password for pedvi
(current) UNIX password:
Enter new UNIX password:
Retype new UNIX password:
Bad: new password is too simple
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully

Loggin-in:

Una vez arrancado el sistema vera esto en la pantalla (suponiendo que localhost y pedvi fueran el nombre del sistema y el nombre de usuario respectivamente):
localhost login
Ahora escribe tu nombre de usuario y pulsa <enter>.
localhost login: pedvi
Password:

Escribe tu contraseña, por seguridad, no se mostrara en pantalla mientras teclea, por lo que hay que ser cuidadoso al escribir.
Si escribes mal la contraseña o el nombre de usuario se mostrara este mensaje:
login incorrect
Y tendrás que volver a escribirla.

Para cerrar la sesión teclea:
pedvi@localhost:~$ exit
Así podrás logearte como otro usuario.

 

La consola:

La consola del sistema es el monitor y el teclado conectados directamente al sistema.
Linux permite el acceso a consolas virtuales (VCs), las cuales permiten tener mas de una sesión abierta a la vez.
Para comprobarlo entramos a en sistema como antes, ahora pulsa <alt+f2> te preguntara otra vez por tu nombre de usuario y contraseña, para volver a la primera sesión pulsa <alt+f1>. Normalmente solo están habilitadas 4 VCs pero podemos habilitar hasta 12.
Por ejemplo, podemos estar instalando algún programa en la VC1 y mientras escribiendo una carta en la VC2.
El uso de varias VCs a la vez nos da una idea de la gran capacidad multitarea de Linux, MS-DOS no permite esto.

El interprete de comandos:

Un interprete de comandos (o shell) es un programa que recoge lo que el usuario ha introducido y lo traduce a instrucciones, en el MS-DOS el interprete de comandos es el COMMAND.COM e incluso el mismo Windows. En Linux existen muchas shell como bash, ssh, o el sistema X-Window.
El interprete arranca nada mas terminar de arrancar el sistema.
Por ejemplo, veamos un inicio de sesión:
localhost login: pedvi
Password: Welcome to localhost!

pedvi@localhost:~$

pedvi@localhost:~$ es el prompt del interprete que indica que esta listo para recibir ordenes, a partir de ahora lo abreviaremos usando solamente "$" para un usuario normal y "#" para el root.

Cuando el interprete de comandos recibe un comando primero analiza la expresión y luego entrega la orden al comando .
Por ejemplo:
$ cp hola /home/pedvi
En este caso no tendría que expandir ni modificar nada, simplemente entregaría "hola" y "/home/pedvi" al comando "cp" como argumentos (más adelante veremos para que sirve este comando).
$ cp ho* ~
Ahora si tendría que cambiar unas cosas: El "ho*" lo sustituiría por cualquier archivo del directorio cuyo nombre empezara por "ho" y "~" lo sustituiría por el directorio del usuario (en este caso /home/pedvi, en el caso del usuario2 /home/usuario2 y en el caso del root /root).
En el caso de que solo hubiera un archivo que empiece por "ho", las dos ordenes hacen lo mismo.

Pero, ¿como sabe el interprete donde esta el comando "cp"?


 
Muy fácil: en la mayoría de sistemas operativos existe una variable que contiene la dirección donde están los comandos.
En Linux esta variable se llama "PATH", para ver lo que contiene una variable usaremos en comando "echo" que sirve para mostrar los argumentos que se le den.
Para mostrar el contenido de una variable con "echo" hay que anteponer "$" al nombre de la variable:
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games

El interprete buscara el comando en estos directorios en el orden en el que están en PATH.
Para cambiar el contenido de una variable haremos:
$ variable=valor
$ export variable

En el caso de PATH haríamos lo siguiente para añadir a su valor el directorio /home/pedvi:
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games
$ PATH=/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games:/home/pedvi
$ export PATH

Es importante que copiemos el valor de PATH antes de cambiarla para que no perdamos ningún directorio.

Ordenes y comandos:

Veamos un ejemplo de un comando:
$ make something
make: *** No rule to make target 'something'. Stop.

Aquí ejecutamos el comando "make" con el argumento "something".
El comando make se usa para compilar programas según las normas de un archivo "makefile".
Cuando el interprete recibe una orden hace algunas cosas antes de analizar la expresión.
Primero busca si la orden es interna, si no lo es, mira a ver si es un "alias" de otra orden, si tampoco lo es, busca en los directorios de PATH y ejecuta el comando con los argumentos, si por ultimo esto no da resultado, escribe un mensaje de error en la pantalla: "(comando no encontrado) : command not found".
Para saber donde esta el comando y el manual (ahora vemos que es el manual) escribimos "whereis (comando)", por ejemplo para saber donde esta el comando "cp" escribimos:
$ whereis cp
cp: /bin/cp /usr/share/man/man1/cp.1.gz

 
Vemos que "cp" esta en /bin y su manual esta en /usr/share/man/man1.
COMANDOS BÁSICOS:
Pequeña lista de comandos.

date muestra la fecha del sistema.

date -u mmddhhhhaa cambia la fecha del sistema, ej. 1202120095 es igual a mes 12, día 02, hora 12:00 y año 1995.

logout sale de la actual sesión.

login inicia una sesión.

^D (Ctrl-D) Pausa el programa actual.

Alt+F1 inicia una consola virtual (varias a la vez: F1,F2,F3...)

passwd cambia el password del actual usuario.

^C aborta programa en ejecución.

^S paraliza la pantalla.

^Q anula la paralización de la pantalla.

who lista los usuarios conectados.

whoami lista tu nombre.

who you are lista tu nombre.

mail nombre envía correo, se finaliza escribiendo un punto en una línea sola.

mail visualiza tu correo, teclea ? para ayuda.

ls lista directorios y ficheros.

ls -i lista directorios y ficheros con sus i-números.

ls -a lista directorios y ficheros en orden alfabético.

ls -s lista directorios y ficheros con su tamaño en bloque (1 bloque= 512 bytes)

ls -r lista directorios y ficheros en orden inverso. 


 ls -u lista directorios y ficheros según último acceso.

ls -l lista todos los directorios y ficheros en formato largo.

Head -nº lines selecciona la primera línea (ej. ls|head -1 lines)

cat file file ... visualiza seguidamente los ficheros indicados.

cat file file > file graba los dos archivos en uno.

ln file link crea un enlace a un archivo, los dos contienen el mismo fichero físico, si cambias uno, cambia el otro. Pero si borras uno todavía queda el otro.

cp file file copia ficheros.

rm file borra ficheros.

mv file file mueve o cambia de nombre.

pwd muestra el directorio actual.

cd cambia de directorio.

mkdir directorio crea un directorio.

rmdir directorio borra un directorio.

comando & hace que el proceso sea desatendido en 2º plano (background).

ps [nº] muestra los procesos desatendidos.

ps alx muestra los procesos desatendidos asociados a la terminal (a), los no asociados (x) y hace una lista larga (l).

Elementos de la lista larga:
STA (Estado del proceso)
O (Inexistente) S (Durmiendo) W (Esperando)
I (Intermedio) R (Ejecutándose) Z (Terminado)
Z (Parado)
UID (Nº de Identificación del propietario)
PID (Nº de Identificación del proceso)
PPID (Nº de Identificación del proceso padre)
PRI (Prioridad, nº altos=baja prioridad)
WCHAN (Suceso al que espera) NICE (Nº para calcular la pri.) 


 TTY (Terminal) STTY (Tiempo de ejecución)

kill nº detiene la ejecución de un proceso en background.

at hora o fecha <<EOF ejecuta algo a una hora establecida (para salir escribir EOF)
Posibilidades para hora o fecha: 8am, 2130, 12N fri week (siguiente semana), 2PM apr 3, now +1minute, now +1 hour, 4PM +2 days, 1PM tomorrow,...

comando ; comando se pueden escribir varios comandos a la vez.

comando > file redirecciona la salida a un archivo.

(comando ; comando) > file redirecciona toda la salida del conjunto a un archivo.

comando >> file redirecciona la salida a un archivo, pero lo añade al final de este.

comando < file > file redirecciona de forma contraria para acabar llevando el resultado a un archivo.

comando | comando tubo (pipeline) la salida del 1º la envía hacia el 2º.

*, ?, [...], ... caracteres de sustitución.

echo * lista directorios y ficheros.

echo -n "Hoy es `date`, hola $variable" hace eco sin carro de retorno (-n) de la frase Hoy es, ejecuta el comando date (entre comillas graves), hace eco de hola y imprime el contenido de la variable "variable". Para eliminar los valores especiales de algunos caracteres deberemos escribir / antes, ejemplo echo "Hola /"Pepe/"" escribira Hola Pepe.

mesg y permite que te escriban los usuarios del sistema.

mesg n prohibe que te escriban a los usuarios del sistema.

mesg muestra el estado actual (escribir o no).

tty muestra tu número (archivo) de terminal.

write nombre [tty] para comunicarse con un usuario conectado al sistema. Para salir ^D, para indicar al otro el fin del mensaje -oo-, y el fin de la comunicación -oo-. Si el usuario pertenece a otra terminal, se debe indicar. Si el usuario tiene el mesg en no o esta realizando una tarea específica no podremos comunicarnos.

cmp file file comprueba si son idénticos, si lo son no aparece ninguna salida.

 
comm [-nº] file file lista las palabras comunes de los dos archivos, en el número se indica la columna a comparar: 0,1,2,3.

diff file file lista las palabras diferentes de los dos archivos.

find . -file ... -mtime 1 -size +10 -type fbusca en el directorio actual los ficheros con dicho nombre, que hayan sido modificados hace 1 día, con un tamaño mayor a 10 bloques y del tipo fichero.

find / -name ... -atime 1 -size -20 -type d busca en el directorio actual los directorios con dicho nombre, que hayan tenido acceso hace 1 día, con tamaño menor que 20 bloques y del tipo directorio.

find . -name -ok rm {} \; busca en el directorio actual y borra los ficheros encontrados que cumplan los requisitos.

lpr file imprime el archivo.

pr file imprime el archivo junto a un encabezamiento, la fecha, hora, ...

tail nº file muestra la cola de un archivo, en nº se debe especificar: +2l (a partir de la segunda línea por arriba), -10l (a partir de la décima línea por abajo). Si en lugar de l (línea) podemos escribir b (bloque) ó c (carácter).

tr caracteres caracteres cambia los caracteres por los indicados a continuación. (Ejemplo: tr abc ABC).

tee file muestra los datos en un punto intermedio.

du muestra el tamaño por bloques de cada archivo y directorio.

du -s muestra el tamaño total por bloques.

file file indica el tipo de archivo que es (empty\ cannot open\ directory\ English text\ ascii text\ data).

stty información sobre nuestro terminal.

stty [-] raw lee carácter a carácter. Se anula añadiendo el signo - al comando.

stty [-] cooked lee línea a línea. Se anula añadiendo el signo - al comando.

stty [-] cbreak mezcla de los dos anteriores. Se anula añadiendo el signo - al comando.

stty [-] nl no retorna el carro hasta el principio (se anula con ^J).

 
stty [-] echo no se ven las pulsaciones en pantalla. Se anula añadiendo el signo - al comando.

sort file muestra en pantalla el archivo ordenado por la 1ª columna (para indicar la segunda columna añadir +1 y así sucesivamente).

sort file -u muestra en pantalla el archivo ordenado por la 1ª columna sin las líneas duplicadas.

sort file -b muestra en pantalla el archivo ordenado por la 1ª columna ignorando espacios en blanco.

sort file -f muestra en pantalla el archivo ordenado por la 1ª columna distinguiendo entre minúsculas y mayúsculas.

sort file -r muestra en pantalla el archivo ordenado por la 1ª columna en orden inverso.

sort file -c comprueba si el archivo ya esta ordenado.

grep palabra file busca unos caracteres determinados en un fichero.

grep -v palabra filebusca las líneas que no contienen dicha palabra.

grep -c palabra file muestra el número de líneas que contienen la palabra.

grep -y palabra file busca la palabra en el fichero sin distinguir entre minúsculas y mayúsculas.

grep -n palabra file busca la palabra y muestra su línea con el número de esta.

uniq file muestra el archivo sin las líneas que estén repetidas.

wc file muestra el número de líneas, palabras y caracteres (en este orden) del archivo.

wc -l file muestra el número de líneas del archivo.

wc -w muestra el número de palabras del archivo.

wc -c muestra el número de caracteres del archivo.

cal [nº mes] nº año imprime un calendario del mes y/o año indicado. Mes: 1-12, año 1-9999.

newgrp grupo cambia de grupo.

sum file suma las palabras de un archivo.

expr nº + nº suma +, resta -, multiplica *, divide /,... una expresión. 


 
wall mensaje manda un mensaje a todos los usuarios. (Solo lo recibirán los usuarios que tengan su sistema configurado para poder recibir estos mensajes)

id muestra nuestro UserId y el GroupId.

chmod nºnºnº file cambia los permisos de un archivo. 1: Permiso de ejecución (x), 2: Permiso de escritura (w), 3: Permiso de lectura ( r). Se deben sumar para poner más de uno. El primer número corresponde al creador del archivo, el segundo al grupo del creador, y el tercero al resto de usuarios. Ej. 666 : todo el mundo tiene permiso de todo.

chown nombre file cambia el propietario de un archivo.

chgrp grupo file cambia el grupo del propietario de un archivo.

umask muestra los permisos por defecto de los archivos creados. Ej. 022 entonces 666-022=644, es decir usuario permiso de w, r, grupo permiso de r y lo otros permiso de r.

umask nº cambia los permisos por defecto de los archivos creados. Ej. umask 000: todo el mundo tiene todos los permisos al ser creado un archivo.

Formas de pedir ayuda:

Muchas veces no sabemos que opciones tiene o para que sirve exactamente tal o cual comando, para saberlo escribimos "man (comando)".
Estas páginas del manual se encuentran en casi todos los sistemas UNIX y son la mayor (junto con los textinfo) fuente de información sobre los comandos que puedes encontrar.
Veamos un ejemplo, otra vez con el comando "cp":
$ man cp
Las páginas del manual están formateadas con "troff", el formateo en troff es bastante difícil, pero como puedes ver, da muy buenos resultados ya que toda la información esta muy bien organizada, la mayoría están en ingles pero los proyectos de documentación como LuCas, entre otros, están trabajando en su traducción. Para movernos en un manual lo haremos con las flechas de dirección y para salir pulsamos "q", para más información (aunque parezca tonto) podemos escribir "man man" para ver el manual del manual.

A parte de los manuales existe bastante información en formato "Textinfo" para consultar el Textinfo del comando "ls" tecleamos:
$ info ls
Estos documentos son mas complicados, ya que se dividen en menús y en submenús, para obtener ayuda de como manejarse en uno de estos documentos visita la pagina del manual "man info" (también puedes hacerlo al revés: "info man"). Para salir pulsaremos la tecla "q".

 
Archivos y carpetas:
En la mayoría de sistemas operativos (Linux incluido) existe el concepto de archivo o fichero que, esencialmente, es un conjunto de información a la que se le ha asignado un nombre.
Los archivos se identifican por su nombre (obviamente), en Linux no hay ningún formato estándar para los nombres de los archivos, en general, pueden tener cualquier carácter menos "/" y están limitados a 256 caracteres de longitud.

Una carpeta o directorio es simplemente una colección de archivos, los directorios, como las carpetas, tienen un nombre para poder identificarlas que siguen las mismas reglas para los nombre que los archivos.
Además están estructurados en forma de árbol, es decir, pueden contener otros directorios.

Para acceder a un archivo se puede usar una ruta relativa o una absoluta:

Si dentro de /home/pedvi hay una carpeta llamada trabajos y esta contiene el archivo "mates" para acceder desde /home/pedvi escribiríamos /trabajos/mates, esto es una ruta relativa, relativa a donde estamos ahora, por que si hacemos lo mismo en /bin, nos pondría algo así: "No such file or directory".

Para poder acceder desde cualquier lugar del sistema tenemos que usar la ruta absoluta:

En el MS-DOS y en el Windows el directorio raíz (donde no se puede ir mas arriba) es el disco duro o disquete (C: o A:), el UNIX y Linux el directorio raíz es "/" y los directorios se separan también mediante "/" (por eso no se puede poner "/" como parte de un nombre de un archivo).
La ruta absoluta accesible desde cualquier lugar del sistema seria /home/pedvi/trabajos/mates, esto nos llevaría al archivo "mates" de la carpeta "trabajos" contenida en la carpeta de un usuario llamado "pedvi" que esta en la carpeta "home" que a su vez esta en "/".
Aquí podemos ver un esquema de los directorios mas importantes en Linux:

Arbol de directorios de Linux



Linux no se basa en la extensión para saber que tipo de archivo es cada uno, si no que utiliza lo que se llama "magic numbers", este sistema determina el tipo de archivo mediante unos test que comprueban que tipo de archivo es. El comando para mostrar el tipo de archivo es file.

 
$ file hola
hola: ASCII text
$ file banner
banner: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), for GNU/Linux 2.2.0, dynamically linked (uses shared libs), stripped
$ file foto
foto: PNG image data, 480 x 119, 4-bit colormap, non-interlaced
Este sistema es mucho mas eficaz que el de las extensiones.
Hay que tener en cuenta que el sistema puede saber que tipo de archivo es pero no tener ninguna aplicación con que visualizarlo.

Moviéndose por el sistema:

Para saber en que directorio estamos escribiremos:
$ pwd
/home/pedvi

Ya sabemos donde estamos, ahora nos moveremos a "/usr" que, como ya sabréis, es el directorio donde se almacenan los archivos los comandos no esenciales y algunos ficheros de configuración, así que cuidado con lo que tecleas.
El comando para ir a un directorio es: "cd (directorio)"
Tecleamos:
$ cd /usr
pedvi@localhost:/usr$

Ahora ya estamos en "/usr", para comprobarlo podemos hacer un "pwd", nos devolverá un "/usr".
Para ir a /usr hemos usado la ruta absoluta.
En /usr hay unos directorios interesantes como /usr/bin, /usr/man, etc.
Iremos a /usr/etc (en la bash la línea que empiece por "#" sera ignorada, la toma como un comentario):
#Comprobamos que estamos en /usr
$ pwd
/usr
$ cd etc
$ pwd
/usr/etc

Ahora hemos usado una ruta relativa, relativa a /usr, para volver a /usr podemos teclear la ruta absoluta "cd /usr" o podemos usar un atajo: "cd .." el ".." indica a cd que tiene que ir al directorio padre, todas las carpetas tienen los directorios "." y "..", la carpeta "." hace referencia a la carpeta actual, por lo que hacer "cd ." es lo mismo que no hacer nada. La carpeta ".." esta referenciada a la carpeta padre (en este caso /usr).
Si tecleamos solamente "cd" nos devolverá a nuestra carpeta de usuario:
$ pwd
/usr/etc
$ cd .
$ pwd
/usr/etc


 
$ cd ..
$ pwd
/usr
$ cd
$ pwd
/home/pedvi

Ahora ya sabemos movernos entre las carpetas.

Fisgoneando los archivos:

Para ver el contenido de un directorio usaremos el comando "ls", el comando ls sin opciones no mostrara los archivos que empiezan por ".", estos archivos suelen ser configuraciones como ".bash_historia" o "bash_profile", para ver estos archivos usamos la opción -a (ls -a).
ls tiene muchas opciones, todas ellas son del estilo "ls -(letra).
Las opciones de un comando las podemos encontrar viendo su manual (man ls).
Las opciones mas útiles de ls son las siguientes:
#Con -a muestra todo el contenido"
$ ls -A
.bash_history .bash_profile .bashrc

#Con -F muestra "/" si se trata de un directorio, "*" si es un ejecutable, "@" si es un enlace y nada si es un archivo normal.
$ ls -F
enlace@ Archivo.normal.jpg carpeta/

#ls -l muestra casi toda la información sobre los archivos
$ ls -l
-rw-r--r-- 1 peter peter 1254 Nov 26 16:16 frame_derecho.html
drwxr-xr-x 2 peter peter 4096 Feb 10 20:17 hola
-rw-r--r-- 1 peter peter 1440 Nov 26 16:16 index.html
drwxr-xr-x 2 peter peter 4096 Feb 10 20:17 kk
-rw-r--r-- 1 peter peter 1445 Nov 2 20:27 linex2.jpg

La 1ª columna muestra los permisos, esta dividida en grupos de 3, el 1º "sobra" (no cuenta en ningún "grupo") ya que indica si es una carpeta "d" o si es un archivo "-".
La 2ª muestra el numero de enlaces fuertes que tiene el archivo, para las carpetas además es el numero de carpetas que tiene dentro (por defecto dos "." y "..").
La 3ª muestra el propietario del archivo y la 4ª el grupo.
La 5ª muestra el tamaño en bytes.
La 6ª es la fecha y la hora de ultima la modificación.
Y la 7ª el nombre.
#Con -R muestras todo el contenido de la carpeta recursivamente, 1º se muestra el contenido de la carpeta y luego se va mostrando el contenido del resto ordenadamente (muy útil para mirar todo).
$ ls -R
.:
atrib banner banner2 banner3 h public_html

./carpeta1:
1
ls: ./atrib/1: Permission denied

 

 
./carpeta2/CursoLinux:
archivo1 archivo2 archivo3

./carpeta2/subcarpeta1:
archivos....

./carpeta2/subcarpeta2:
archivos...

#Con ls -S ordenas los archivos por su tamaño
#Con ls -1 muestra un archivo por columna.
$ ls -1
archivo1
archivo2



El 1º grupo de 3 muestra los permisos del propietario del archivo (mostrado en la 3ª columna).
El 2º grupo muestra los permisos del grupo del propietario (mostrado en la 4ª columna).
El ultimo grupo muestra los permisos del resto usuarios que no son ni el propietario ni de su grupo.
Veamos ahora un "grupo": "rwx" la r significa permiso de lectura (de read), la w permiso de escritura (de write) y la x permiso de ejecución (si no es ni una ejecutable ni una carpeta estará en blanco "-", si se trata de un directorio es permiso de entrada).
Entonces si un archivo tiene los siguientes permisos: -rw-rw-rw- quiere decir que todo el mundo podrá verlo y modificarlo.
Si tiene los siguientes permisos: -rw-r--r-- todo el mundo podrá verlo pero solo el propietario (y el root) podrá modificarlo.
Con los permisos se pueden producir casos curiosos como "d---------", nadie podrá ni siquiera entrar en el directorio, o "d--x--x--x" todo el mundo podrá entrar pero nadie podrá ver lo que hay ni crear nada.
En el caso en el que no puedas hacer algo el comando "protestara":
$cd 1
-bash: cd: 1: Permission denied

Cambiando permisos:
Para cambiar los permisos (solo lo puedes hacer si eres el propietario del archivo) se usa el comando "chmod (permisos) (archivos)".
Una forma de cambiar los permisos del archivo hola seria la siguiente:
$ ls -l
total 4
-rw-r--r-- 1 peter peter 0 Feb 17 18:34 hola
$ chmod ugo+r+w+x hola
$ ls -l
total 4
-rwxrwxrwx 1 peter peter 0 Feb 17 18:34 hola
¿Que hemos hecho?:
Muy simple, en la sentencia "chmod ugo+r+w+x hola" le hemos indicado al comando chmod que cambie los permisos del usuario (u), del grupo (g) y del resto (o) añadiendo permiso de lectura (+r), escritura (+w) y de ejecución(+x) al archivo "hola".


 
Otra manera de hacerlo (mas rápida) es usando el siguiente formato "chmod xxx archivo" en donde xxx son 3 números del 1 al 7 el 1º son los permisos del usuario, el 2º los permisos del grupo y el 3º los permisos del resto según la siguiente tabla:
Representación decimal
Representación binaria
Significado
0
000
---
1
001
--x
2
010
-w-
3
011
-wx
4
100
r--
5
101
r-x
6
110
rw-
7
111
rwx
Que en resumen es esto:

0 --> Fichero de sistema, no posee permisos para el resto de usuarios
1 --> ejecución
2 --> Escritura
3 --> 1+2 --> ejecución y escritura
4 --> Lectura
5 --> 1+4 --> ejecución y lectura
6 --> 2+4 --> Escritura y lectura
7 --> 1+2+4 --> ejecución, escritura y lectura

Veamos un ejemplo:
$ ls -l
total 4
-rw-r--r-- 1 peter peter 0 Feb 17 18:34 hola
$ chmod 777 hola
$ ls -l
total 4
-rwxrwxrwx 1 peter peter 0 Feb 17 18:34 hola
Como ves es lo mismo hacer un chmod ugo+r+w+x hola que hacer un chmod 777 hola, solo que lo último es más rápido.

Enlaces:

Los enlaces permiten dar a un único archivo varios nombres.
Todos los archivos son identificados por un numero de inodo.
Una carpeta es una lista de nº de inodos con sus correspondientes nombres
Hay dos tipos de enlaces: los enlaces duros y los blandos.
Los enlaces blandos (o simbólicos) son simples "puentes" a otro archivo, por ejemplo: tenemos un archivo en /usr/games llamado banner y cada vez que queremos ejecutarlo 


 
debemos hacer un cd "/usr/games/" y luego "banner", en vez de hacer todo esto creamos un enlace simbólico a /usr/games/banner de esta manera:
$ ln -s /usr/games/banner
$ ls -l
lrwxrwxrwx 1 peter peter 17 Feb 18 23:36 banner -> /usr/games/banner

De esta manera nos creara en el directorio actual un archivo llamado banner que enlaza con el archivo /usr/games/banner.
Observa la "l" que hay a la izquierda del todo de los resultados del ls -l, indica que es un enlace (link).
Si queremos que tenga otro nombre u otra dirección haremos:
$ ln -s /usr/games/banner /tmp/pruebas/mensaje
Entonces nos creara un archivo llamado mensaje en /tmp/pruebas que enlaza con banner en /usr/games.
También podemos enlazar con un directorio, aunque hay que tener en cuenta que hacemos un cd.. en el enlace volveremos no a donde apunta el enlace, si no, a desde donde enlaza. Veámoslo en un ejemplo:
$ ln -s /usr/games juegos
$ ls -l
total 0
lrwxrwxrwx 1 peter peter 10 Feb 19 23:06 juegos -> /usr/games
$ cd juegos
$ pwd
/home/peter/juegos/juegos
$ ls
banner
$ cd ..
$ pwd
/home/peter/juegos
$ ls
juegos

Los enlaces duros son enlaces a un inodo, esto significa que mas de un nombre puede apuntar a un archivo.
Para crear un enlace duro simplemente haremos lo siguiente:
$ ls -i
22192 archivo.original
$ ln archivo.original enlace
$ ls -i
22192 archivo.original 22192 enlace

Fisgoneando en los archivos:

Para ver el contenido de un archivo de texto se usar el comando cat o si es muy largo el comando more o less.
Con cat veremos el contenido de una vez, si es muy largo no nos dará tiempo para verlo entero, para eso usaremos el comando more o less, para pasar de pagina con less o more pulsamos <enter> o <flecha abajo>, para salir pulsamos <q>.

 
$ cat hola.txt
hola, blablabla
blablabla
...
fin

$ less hola.txt
hola, blablabla
...
bla
hola.txt
(pulsamos intro)
:
blablabla
(pulsamos intro)
:
fin
(END)

Creando archivo y carpetas:

Para crear un archivo usamos el comando touch (nombre del archivo), el comando touch sirve para cambiar la fecha y hora de última modificación a la fecha y hora actual, su uso para crear archivos es este:
$ ls
$ touch hola
$ ls
hola

Acabamos de crear el archivo 'hola', para crear mas de un archivo a la vez escribiremos los nombre unos detrás de otros separados por un espacio:
$ touch h hola h2 hola2
$ ls
h h2 hola hola2

Para crear una carpeta usamos el comando mkdir (make directory) de la misma forma que touch:
$ ls
$ mkdir hola
$ ls
hola
$ ls -F
hola/

Para crear mas de una carpeta a la vez hacemos lo mismo que con touch.

Borrando archivos y carpetas:

Para borrar un archivo usamos el comando rm:
$ ls
#Creamos unos archivos
$ touch h hola


 
$ ls
h hola
#Borramos de forma normal
$ rm h
$ ls
hola
#Intentamos borrar un archivo que no existe
$ rm hh
rm: cannot lstat `hh': No such file or directory
$ rm -f hh
#Forzamos a borrar un archivo exista o no
$ rm -i hola
#Borramos preguntando antes, si la respuesta empieza por 'y' se borra, en otro caso no.
rm: remove regular empty file `hola'? y

Para borrar una carpeta se usa el comando rmdir:
$ ls
$ mkdir hola
$ rmdir hola
$ ls

Si se intenta borrar una carpeta que no este vacia, rmdir dará un error, para ello se usa la opcion -R de rm, que borrara de forma recursiva la carpeta y sus subcarpetas
$ ls
$ mkdir hola
$ cd hola; mkdir hola2
$ rm -R hola
$ ls

Copiando y moviendo archivos:

Para copiar un archivo se usa el comando cp [OPCIÓN] fuente destino.
#Vamos a copiar el comando ls que esta en /bin/ ( el . es el directorio actual):
$ cp /bin/ls .
$ ls
ls
#Ahora copiamos el comando rm y el comando mkdir:
$ cp /bin/rm /bin/mkdir .
$ ls
ls mkdir rm

Para mover un archivo se usa el comando mv [OPCIÓN] fuente destino.
mv también sirve para renombrar si la fuente y el destino son el mismo directorio.
#Movemos el archivo hola de la carpeta padre a la actual:
$ ls ..
hola
$ mv ../hola hola
$ ls ..
$ ls
hola
#Renombramos hola a que.tal
$ ls


 
hola
$ mv hola que.tal
$ ls
que.tal

Alias:
Ahora que ya conocemos unos pocos comandos podemos hacer que su manejo sea mucho mas sencillo con los alias.
Los alias son seudónimos que sustituyen a otros comando (incluidos los argumentos).
Para saber que alias tenemos en nuestro equipo escribimos alias.
$ alias
alias l='ls -CF'
alias la='ls -A'
alias ll='ls -l'
alias ls='ls -lla --color'
Para definir un nuevo alias escribimos: alias nombre del alias='comando con los argumentos' (esto ultimo tiene que estar entre comillas).
Puedes definir alias para simplificar los comandos, para evitar algunos errores que cometas siempre...
$ alias ls='ls -lAF --color=auto'
$ alias mkae='make'
$ alias rm='rm -i'
Para que estos alias no sean temporales tenemos que definirlos en .bashrc (luego veremos como).

A parte de los alias, bash tiene otros 'atajos' propios solo de ella:
  • TAB : Si escribimos los primeros caracteres y pulsamos TAB nos completara la palabra, si hay mas de una coincidencia se mostrara una lista.
  • Ctrl-L : Limpia la pantalla (como clear).
  • Shift-RePág : Enseña media pantalla anterior.
  • Shift-AvPág : Enseña media pantalla posterior.
  • Ctrl-W : Elimina la última palabra escrita.
  • Ctrl-T : Intercambia el orden de los dos últimos caracteres.
  • Ctrl-D : Sale del interprete de comandos (como logout).
Otro mecanismo muy útil del bash es la historia de comandos.
Es normal que utilizando el sistema debamos repetir muchas instrucciones escritas anteriormente.
Con las teclas del cursor arriba y abajo podemos ir viendo todos los comandos que hemos ido utilizando y repetir alguno apretando ENTER.
También podemos utilizar history, con el cual se mostrarán por pantalla todos los comandos ejecutados, enumerados según su aparición.
Escribiendo "!NUM" se ejecutará el que se corresponda con esta historia.
También podemos escribir "!" seguido de las letras iniciales de algún programa ejecutado anteriormente y el programa buscará el más reciente para ejecutarlo.

 

Buscando en el sistema:

Para buscar un archivo existen diferentes comandos:

find:
Es el comando más versátil para realizar esta acción.
Nos permite filtrar los ficheros para encontrar desde los que tienen un determinado nombre, los modificados o creados a partir de una cierta fecha, los que tienen ciertos permisos, etc.
Su única desventaja es que no utiliza ningún tipo de mecanismo para acelerar la búsqueda, con lo cual, éstas pueden tardar bastante.

locate:
Se trata de otro comando, pero, a diferencia del anterior, utiliza una base de datos interna que se actualiza periódicamente y nos permite hacer búsquedas bastante más rápidas.
Debemos tener en cuenta, sin embargo, que los resultados no siempre estarán actualizados, además de que no podemos realizar búsquedas tan versátiles como con find.

whereis:
Por último, whereis está orientado a la búsqueda de los archivos binarios (los ejecutables), de ayuda o los de código fuente de un determinado programa.
Compresión y descompresión:
Hoy en día existen cientos de programas con muchos formatos que sirven para empaquetar/desempaquetar y comprimir/descomprimir, pero el único que esta presente en la mayoría de los sistemas UNIX es el tar, con el podemos hacer todo lo anterior y mucho mas con todas las opciones que tiene y que podremos conocer viendo las paginas de su manual.
Para crear un nuevo archivo usamos c, para guardarlo en otro usamos f y para desempaquetarlo usamos x, así con 'tar cf holas.tar hola*' empaquetamos en 'holas.tar' todos los archivos del directorio actual que empiecen con 'hola' y con 'tar fx holas.tar' descomprimiria el archivo holas.tar:
$ ls
total 60
-rw-r--r-- 1 peter peter 30720 Mar 26 23:34 holajuan.txt
-rw-r--r-- 1 peter peter 24860 Mar 26 23:34 holasanti.txt
$ tar -cf holas.tar hola*
$ ls
total 124
-rw-r--r-- 1 peter peter 30720 Mar 26 23:34 holajuan.txt
-rw-r--r-- 1 peter peter 61440 Mar 26 23:37 holas.tar
-rw-r--r-- 1 peter peter 24860 Mar 26 23:34 holasanti.txt
$ rm holaju*
$ rm holasan*
$ ls
total 64
-rw-r--r-- 1 peter peter 61440 Mar 26 23:37 holas.tar
$ tar fx holas.tar
$ ls

 
total 124
-rw-r--r-- 1 peter peter 30720 Mar 26 23:34 holajuan.txt
-rw-r--r-- 1 peter peter 61440 Mar 26 23:37 holas.tar
-rw-r--r-- 1 peter peter 24860 Mar 26 23:34 holasanti.txt
$ rm holas.tar
Para comprimir usando gzip usamos z, por lo que 'tar cfz holas.tar.gz hola*' empaquetaría y comprimiría todos los archivos que empiecen con 'hola' y para desempaquetarlo y descomprimirlo usaríamos 'tar xzf holas.tar.gz':
$ ls
total 60
-rw-r--r-- 1 peter peter 30720 Mar 26 23:34 holajuan.txt
-rw-r--r-- 1 peter peter 24860 Mar 26 23:34 holasanti.txt
$ tar cfz holas.tar.gz hola*
$ ls
total 64
-rw-r--r-- 1 peter peter 30720 Mar 26 23:34 holajuan.txt
-rw-r--r-- 1 peter peter 1647 Mar 26 23:39 holas.tar.gz
-rw-r--r-- 1 peter peter 24860 Mar 26 23:34 holasanti.txt
$ rm holaju*
$ rm holasan*
$ ls
total 4
-rw-r--r-- 1 peter peter 1647 Mar 26 23:39 holas.tar.gz
$ tar xfz holas.tar.gz
$ ls
total 64
-rw-r--r-- 1 peter peter 30720 Mar 26 23:34 holajuan.txt
-rw-r--r-- 1 peter peter 1647 Mar 26 23:39 holas.tar.gz
-rw-r--r-- 1 peter peter 24860 Mar 26 23:34 holasanti.txt
Fíjate en la diferencia de tamaño del archivo .tar y del .tar.gz (5ª columna).

Una pequeña tabla con las opciones mas básicas de tar:
Opción:
Significado:
-c
Crea un nuevo archivo
-f
El resultado se guarda en un archivo
-j
Descomprime un .bz2
-k
No sobreescribe al extraer
-t
Lista el contenido de un .tar
-v
Describe lo que va haciendo
-z
Comprime con gzip
-Z
Comprime con Compress (más antiguo)
-x
Extrae archivos de otro archivo
Como hemos visto tar no es un programa de compresión/descompresión ya que para comprimir utiliza otro programa llamado gzip, los programas de compresión mas comunes son los siguientes:

 

gzip y compress:

Como tar no comprime, solo empaqueta, tiene que 'usar' a otro programa para comprimir.
Para comprimir uno o varios archivos no hace faltan opciones, para descomprimir usamos -d (fíjate en el tamaño antes y después de la compresión):
$ ls
total 124K
-rw-r--r-- 1 peter peter 30K Mar 26 23:34 holajuan.txt
-rw-r--r-- 1 peter peter 60K Mar 26 23:39 holas.tar
-rw-r--r-- 1 peter peter 25K Mar 26 23:34 holasanti.txt
$ gzip hola*
$ ls
total 12K
-rw-r--r-- 1 peter peter 885 Mar 26 23:34 holajuan.txt.gz
-rw-r--r-- 1 peter peter 1.7K Mar 26 23:39 holas.tar.gz
-rw-r--r-- 1 peter peter 768 Mar 26 23:34 holasanti.txt.gz
$ gzip -d hola*
$ ls
total 124K
-rw-r--r-- 1 peter peter 30K Mar 26 23:34 holajuan.txt
-rw-r--r-- 1 peter peter 60K Mar 26 23:39 holas.tar
-rw-r--r-- 1 peter peter 25K Mar 26 23:34 holasanti.txt
Una pequeña tabla con las opciones mas comunes de gzip:
Opción:
Significado:
-d
Descomprime.
-f
Fuerza la acción.
-l
Muestra una lista de los archivos comprimidos.
-r
Comprime recursivamente.
-v
Muestra lo que va haciendo.
-n
Regula la velocidad y el tamaño, en donde 'n' es un numero del 1 al 9, el 1 es más rápido y el 9 esta más comprimido.
Conclusión:

Para empaquetar los archivos 'hola' y 'hola2' en holas.gz: tar -cf holas.tar hola*
Para desempaquetar hola y hola2 de holas.tar: tar -fx holas.tar

Para comprimir hola a hola.gz: gzip hola // tar -czf hola.gz hola
Para descomprimir hola.gz: gzip -d hola.gz // tar -zxf hola.gz

Para empaquetar y comprimir hola y hola2 en holas.tar.gz: tar -czf holas.tar.gz hol*
Para desempaquetar y descomprimir hola y hola2 que están en holas.tar.gz: tar -xzf holas.tar.gz

Tabla con las extensiones y los formatos de los programas de compresión mas populares:

Extensión:
Formato:
.tar
tar
.gz
gzip
.tgz
tar + gzip
.bz2
bzip2
.zip
zip
.z
compress