En Ubuntu existen varios modos de añadir, eliminar o actualizar aplicaciones del sistema.

Ten en cuenta que no todas las aplicaciones disponibles para Ubuntu están disponibles por defecto para ser instaladas. Será necesario habilitar la posibilidad de instalar ciertas aplicaciones de forma manual.

Los principales modos de instalar aplicaciones son:

El programa Añadir/Quitar aplicaciones . Una sencilla aplicación con la que podrás añadir o quitar paquetes de tu sistema de una manera muy sencilla.

El programa Synaptic . Con Synaptic podrás tener más control sobre los programas que instalas en el sistema. Así como un mayor número de ellos. NOTA: Por el momento, Synaptic utiliza apt-get.

El programa Adept . Adept es la versión de Synaptic para KDE, incluida en Kubuntu.

Los programas apt-get o aptitude . Estos son programas más avanzados que se ejecutan en modo terminal. Son muy potentes y te permiten también añadir y quitar aplicaciones del sistema entre otras cosas. (Aptitude es más completo que apt-get, recuerda las librerías descargadas y las desinstala si están en desuso). Para ver la ayuda de cualquier programa que se ejecute en modo terminal: (man nombre_del_programa). Ejemplo: man aptitude

Paquetes Deb . Los ficheros con extensión .deb son paquetes de aplicaciones ya preparados para instalarse de una forma sencilla en tu sistema Ubuntu.

Archivos binarios . Los archivos con extensión .bin son los programas ejecutables en Linux.

Archivos Run . Los archivos con extensión .run suelen ser los asistentes para la instalación en Linux.

Vamos a ver ahora cada uno de ellos con sus particularidades.

Mediante programas

Debemos tener en cuenta que solo se puede tener activo un programa a la vez. Por ejemplo, si tenemos abierto el programa Synaptic no podremos usar aptitude.

Añadir/Quitar aplicaciones

El programa Añadir/Quitar aplicaciones es la forma más sencilla en Ubuntu de instalar o quitar programas. También es la más limitada.

Puedes encontrar el programa en Menú Aplicaciones → Añadir y quitar ...

(1) Para instalar aplicaciones selecciona una de las categorías de la izquierda. De este modo se actualizará la ventana de la derecha mostrando en ella los programas disponibles de esa categoría.

(2) Ahora sólo tienes que marcar el programa para instalarlo o quitar la marca para eliminarlo del sistema y pulsar el botón Aceptar.

(3) Si no sabes en que sección se encuentra el programa que estás buscando. Selecciona en la parte de la izquierda “Todo” e introduce el nombre de la aplicación que deseas instalar en la caja de búsqueda de la parte superior derecha. A medida que vayas escribiendo el nombre del programa se irá reduciendo la lista de candidatos posibles, hasta que des con el que andabas buscando.

(4) Puedes activar estas casillas para ampliar la búsqueda a las aplicaciones no soportadas y a las privativas.

(5) Pulsando en el botón Preferencias accederás a la configuración de ciertos detalles de la aplicación. Como los orígenes de software, añadir repositorios externos, etc...

Gestor de paquetes Synaptic

Synaptic es un avanzado sistema para instalar o eliminar aplicaciones de tu sistema. El entorno es gráfico, como en Añadir/Quitar Aplicaciones, pero mucho más potente. Con Synaptic tienes el control completo de los paquetes (aplicaciones) instalados en tu sistema.

Para ejecutar Synaptic elige Sistema -> Administración -> Gestor de paquetes Synaptic. Este gestor de paquetes nos permitirá instalar, reinstalar y eliminar paquetes de una forma gráfica muy sencilla.

La pantalla de Synaptic está dividida en 4 secciones.

Las dos más importantes son la lista de categorías (1) en el lado izquierdo y la de los paquetes (3) en el lado derecho.

Al seleccionar un paquete de la lista se mostrará una descripción del mismo (4).

Para instalar un paquete puedes seleccionar una categoría, pulsar con el botón derecho en el paquete deseado y seleccionar “marcar para instalar” o hacer doble-click en el nombre del paquete.

Marca de esta forma todos los paquetes que desees instalar en el sistema y pulsa Aplicar para proceder a su instalación. Synaptic descargará ahora los paquetes necesarios desde los repositorios en internet o desde el CD de instalación.

También puedes usar el botón Buscar para encontrar los paquetes que desees instalar.

Pulsando en el botón de buscar, podremos realizar búsquedas de programas mediante su nombre o descripción. Una vez localizado el programa que deseamos instalar hacemos doble clic sobre él para instalarlo. Si queremos eliminar un programa bastará con pulsar con el botón derecho encima de éste y seleccionar eliminar o eliminar por completo.

Para que se apliquen los cambios es necesario pulsar en el botón de Aplicar.

El sistema de instalación de software en Ubuntu es muy potente y versátil. Dentro de los repositorios las aplicaciones están organizadas en "paquetes". Cada paquete tiene otros de los que depende para su correcto funcionamiento. Synaptic se encarga de resolver estas dependencias e instalar los paquetes necesarios por ti. Pero no sólo eso. En los paquetes de aplicaciones también se indican otros paquetes que aunque no son necesarios para que funcione la aplicación que queremos instalar si son de utilidad. Estos son los "paquetes recomendados".

Podemos configurar Synaptic para que considere esos paquetes "recomendados" como si fuesen dependencias y así los instalará también automáticamente.

Arranca Symaptic y ve a Configuración -> Preferencias, en la Pestaña General marca la casilla "Considerar los paquetes recomendados como si fuesen dependencias".

Administrador experto Adept

Los usuarios de Kubuntu disponen del equivalente de Synaptic, llamado administrador experto Adpet. Se puede encontrar en el menú KDE -> Sistema -> Administrador experto. El funcionamiento es muy similar al de Synaptic.

Mediante el cuadro de búsqueda se puede buscar paquetes tanto por nombre como por la descripción de este. Haciendo doble click sobre un elemento del resultado de la lista queda marcado para instalar.

Se pueden ver las dependencias de un paquete mirando sus propiedades ("detalles").

Los repositorios en adept los podemos manejar haciendo click en el menú adept y luego en administrar repositorios

Software Kubuntu : aquí están (main, universe, restricted, multiverse) y una mas donde están los códigos fuentes. Además un menú desplegable para elegir de donde o desde cual servidor descargaremos.

Third-Party Software: Aquí podemos incluir repositorios adicionales de terceros o un cdrom.

Updates: Actualizaciones de Kubuntu, podemos seleccionar las actualizaciones que adept revisara además configuramos las actualizaciones automáticas, podemos elegir entre instalarlas sin que nos notifique, descargarlas en silencio o solo notificar que hay actualizaciones.

Authentication: Aquí están las claves de las firmas para los archivos que descargamos de los repositorios, además si encontramos un repositorio de un tercero que nos interese y maneja firmas podemos incluirla bajando el archivo de firma del sitio web o ftp a un directorio cualquiera y la importamos o incluimos dándole click al botón “Import Key File...”

Después de añadir o remover repositorios para que el sistemas tome los cambios tenemos que hacer click en el botón comprobar actualizaciones.

aptitude y apt-get

Aunque podemos instalar programas de forma gráfica como hemos visto en los puntos anteriores, siempre podemos recurrir a la terminal para instalar cualquier programa.

A muchos usuarios nóveles esta opción les puede parecer un poco más complicada y algo críptica. Nada más lejos de la realidad; cuando uno se acostumbra es mucho más cómodo, fácil y rápido.

Existen dos formas de instalar programas en modo texto: con aptitude y con apt-get.

Ambos programas son muy similares, salvo en un detalle: aptitude recuerda las dependencias que se han aplicado en la instalación de un paquete. Esto significa que si se instala o actualiza una aplicación con aptitude y luego se quiere desinstalar, aptitude borrará el programa junto con todas sus dependencias (excepto si son usadas por otros paquetes). Si se instala con apt-get o con entorno gráfico Synaptic, la desinstalación borrará sólo el paquete especificado, pero no las dependencias.

Uso

Abrimos una terminal vía Aplicaciones -> Accesorios -> Terminal.

Instalar paquetes:

$ sudo aptitude install <paquetes>

Desinstalar paquetes:

$ sudo aptitude remove <paquetes>

Desinstalar paquetes (incluyendo archivos de configuración):

$ sudo aptitude remove --purge <paquetes>

Actualizar la lista de paquetes disponibles:

$ sudo aptitude update

Actualizar el sistema con las actualizaciones de paquetes disponibles:

$ sudo aptitude upgrade

Obtener una lista de opciones del comando:

$ sudo aptitude help

Para instalar paquetes desde la línea de comandos también podemos usar apt-get, aunque es preferible el uso de aptitude por el manejo de dependencias.

Instalar paquetes sin internet

En un ordenador que sí tenga internet y que el programa/paquete que queremos no este instalado podemos descargarnos los paquetes junto con sus dependencias (no instaladas ya) mediante estos dos comandos:

$ sudo aptitude clean$ sudo aptitude install -d nombre_paquete

Cuando instalamos un paquete mediante aptitude/apt, éste permanece en una carpeta específica. Con el primer comando lo que hacemos es borrar esos paquetes del ordenador (no afecta a las instalaciones ya hechas).

El segundo comando se descargará el paquete que queríamos y las dependencias que necesite, pero no lo instalará. Ahora vamos a "/var/cache/apt/archives" y vemos dichos paquetes. Los copiamos, los llevamos al equipo que no tiene conexión y los instalamos mediante doble click sobre cada uno de ellos o en consola:

$ sudo dpkg -i nombre_paquete

Tened en cuenta que si hay dependencias, hay que instalar estas primero. También puede darse el caso que alguna de estas dependencias ya estuvieran instaladas en el equipo con internet, de forma que no se descargarían.

Si el equipo con internet ya lo tuviera instalado, pues se podría desinstalar mediante “aptitude remove” (sin purge) y quitamos el “-d” del “aptitude install” posterior. De este modo primero lo desinstalamos y después lo descargamos e instalamos. De esta manera el equipo con internet seguirá teniendo el programa exáctamente igual que antes de desinstalarlo.

Para solucionar y prevenir los posibles problemas de dependencias podemos ir al Synaptic del equipo con internet, buscamos el paquete que queremos, hacemos clic derecho sobre el paquete en cuestión, entramos en Propiedades y seleccionamos la pestaña de Dependencias. Ahí vemos los paquetes que necesitamos para instalar debidamente el paquete en el equipo sin internet.

Mediante archivos

Paquetes Deb

Otra forma de instalar aplicaciones en el sistema es por medio de los paquetes ya preparados para ser instalados y con extensión .deb.

Para instalar estos paquetes sólo tienes que hacer doble click sobre el fichero en el navegador Nautilus y automáticamente se lanzará la aplicación gdebi, que se ocupará de instalar el paquete y buscar las dependencias de otros paquetes que pudiera necesitar para su correcta instalación.

Si lo preferimos, también se pueden instalar mediante la línea de comandos, mediante el comando dpkg:

$ sudo dpkg -i <paquete>.deb

En este caso también habrá que instalar manualmente las posibles dependencias del paquete.

El mismo comando también se puede usar para desinstalar el paquete:

$ sudo dpkg -r <paquete>

Convertir paquetes RPM a Deb

Algunas distribuciones de GNU/Linux, como por ejemplo Red Hat, SUSE y Mandriva, usan paquetes .rpm, organizados de manera diferente a los paquetes .deb de Debian y Ubuntu.

Para instalar estos paquetes es preciso convertirlos antes al formato .deb. Para ello se usa la aplicación alien, la cual se puede instalar mediante uno de los métodos explicados en este artículo. La aplicación alien se utiliza de la siguiente manera:

Abrimos una terminal (Aplicaciones → Accesorios → Terminal) y ejecutamos la siguiente instrucción:

$ sudo alien <paquete>.rpm

De esta forma el programa crea un archivo con el nombre del paquete, pero con extensión .deb, que se podrá instalar siguiendo la explicación Paquetes Deb.

Paquetes Autopackage (de extensión .package)

El proyecto Autopackage nace con la idea de facilitar la instalación de aplicaciones en Linux independientemente de la distribución y escritorio que usen. Por ello muchos proyectos lo utilizan, como por ejemplo Inkscape.

Instalar por primera vez un archivo de extensión .package es muy sencillo. Basta con seguir las siguientes indicaciones (en la pagina del proyecto también se indica cómo).

Una vez descargado el archivo, debemos darle permisos de ejecución, hacer doble clic sobre el archivo y en el aviso en el que pregunta ¿Quiere ejecutar __ o ver su contenido? debemos hacer clic en Ejecutar. Una vez hecho esto, empezará el instalador del programa Autopackage y del contenido del paquete.

Al instalarse el programa Autopackage, el próximo archivo de este tipo que desees instalar bastará con hacer doble clic sobre él sin necesitar hacer nada de lo escrito anteriormente.

Archivos binarios

Los archivos con extensión .bin son archivos binarios. No contienen un conjunto de programas o librerías como los paquetes, sino que son el programa en sí mismo. Normalmente se suelen distribuir bajo este sistema programas comerciales, que pueden ser o no gratuitos, pero que normalmente no son libres.

Cuando descargamos un archivo de este tipo y lo guardamos en el sistema, no tendrá permiso para ejecutarse.

Lo primero que debemos hacer, por consiguiente, es dar a ese fichero el permiso para ejecutarse. Desplegamos el menú contextual del archivo y elegimos la opción Propiedades. Seleccionamos la pestaña Permisos y veremos que el archivo tiene permisos de lectura y

escritura para el propietario pero no para ejecución. Activamos la casilla para dar permisos de ejecución y cerramos la ventana.

Ahora que ya hemos dado permiso al fichero para poder ejecutarlo haz doble clic. Al hacerlo te aparecerá una ventana dándote varias opciones. Elije ejecutar.

Para realizar esto mismo desde una terminal:

Damos permisos de ejecución al archivo:

$ sudo chmod +x <nombre_binario>.bin

Instalamos el archivo binario:

$ sudo ./<nombre_binario>.bin

Archivos Run

Los archivos .run son asistentes, normalmente gráficos, que ayudan a la instalación. Para ejecutarlos basta con introducir en la terminal:

$ sh ./<archivo>.run

Normalmente, en el caso de que necesite permisos de superusuario (también llamado administrador o root) pedirá la contraseña; de no ser así basta con agregar la orden sudo antes del comando, con lo cual quedaría así:

$ sudo sh ./<archivo>.run

Compilar aplicaciones a partir del código fuente

A veces se encuentran aplicaciones que no proporcionan paquetes de instalación, y hay que compilar a partir del código fuente. Para ello, lo primero que debemos hacer en Ubuntu es instalar un meta-paquete llamado build-essential, usando uno de los métodos explicados en este artículo. En general, los pasos a seguir para compilar una aplicación son los siguientes:

1. Descargar el código fuente. 2. Descomprimir el código, generalmente está empaquetado con tar comprimido bajo

gzip (*.tar.gz) o bzip2 (*.tar.bz2).

3. Entrar en la carpeta creada al descomprimir el código.

4. Ejecutar el script configure (sirve para comprobar las características del sistema que afectan a la compilación, configurando la compilación según estos valores, y crear el archivo makefile).

5. Ejecutar el comando make, encargado de la compilación.

6. Ejecutar el comando sudo make install, que instala la aplicación en el sistema, o mejor aún, instalar el paquete checkinstall, y ejecutar sudo checkinstall. Esta aplicación crea un paquete .deb de forma que no haya que compilarlo la próxima vez, aunque no incluye la lista de dependencias.

El uso de checkinstall tiene también la ventaja de que el sistema tendrá constancia de los programas instalados de esa forma, facilitando también su desinstalación.

He aquí un ejemplo completo de ejecución de este procedimiento:

$ sudo aptitude install libpanelapplet$ tar xvzf sensors-applet-0.5.1.tar.gz$ cd sensors-applet-0.5.1$ ./configure --prefix=/usr$ make$ sudo checkinstall

Programación del Shell

Ejercicios resueltos

 Estructura de archivos.Estructura del archivo /etc/passwd:

#nombre:contraseña:UID:GID:comentarios:dir_propio:shell jperez:Xdio0IKLLP:1130:103:Juan Pérez:/home/jperez:/bin/bash Estructura del archivo /etc/group:#grupo:GID:lista_usuarios docentes:103:victor,german,fernando Estructura del archivo /etc/hosts:#número_IP nombre_máquina alias 10.137.137.250    liebre.cdi.edu.uy liebre localhost mailhost Todos los archivos anteriores pueden tener comentarios (líneas comenzadas por #).

1. Recibir un nombre de archivo como parámetro e indicar, imprimiendo todas las leyendas que correspondan, si el archivo es legible, modificable y ejecutable por el usuario.

#!/bin/bsh# carsarch.sh: características de un archivoecho Caracteristicas del archivo $1if [ -r $1 ]then  echo es legiblefiif [ -w $1 ]then  echo es grabablefiif [ -r $1 ]then  echo es ejecutablefi 

2. Recibir varios nombres de archivo como parámetros, y para cada uno validar si el nombre corresponde a un archivo común existente, y si es así mostrarlo en pantalla paginando. #!/bin/bash# mostrarchs.sh: muestra contenido de varios archivosfor VAR in $*doif [ -f $VAR ]then  more $VARelse  echo No existe $VARfidone 

3. Recibir un nombre de directorio, validar existencia y condición de directorio y mostrar nombres de todos los directorios y subdirectorios bajo él, en formato de página largo 23.

#!/bin/bash

# esdir.sh: verifica directorio y muestra contenido recursivoclearif [ -d $1 ] then   echo Directorios bajo $1   echo "Digite Enter para continuar"; read; clear   ls -lR $1 2>/dev/null | grep '^d' | pr -l24 | more -24   # el valor 24 en more es para visualizar en pantalla else   echo No existe el directorio $1

fi  

4. Escribir un programa seaejec que reciba un nombre de archivo, verifique que existe y que es un archivo común, lo convierta en ejecutable para el dueño y el grupo y muestre el modo final. #!/bin/bash# seaejec: convierte un archivo en ejecutable#ARCH=$1if [ -f $ARCH ]          # existe y es archivo regularthen  chmod ug+x $ARCH  ls -l $ARCHelse  echo "seaejec: el archivo $ARCH no pudo ser convertido"

fi  5. Escribir un programa copiabin.sh que mueva todos los programas del directorio actual (archivos ejecutables) hacia el subdirectorio bin del directorio propio del usuario, muestre los nombres de los que mueve e indique cuántos ha movido o que no ha movido ninguno. Si el directorio bin no existe, deberá ser creado. #!/bin/bash# copiabin.sh: copia archivos ejecutables hacia $HOME/bin## si el directorio bin no existe lo creaif [ ! -d $HOME/bin ]then  mkdir $HOME/binfi# copia de archivosN=0            # contador de archivos copiadosfor ARCH in *do  if [ -x $ARCH -a -f $ARCH ]  # ejecutable y archivo común (no directorio)  then    cp $ARCH $HOME/bin    echo "  $ARCH fue copiado a $HOME/bin"    N=`expr $N + 1`  fidone

if [ $N -eq 0 ]then  echo "No se copió ningún archivo"else  echo "Fueron copiados $N archivos"fi

  6. Usando el archivo /etc/passwd escribir el programa usuarios que lista los nombres de login, el directorio propio del usuario y el intérprete invocado por defecto de todos los usuarios, ordenados alfabéticamente por nombre de login. # usuarios: lista datos de usuarios#echo "Nombres de usuarios, Directorio propio, intérprete de comandos"ypcat passwd | cut -d: -f1,6,7 | sort | moreecho

  7. Usando solamente el archivo /etc/group, escribir los siguientes programas:a) 'grupo1': listar los nombres y números de grupo y la lista de usuarios de cada uno, ordenados por nombre.b) 'grupo2': igual, ordenados por número de grupo.c) 'grupo3': reúne las dos salidas anteriores, con leyendas explicativas adecuadas para cada parte y para cada columna, así como nombre de la máquina y fecha del día. #!/bin/bash## grupo1:clearecho "Grupos por nombre:"echo ---------------------------------------------------------echo "login:número_de_grupo:lista de usuarios"echo ---------------------------------------------------------ypcat group | cut -d: -f1,3,4 | sort | more -18echo ---------------------------------------------------------echo Digite Enter para continuarreadclear #!/bin/bash## grupo2:echo "Grupos por número:"echo ---------------------------------------------------------echo "login:número_de_grupo:lista de usuarios"echo ---------------------------------------------------------ypcat group | cut -d: -f1,3,4 | sort -t: -n +1 | more -18echo ---------------------------------------------------------echo 

#!/bin/bash## grupo3:clear./grupo1echo./grupo2echoecho Máquina: `hostname`echo Fecha: `date`

  8. Escribir un programa usugrup que dado un nombre de login de usuario determine si existe en el sistema, y si es así, presente su nombre de usuario, , número de usuario (UID), grupo primario y grupos secundarios si los tiene, con leyendas adecuadas. #!/bin/bash# usugrup: datos y grupos de un usuario#USUARIO=$1id $USUARIO 1>/dev/null 2>&1ERROR=$?if [ $ERROR -ne 0 ]then  echo "El usuario " $USUARIO "no existe"  exitfiNOMBRE=`id $USUARIO | cut -f1 -d" "`echo \(UID\) y nombre: $NOMBREGRUPO1=`id $USUARIO | cut -f2 -d" "`echo \(GID\) y grupo primario: $GRUPO1if test `id $USUARIO | tr " " "\n" | wc -l` -gt 2then  GRUPOS2=`id $USUARIO | cut -f3 -d" "`echo \(GIDs\) y grupos secundarios: $GRUPOS2fi

  9. Escribir un programa grupusu que dado un nombre de grupo determine si existe en el sistema, y si es así, presente su nombre, número de grupo (GID), y lista de usuarios que pertenezcan a él, ya sea como grupo primario (en /etc/passwd) o como grupo secundario (lista en /etc/group). #!/bin/bash# determina usuarios en un grupo GRUPO=$1        # nombre de variable significativoEXISTE=`ypcat group | grep "^$GRUPO"`if [ ! $EXISTE ]then  echo "El grupo $GRUPO no existe."  exitfi 

# extrae número del grupo

GID=`echo $EXISTE | cut -d: -f3` echo "El número del grupo $GRUPO es $GID"  # busca usuarios con este grupo primario

echo Usuarios en este grupo como primario:   # corta campos usuario e id grupo,

# selecciona líneas con $GID al final, # luego corta el GID, deja nombre usuario ypcat passwd | cut -d: -f1,4 | grep :$GID$ | cut -d: -f1  # busca usuarios con este grupo secundario

echo Usuarios en este grupo como secundario: echo $EXISTE | cut -d: -f4 | tr "," " "

  10. Escribir los siguientes programas:a) ligass: muestra los nombres de archivo que son enlaces simbólicos.b) ligash: muestra los archivos que tiene enlaces hard.Ambos programas reciben un nombre como como parámetro, y validarán que corresponda a un directorio del sistema. #!/bin/bash# ligass: lista archivos que son enlace simbólico o tienen enlaces hard# simbólicos: en ls -l se busca que empiece con lif [ ! -d $1 ]then  echo Error: ligas: $1 no es un directorio  exitfiecho Archivos que son enlace simbólico:ls -l | grep "^l" | cut -56 -echo# hard: se busca 3 espacios y distinto de 1 como contador de enlacesecho Archivos que tienen enlace hard:ls -l | grep -v "^d" | cut -c11 - | grep -v "^ 1" | cut -c46 -

  *11. Escribir un programa saludo que, según la hora, escriba el saludo correspondiente al nombre de pila del usuario. En el archivo /etc/passwd los usuarios deben estar ingresados con nombre y apellido separados por blanco. Los saludos corresponden a las siguientes horas: Buenos días, de 05:00 hasta 12:59; Buenas tardes, de 13:00 hasta 19:59; Buenas noches 20:00 hasta 04:59. Ejemplo de mensaje: Buenos días, Juan.A efectos de pruebas, se recibirán la hora y el nombre de login como parámetros, dejando comentados los comandos donde se extrae la hora real y se toma el usuario real. #!/bin/bash

# saludo.cmd# script en UNIX que saludo al usuario por su nombreNOMBRE=`cat /etc/passwd | grep "^$LOGNAME" | \cut -d: -f5 | cut -d' ' -f1`# si el usuario no tiene ingresado un nombre, toma "Nadie"NOMBRE=${NOMBRE:-Nadie}HORA=`date | cut -c12-13 | tr -d ' '`if expr "$HORA" \<= 5 > /dev/nullthen  echo 'Buenas noches, '$NOMBREelif expr "$HORA" \<= 12 > /dev/nullthen  echo 'Buenos dias, '$NOMBREelif expr "$HORA" \<= 19 > /dev/nullthen  echo 'Buenas tardes, '$NOMBREelif expr "$HORA" \<= 24 > /dev/nullthen  echo 'Buenas noches, '$NOMBREfi

  12. Un script de respaldo produce, entre otros mensajes, líneas del tipo   "Total bytes written 18804023"

Guarda su salida en el archivo respaldo.error. Escribir un script total.cinta que sume los bytes grabados e indique el total en bytes, Mb y Gb.Crear un archivo respaldo.error de prueba, con un contenido tal como   Total bytes written 1800   Total bytes written 1000 ## total.cinta: cantidad de bytes grabados en cinta#TOTAL=0LISTA=`cat respaldo.error | tr -dc "[0-9] "`for NUM in $LISTAdo  TOTAL=`expr $TOTAL + $NUM`doneecho "Total General de bytes respaldados: "$TOTALTOTALMB=`expr $TOTAL \/ 1000000`echo "Total General de MB respaldados: "$TOTALMBTOTALGB=`expr $TOTALMB \/ 1000`echo "Total General de GB respaldados: "$TOTALGB

Tomado de http://iie.fing.edu.uy/~vagonbar/unixbas/index.htm