Recogida de correo: Fetchmail

Si con programas como sendmail es posible enviar el correo a nuestra máquina estando desconectados de Internet para su posterior distribución cuando se conecte a la Red, con Fetchmail es posible hacer el proceso inverso, es decir, recoger TODO el correo de todos los servidores POP o IMAP deseados para su posterior recogida desde nuestra máquina y lectura en modo desconectado.

Fetchmail es el daemon encargado de la recogida de correo, para posteriormente pasárselo a sendmail, que es quien lo distribuye. La forma más sencilla de configurar fetchmail es creando un fichero .fetchmailrc en el directorio personal del usuario (ya sea /home/usuario o incluso /root), de forma que sea el mismo usuario quien recoja el correo y se lo pase al usuario/usuarios que deban leerlo. Dicho fichero tiene un formato como el que sigue:

  defaults
 fetchall
 flush
 pass8bits
 poll servidor_de_correo
 proto pop3
 user usuario
 pass password
 to usuario_local

(pueden haber más bloques poll/proto/user/pass/to si hay mas servidores de correo de donde deseemos recoger el mismo)Las opciones incluidas en este fichero son las siguientes:

• defaults: establece los valores por defecto para fetchmail.
• fetchall: recoge todos los mensajes pendientes en el servidor de correo.
• flush: una vez recogidos los mensajes son borrados del servidor de correo. Para nuestras primeras pruebas es recomendable cambiar este parámetro por keep, para que los mantenga y así no los perdamos en caso de un error de configuración.
• pass8bits: Indica que el mensaje puede contener carácteres de 8 bits (acentos, eñes, etc.).
• Bloque poll/proto/user/pass: Indica las características de nuestro servidor de correo. Si disponemos de más de un servidor de correo, se deben incluir tantos bloques de este tipo (repetir la estructura para ambos) como servidores dispongamos.
• poll: Indica el servidor de correo entrante (POP o IMAP) de donde leer el correo (en mi caso se trata simplemente de anteponer pop al dominio de mi ISP, quedando pop.dominio.com).
• proto pop3: Indica que nuestro servidor de correo entrante utiliza POP para la recogida del correo (alternativo a IMAP).
• user y pass: Indican la cuenta del correo y password del usuario. Algunas cuentas de correo típicas son como las siguientes:

    user lester@dominio        <- en dominio.com

• (consultar con nuestro ISP cual es el login de nuestra cuenta de correo). Si nuestro password es numérico tal vez haga falta encerrarlo entre comillas dobles “”.
• to usuario: Indica a qué cuenta de usuario se le ha de pasar el correo. Usuario ha de ser una cuenta de nuestro sistema Linux, tales como sromero, o root.

Un ejemplo de fichero .fetchmailrc para un usuario lester@dominio.com en /home/lester sería el siguiente:

  defaults
 flush
 fetchall
 pass8bits
 poll pop.dominio.com
 proto pop3
 user lester@dominio
 pass mipassword
 to lester

Además, este fichero tiene que tener unos permisos de lectura/escritura concretos, debido a que posee nuestro password de correo, cosa que se realiza con la orden chmod:

  [lester@Centos lester]#   chmod 0600 .fetchmailrc

La forma de recoger el correo es, estando conectado, ejecutar la orden “fetchmail”.Por último, podemos hacer que fetchmail corra en forma de demonio (el equivalente en MSDOS sería como un programa residente), y que recoja el correo sólo cada X segundos, cosa muy sencilla de realizar añadiendo la siguiente opción al fichero .fetchmailrc:

  set daemon X     (ejemplo: set daemon 300)

Esto haria que fetchmail buscara correo nuevo cada 300 segundos sin necesidad de ser lanzado por nuestra parte con el comando “fetchmail”.Una vez recogidos los mensajes (ya sea en forma manual o como daemon), éstos son depositados por sendmail en /var/spool/mail, de manera que puedan ser accedidos por cualquier programa de correo del sistema (mailx, pine, y, como veremos ahora, Netscape). Simplemente debemos configurar nuestro cliente de correo especificando como servidor POP nuestra propia máquina (localhost, 127.0.0.1, etc). Tras haber recogido todos los mensajes con fetchmail y ya desconectados de la Red, en el cliente de correo (por ejemplo Netscape) le damos a GET NEW MESSAGES (Obtener nuevos mensajes) y aparecerán ante nosotros los emails recogidos por fetchmail dispuestos para ser respondidos totalmente offline.

Salu2,

Lester Espinosa Martínez

Envio de correo: Sendmail basico

Una de las necesidades básicas en nuestros sistemas Linux es el envio de correo electrónico o email a direcciones fuera de nuestra red local (a Internet, por ejemplo) o, en general, de nuestra propia máquina. Cuando escribimos un email en mailx, en Netscape, o en cualquier otro cliente de news, hace falta alguien que lleve dicho mensaje hasta el servidor de correo saliente (SMTP) de nuestro proveedor de Internet para que éste deje cada mensaje en el buzón destino correcto. Esta es una de las tareas que sendmail puede realizar en nuestras máquinas.

En nuestros envios de mensajes, pues, necesitamos un agente que extraiga dicho correo de /var/spool y lo envie a nuestro Proveedor de Servicios de Internet (por ejemplo, a smtp.dominio.com). Sendmail es un programa tan completo que su estudio dispone de libros de cientos de paginas (incluso hay alguno que llega al millar de ellas) para abordar su gestión completa. Ya que muchos disponemos de Linux en nuestras propias máquinas (y somos también root de ellas), vamos a exponer el método más sencillo de configuración para uso con un sólo Proveedor de Servicios de Internet (ISP).

Lo primero es saber si lo tenemos instalado y con el daemon funcionando. Normalmente dicho paquete estará instalado y funcionado ya que es un daemon básico en todas las distribuciones Linux. Para arrancar el daemon (si no lo tenemos ya funcionando) y de paso chequear si está instalado, basta con ir a /etc/rc.d/init.d en el caso de Redhat (en otras distribuciones puede variar el directorio) y ejecutar:

  /etc/rc.d/init.d/sendmail stop
 /etc/rc.d/init.d/sendmail start

Obtendremos lo siguiente.

  [root@Centos /root]# /etc/rc.d/init.d/sendmail stop
 Shutting down sendmail: sendmail
 [root@Centos /root]# /etc/rc.d/init.d/sendmail start
 Starting sendmail: sendmail

También podemos observar simplemente si durante el arranque y lanzamiento de los daemons del sistema sendmail es iniciado con lo que no haría falta su lanzamiento manual.Tras asegurarnos de disponer de sendmail instalado y si somos root de nuestra máquina procederemos a la configuración más básica y sencilla del mismo (también es posible contactar con el administrador o root de la misma si no lo somos), que consiste en la edición del fichero de configuración /etc/sendmail.cf, (por ejemplo con el editor joe, emacs, jed, etc) con el fin de modificar algunas líneas del mismo y configurar sendmail para nuestro uso:

• Buscamos una línea similar a la siguiente:

    # "Smart" relay host (may be null)
   DS

  Esta línea hay que cambiarla de forma que referencie a nuestro servidor de correo saliente o smtp (para que sendmail envie a dicho servidor nuestro correo). A título de ejemplo, mi servidor de correo saliente es smtp.dominio.com, por lo que la línea debe quedar como:

    # "Smart" relay host (may be null)
   DSsmtp.dominio.com

  La dirección del servidor de correo saliente puede ser otra, pero suelen tener todas el mismo formato (stmp.dominio.com, smtp.dominio1.com, etc). De todas formas nuestro proveedor debe de facilitarnos el nombre de la máquina servidora de correo saliente al inscribirnos en dicho ISP.

• Ahora tenemos que enmascarar nuestra dirección de correo (es decir, modificar el fichero de configuración para que las direcciones de retorno de emails no sean las que tenemos en nuestra máquina (como lester@Centos), sino las direcciones de retorno reales. Para ello buscamos la siguiente línea:

    # Who I masquerade as (null for no masquerading)
   DM

  A esta línea se le añade el dominio de nuestra dirección de correo. Si mi dirección email es lester@dominio.com, el dominio es dominio.com:

    # Who I masquerade as (null for no masquerading)
   DMdominio.com

Con estos cambios estamos forzando a que cuando se escribe un email, la dirección de retorno del mismo tenga el dominio correcto, cosa que se podría modificar de igual manera (sin el retoque de sendmail.cf) si nuestro programa para leer/contestar el correo permite hacerlo (en PINE, por ejemplo, modificamos la cabecera FROM en las opciones, en CUSTOMIZED-HEADERS). Para un usuario medio (acceso a Internet, recogida y envio de correo en un proveedor, etc.), el método comentado del sendmail.cf es más que suficiente. Además existen otros métodos e incluso otros MTAs (agendes de correo) como qmail o smail, que pueden realizar el mismo papel de una manera más sencilla.Una vez realizada la configuración, supongamos que desde un usuario cualquiera enviamos un email a pepe@proveedor.com, mediante el comando mail pepe@proveedor.com. Dicho email se grabará en /var/spool/mqueue a la espera de ser enviado a nuestro ISP quien a su vez lo enviará al usuario juan. Es decir, los emails que enviemos a Internet se guardarán en el directorio del correo hasta que se realice su envio mediante sendmail en la próxima conexión a Internet, gracias al comando “sendmail -q”. Los mensajes en cola de envío se encuentran en /var/spool/mqueue (por si queremos releerlos o borrar alguno), y podemos consultarlos mediante el comando mailq.

Sendmail es un daemon o demonio, es decir, está ejecutandose en nuestra consola continuamente tratando de enviar el correo cada X tiempo. Para evitar esto, y obligarle a que el envío se realice manualmente por nuestra parte, debemos modificar el arranque de sendmail en el fichero /etc/rc.d/init.d/sendmail cambiándolo para que arranque con las siguientes opciones:

  daemon /usr/sbin/sendmail -bd -oDeliveryMode=d

Otro problema común es recibir una advertencia (warning) cada vez que un mensaje lleve más de X hroas sin ser enviado (4 por defecto). Para evitar eso tan sólo hay que editar /etc/sendmail.cf y comentar (colocando un símbolo # al principio de la línea, y, por tanto, deshabilitándola) la siguiente opción:

  Timeout.queuewarn=4h

Otra opción a comentar (añadiendo # al principio de la línea correspondiente en sendmail.cf) es la siguiente:

  Timeout.queuereturn=5d

Esta opción especifica que si el correo no ha podido ser enviado durante 5 días debe ser devuelto a sendmail. Esto puede ser util si estamos enviando los emails a un proveedor y se pierden, con lo que gracias a la devolución podrían ser reenviados, pero en nuestro caso no va a ser necesario pues los mensajes residiran en nuestro disco duro hasta el momento en que los enviemos.En resumen: sendmail es un agente de transporte de correo (MTA) que recoge nuestros emails y los deja temporalmente como simples ficheros de texto que son en /var/spool/mqueue a la espera de realizar su distribución a los destinatarios especificados. Esta entrega se puede hacer bien mediante el comando “sendmail -q” o bien esperando a que el sistema llame a sendmail (lo llama cada X tiempo, siendo este tiempo programable) para que lo distribuya. Este tiempo, así como los restantes parámetros de configuración (como el servidor SMTP, que es el lugar a donde sendmail debe enviar los mensajes, es decir, nuestro proveedor de Internet) se pueden especificar en el fichero de configuración /etc/sendmail.cf .

Gracias a sendmail podremos enviar mensajes de corre electronico estando desconectados de Internet, mensajes que serán enviados por él cuando se realice la próxima conexión. Esto nos permitirá responder el correo electrónico desde nuestro cliente de correo, con el siguiente mecanismo: una vez configurado sendmail, en nuestro cliente de correo ponemos como SMTP la dirección IP de nuestra máquina (nuestra IP de red, nuestro nombre de máquina o bien 127.0.0.1 o localhost) de modo que cuando escribamos un mensaje en Netscape y pulsemos en Enviar, éste será enviado *a nuestra propia máquina* de tal forma que sendmail se encargará de enviarlo durante la próxima conexión a Internet cuando se ejecute mediante “sendmail -q” o como daemon temporal. Esto nos permite contestar el correo electronico en nuestro cliente favorito, sin gasto de teléfono por nuestra parte, y pudiendo simplemente enviar los mensajes y dejar que sendmail los distribuya al conectar a Internet.

Salu2,

Lester Espinosa Martínez

¿Cómo puedo leer y contestar correo con mail/mailx?

El correo electrónico en Linux no puede considerarse como un extra al sistema operativo, sino que forma parte del mismo pues es una característica casi inherente a todo Linux. Esto quiere decir que aunque no hayamos instalado ningún cliente de correo como Netscape o Pine, probablemente dispondremos en el sistema de herramientas ya preparadas para ello.

Dentro de casi cualquier sistema Linux disponemos de un programa básico de email en consola (modo texto) llamado Mailx que nos permitirá el envio, lectura y contestación de mensajes de correo electrónico. En resumen, posibilita el envío de texto y datos dentro de una estructura coherente llamada mensaje, con su cabecera (campos: FROM (persona que envía el mensaje), TO (persona destinataria del mismo), SUBJECT (tema del que trata el mensaje) y CC o carbon copy (lista de personas que recibirán una copia del mismo).) y su BODY (cuerpo del mensaje), pudiendo incluir además ficheros añadidos que vienen incluidos dentro del paquete del mensaje (attach).

Para explicar el uso de mailx se va a usar un sencillo ejemplo en un máquina con un sólo usuario: sromero, además del obligatoriamente existente root (puede obternerse la lista de usuarios presentes en el sistema y en qué terminal están trabajando simplemente ejecutando la orden who). Suponga os que somos el usuario sromero y queremos enviarle un mensaje a root para testear las capacidades de envio de email. La manera más sencilla de enviar un mensaje a un usuario de la red es ejecutar mail :

  [lester@Centos info]$ mail root
 Subject: Prueba de MailX.
 Esto es el cuerpo del mensaje. Es una prueba de mailx.
 Un mensaje se acaba con un punto (.) al principio de línea.
 .
 Cc: (intro)

Al ejecutar mail root se nos ha preguntado el tema (subject), el cuerpo del mensaje (acabado en punto (.)), y a quién se le deseaba enviar copias del mismo (Cc), cosa que hubiera sido bastante útil si nuestro mensaje fuera una invitación a un grupo de amigos o una información para un grupo concreto de personas. Tras escribir esto, el mensaje escrito se graba como un fichero de texto (con el mismo nombre que el destinatario del mensaje, y al que se añadirán más mensajes conforme se le vayan enviando a dicho destinatario) en el directorio /var/spool/mail, a la espera de que el usuario destino los lea y vayan siendo eliminados del mismo.Si root está conectado o entra más tarde en cualquier terminal del sistema, recibirá un mensaje de aviso indicando que el sistema ha detectado la llegada de correo para el usuario:

  You have mail.

Para realizar la lectura del correo electrónico, simplemente se invoca al programa mail, obteniendo una lista del correo pendiente y esperando el programa a que el usuario lo lea, responda, borre o almacene para más tarde:

  [root@Centos /root]# mail
 Mail version 8.1 6/6/93.  Type ? for help.
 "/var/spool/mail/root": 3 messages 3 new
 >N  1 lester   Thu Jul 30 17:04  17/55   "Prueba de MailX."
  N  2 lester   Thu Jul 30 17:15  17/50   "Pregunta sobre adm"
  N  3 lester   Thu Jul 30 17:16  15/44   "Felices vacaciones!"   & _

Como puede verse, mail nos muestra los mensajes pendientes (en este caso 3) por responder, con su usuario de origen (sromero), la fecha y el tema, con el cursor virtual (>) situado sobre el primero (es decir, indicando sobre cual actuará una orden de lectura, respuesta o borrado), y con un promtp (el carácter &) a la espera de recepción de órdenes sobre qué hacer con dicho correo.Estas órdenes son:

  'número' -> Listar el mensaje .
 't' -> lista el mensaje actual (el apuntado por >)
 'n' -> Pasar al siguiente mensaje y visualizarlo.
 'd' -> Borrar mensaje.
 'e' -> Editar mensaje
 'r' -> Responder mensaje.
 'q' -> Salir de mailx.

A la mayoría de estas opciones se les puede pasar un nº de mensaje (desde 1 hasta n) para indicar sobre qué mensaje realizar la acción (ejemplo ‘d 3′ o ‘delete 3′). Otras opciones, obtenidas mediante la ayuda de mailx, son:

  & ?   Mail Commands
 t    listar mensaje
 n    ir al mensaje especificado y listarlo.
 e    editar mensaje
 f    ver cabeceras del mensaje
 d    borrar mensaje
 s    añadir mensajes a un fichero
 u    recuperar mensajes borrados
 R    Responder a los remitentes del mensaje
 r    Responder al remitente y a todos los destinatarios.
 pre  hacer ir los mensajes de nuevo a /usr/spool/mail
 m    enviar mensaje a los usuarios especificados.
 q    salir grabando mensajes en mbox
 h    mostrar cabeceras activas.
 !    permite ejecutar una shell o comandos de shell

En el caso de no disponer de correo en ese momento, mail nos avisa con un:

  [root@Centos root]# mail
 No mail for root

Otro fichero asociado es el fichero .signature de nuestro directorio home, utilizado como fichero de firmas y cuyo contenido es incluido al final de los emails escritos y respondidos por nosotros, pudiendo editarse y rellenarse con cualquier editor estándar de Linux para incluir nuestra firma personal. Este fichero es utilizado por la mayoría de gestores de correo de Linux como fichero de firmas por defecto, tal y como hace Mail, Pine, Netscape, Kmail, etc.

Salu2,

Lester Espinosa Martínez

¿Cómo se cambian los permisos de ficheros y directorios?

Lo primero que hay que decir es que para conseguir toda la información sobre los comandos involucrados en el tema de permisos podeis consultar man chmod, man chown y man chgrp

Información de un fichero/directorio

Cuando obtienes información sobre un fichero/directorio, existen diferentes campos que te dicen que clase de permisos el fichero/directorio tiene.

  Ej:

  [lester@Centos]# ls -l
 -rwxr-x---   1 pepito depart1     4348 Nov 24 16:19 test

En la primera columna se pueden ver una serie de letras -rwxr-x---, estas letras nos dicen quien en el sistema, y que clases de permisos tiene el fichero test.Estas letras están agrupadas en tres grupos con tres posiciones cada uno, más una primera posición que nos dice de que clase de archivo se trata (los mas normales (d) directorios, o (-) archivos de datos). En nuestro ejemplo la primera posición es (-) con lo cual el archivo test, es un archivo de datos (binario/ejecutable en este ejemplo).

El primer grupo de tres (rwx en nuestro caso) nos dice que clase de permisos tiene el dueño del fichero (u)(user/owner)).
El segundo grupo de tres (r-x en nuestro caso) nos dice que clase de permisos tiene el grupo del fichero (g)(group).
Y el último grupo de tres (— en nuestro caso) nos dice que clase de permisos tienen todos los demás usuarios del sistema sobre este fichero(o)(others).

  r :significa permiso para leer
 w :significa permiso para escribir
 x :significa permiso para ejecutar

La segunda columna pepito, nos dice quien es el dueño del fichero,(pepito en este caso).
La tercera columna depart1, nos dice cual es el grupo del fichero (depart1 en este caso).
La cuarta columna 4348, nos dice el tamaño del fichero.
La quinta columna Nov 24 16:19, nos dice cual es la fecha y hora de la última modificación.
La sexta columna test, nos dice cual es el nombre del fichero/directorio.

Asi pues, el fichero test de nuestro ejemplo tiene los siguientes permisos:

• pepito puede leer, escribir/modificar, y ejecutar el fichero test.
• depart1 puede leer, y ejecutar pero no escribir/modificar.
• Los demás usuarios no pueden hacer nada, ni leerlo, ni escribir/modificar, ni ejecutarlo.

Como cambiar los permisos/dueño/grupo de un fichero/directorio?:

Para cambiar el dueño del fichero: chown usuario fichero
Para cambiar el grupo del fichero: chgrp grupo fichero
Para cambiar los permisos se utiliza el comando: chmod permisos fichero

Los permisos se pueden especificar de diferentes maneras, una serie de ejemplos, es lo mejor para comprenderlo:

  chmod ugo+rwx test (da permisos rwx a todos, user,group,others)
 chmod ugo-x test (quita permiso x (ejecucion) a todos, user,group,others)
 chmod o-rwx test (quita permisos rwx a others)
 chmod u=rwx,g=rx test (da permisos rwx a user, rx a group y ninguno a others)

Asi podriamos continuar con todas las posibles combinaciones de letras, es cuestión de usar la imaginación ;-) Existe otro metodo que utiliza numeros, en vez de letras para asignar permisos, la siguiente tabla nos puede ayudar un poco a comprender esta manera:

  r w x  VALOR DECIMAL
 0 0 0  0 (000 binario es 0 en decimal)
 0 0 1  1  .........
 0 1 0  2  .........
 0 1 1  3  .........
 1 0 0  4 (100 binario es 4 en decimal)
 1 0 1  5  .........
 1 1 0  6  .........
 1 1 1  7 (111 binario es 7 en decimal)

1 significa activado y 0 desactivado, o sea 101 activa r y x, y desactiva w.

Sabiendo esto solo tenemos que usar el valor decimal, un ejemplo aclarara esto.

  chmod 750 test
 da permisos rwx al usuario (7=111)
 da permisos r-x al grupo (5=101)
 da permisos --- a los demas (0=000)

Salu2,

Lester Espinosa Martínez

¿Cómo se convierten paquetes entre RPM, DEB y TGZ con alien?

Alien es un programa que permite convertir un paquete binario entre los formatos rpm (Redhat, Suse), deb (Debian) y tgz (Slackware):

Conversion a .DEB:

    alien --to-deb paquete.elquesea

Conversion a .RPM:

    alien --to-rpm paquete.elquesea

Conversion a .TGZ:

    alien --to-tgz paquete.elquesea

Existen otros flags (como -i) que permiten directamente tras la conversión realizar la instalación del paquete generado. Alien realiza la conversión descomprimiendo el paquete original y generando el nuevo paquete, diciéndonos el lugar del árbol de directorios donde dejará el paquete recién generado, según la distribución (por ejemplo, en Redhat en /usr/src/redhat/RPMS/).

Salu2,

Lester Espinosa Martínez

¿Cómo instalo, desinstalo o actualizo paquetes rpm?

Los paquetes rpm son archivos que llevan incluidos dentro de ellos todos los ficheros que componen un determinado programa. Internamente están comprimidos, pero nosotros sólo debemos pensar en ellos en términos de Instalación, Actualización, Borrado y Consultas. Dentro del rpm van los ficheros del programa a instalar, su descripcion, a que directorios van a ir instalados, scripts de auto-configuración en algunos casos, etc.

La sintaxis de rpm es rpm -acción nombre_del_paquete

Acciones:

  rpm -i  archivo   (instalar)
 rpm -e  paquete   (desinstalar)
 rpm -u  paquete   (actualizar)
 rpm -qi paquete   (pedir info)

Ejemplos:

  rpm -i  Par-1.50-1.i386.rpm
 rpm -e  Par
 rpm -u  Par
 rpm -qi Par

Supongamos el fichero programa-1.0.rpm que no tenemos instalado y que acabamos de bajar de Internet. Procedemos a su instalación:

  rpm -i programa-1.0.rpm

Tras eso el programa estará instalado en nuestro Linux y podremos ejecutarlo y usarlo normalmente. Tal vez nuestro problema es que no sabemos como se llama el ejecutable y los demás ficheros de configuración que le acompañan. Para solucionar eso hacemos una consulta (query) del paquete ya instalado:

  rpm -ql programa

La acción -ql significa “query list”, y nos mostrará en pantalla la lista de ficheros instalados de este programa y sus directorios destinos. Si por ejemplo deseamos ver sólo los fichero sean instalados en los directorios bin (los ejecutables) podemos hacer uso de grep, la herramienta de Linux que sólo nos mostrará aquellas líneas que contengan una cadena determinada:

  rpm -ql programa | grep bin

Esto nos mostrará sólo los ficheros de “programa” que hayan sido instalados en directorios bin.Si queremos saber que hace un paquete instalado, podemos verlo con la opción “query info” (-qi):

  rpm -qi programa

Como ejemplo, veamos la salida para el paquete fetchmail de Linux:

  Name        : fetchmail
 Relocations : (not relocateable)
 Version     : 5.0.0
 Vendor      : Red Hat Software
 Release     : 1
 Install date: dom 30 may 1999 16:00:12 CEST
 Group       : Applications/Internet
 Size        : 565413
 Packager    : Red Hat Software http://developer.redhat.com/bugzilla
 Summary     : A remote mail retrieval and forwarding utility.
 Description : Fetchmail is a remote mail retrieval and forwarding utility intended
               for use over on-demand TCP/IP links, like SLIP or PPP connections.
               Fetchmail supports every remote-mail protocol currently in use on the
               Internet (POP2, POP3, RPOP, APOP, KPOP, all IMAPs, ESMTP ETRN) for
               retrieval.  Then Fetchmail forwards the mail through SMTP, so you can
               read it through your normal mail client.

Si el programa no nos gusta, la deinstalación es muy sencilla:

  rpm -e programa

Obviamente, no tenemos porqué instalar los programas para ver su contenido o información. Los podremos ver antes de la instalación insertando un comando p antes de la acción:

  rpm -qpi fichero.rpm
 rpm -qpl fichero.rpm

Si queremos ver la lista de RPMs instalados disponemos del comando “query all” (-qa):

  rpm -qa

Para verlo en formato pausado, podemos usar una tubería:

  rpm -qa | less

Es posible que tras un tiempo obtengamos la versión 2.0 del programa que ya disponemos instalado. En esto caso hay 2 opciones: bien eliminar el programa anterior (-e) e instalar este nuevo (-i), o, simplemente, actualizar el programa a la versión 2.0 con el comando -U (de Update):

  rpm -U programa-2.0.rpm

Por último, si al tratar de instalar un paquete rpm aparece el siguiente error:

  Data type X not supprted

Esto es debido a que nuestra versión de rpm es muy antigua, al menos más que el rpm que estamos tratando de instalar, y que este tiene algún tipo de compresión o elemento que nuestro rpm no entiende. Bastará entonces con actualizar nuestro ejecutable del RPM.Cabe decir que también existen front-ends al programa rpm, es decir, programas en modo gráfico (o texto) que realizan las acciones del programa RPM mediante pulsaciones nuestras del ratón. Es el front-end el que se encarga de pasarle a RPM los parámetros correctos para que se realice la acción pedida por el usuario. Entre estos programas tenemos glint, gnorpm, purp, kpackage, xrpm, etc.

Salu2,

Lester Espinosa Martínez

¿Cómo se utilizan los empaquetadores-des/compresores?

Los ficheros tar no son ficheros comprimidos, sino empaquetados. Tar es un empaquetador, es decir, es algo parecido a un compresor como arj o zip, pero sin compresión. Se dedica a incluir todos los ficheros juntos en el mismo archivo, preservando las estructuras de directorios y permisos de los mismos. Como veremos, lo podremos comprimir gracias al programa GZip.
Hay 2 operaciones básicas con tar: empaquetado y desempaquetado. Si estamos en un directorio y queremos empaquetar todos los ficheros de este directorio y los que cuelgan de él, basta con ejecutar la orden:

  tar -cvf fichero.tar *
 c = compress  (más bien, empaquetar)
 v = verbose   (para que nos diga lo que hace)
 f = file      (empaquetar en un fichero)
 *             (empaquetar todos los ficheros, podría haber sido *.doc, etc.)

Si disponemos de un fichero .tar y queremos desempaquetarlo:

  tar -xvf fichero.tar
 x = eXtract   (desempaquetar).

También es posible listar los contenidos de un fichero .tar antes de desempaquetarlo, mediante la orden tar -tvf fichero.tar .Por otra parte, el ficheros con extensión gz son ficheros comprimidos. A diferencia de arj o zip, el contenido de un fichero GZ es un solo fichero, es decir, cuando comprimimos fichero.txt con este compresor (llamado gzip) obtenemos un fichero.txt.gz de tamaño mucho menor. Con GZ no es posible empaquetar ficheros, es decir, la compresión se realiza a un sólo fichero.

Para comprimir un fichero con gz, se utiliza el comando:

  gzip fichero

Para descomprimirlo:

  gunzip fichero.gz

La combinación de tar y gz es lo que permite el tener multiples ficheros comprimidos en un sólo archivo. Es decir, si empaquetamos un directorio con tar y luego comprimimos ese archivo tar con gz, obtenemos un tar.gz comprimido con múltiples ficheros.La compresión y descompresión es posible hacerla en 2 pasos (primero tar y luego usar gz) o bien usar el flag -z de tar para ello:

Compresión:

  tar -cvzf fichero.tar.gz *

Descompresion:

  tar -xvzf fichero.tar.gz

Otro formato que se ha puesto de moda es bzip2, con el mismo sistema de funcionamiento que Gzip, y cuyos nombres de ejecutable son bzip2 (comprimir) y bunzip2 (descomprimir). Este compresor obtiene mejor compresión que Gzip y su funcionamiento es igual de sencillo, aunque tarda mas en comprimir y utiliza mas recursos.Estos compresores/descompresores/empaquetadores son una gran y libre alternativa a formatos comerciales como zip, arj y rar, también disponibles para Linux (comandos zip, unzip, rar y unarj).

Para descomprimir ficheros arj mediante unarj, simplemente hace falta ejecutar el comando unarj x fichero.arj. El compresor es shareware y se debe obtener en la Web de sus programadores.

Zip es el programa destinado a hacer Linux capaz de leer y escribir los ficheros en formato .zip (generados por pkzip o winzip): Para ello tenemos los comandos zip e unzip, que nos permitiran comprimir y descomprimir ficheros sueltos, directorios completos, directorios con recursividad, etc:

Para comprimir todos los ficheros de un directorio en un zip:

  zip fichero.zip *

Para comprimir este directorio y todos los que cuelguen del mismo:

  zip -r fichero.zip *

La descompresión se realiza mediante unzip:

  unzip fichero.zip

El programa rar también es un buen compresor que podemos encontrar en diferentes formatos (rpm, deb, tar.gz) en Internet. Su uso es identico a la versión MSDOS:Comprimir:

  rar a fichero.rar *

Descomprimir:

  rar x fichero

Para más información sobre cualquiera de los des/compresores basta con consultar la página man del mismo, mediante “man comando“.

Salu2,

Lester Espinosa Martínez

¿Cómo arranco directamente en XWindow?

En Linux es perfectamente posible pedir que el arranque del sistema se haga en modo gráfico, y que el login y password se introduzcan directamente en una ventana XWindow para la posterior carga del gestor de ventanas habitual que use dicho usuario.
Es decir, podremos identificarnos y aparecer directamente bajo X sin necesidad de ejecutar startx.

Para arrancar directamente en XWindow (o no hacerlo) todo el proceso de configuración gira en torno a cambiar el runlevel (o nivel de ejecución en que arranca Linux).

El runlevel es, dicho de una manera sencilla, el modo en que arranca Linux. Por defecto el runlevel suele ser el 2 ó el 3, es decir, arranque en modo texto o consola ó en modo gráfico. Para cada distribución suele haber una lista de runleves y sus significados, aunque casi se puede decir que son similares para todas ellas. Para Redhat, por ejemplo, la lista es la siguiente:

  # Porción del fichero /etc/inittab
 # Default runlevel. The runlevels used by RHS are:
 #   0 - halt (Do NOT set initdefault to this)
 #   1 - Single user mode
 #   2 - Multiuser, without NFS (The same as 3)
 #   3 - Full multiuser mode
 #   4 - unused
 #   5 - X11
 #   6 - reboot (Do NOT set initdefault to this)

Como puede verse, el arranque normal por defecto para que puedan acceder usuarios a Linux es 2 (si no tenemos red) o 3 si queremos usar servicios de red, siendo normalmente este el runlevel por defecto. Como puede verse, X11 tiene asignado el runlevel al 5. Si cambiamos el runlevel por defecto para que arranque en el 5, nos aparecerán directamente X Window.Para cambiar este runlevel por defecto hay que editar el fichero /etc/inittab, y acudir a la siguiente línea:

  id:3:initdefault:

El valor numerico antes de initdefault indica el runlevel de arranque por defecto. Si lo cambiamos de 3 a 5, la próxima vez que arranquemos Linux arrancará en X Window:

  id:5:initdefault:

Para que el proceso se ejecute correctamente debe tener instalado un gestor de arranque en runlevel 5, que es el programa encargado de pedir el login+passwd y arrancar el gestor de ventanas adecuado. Puede elegir entre xdm (el que viene por defecto con XWindow), kdm (version de kde del mismo) y gdm (versión aportada por gnome). Cada una de ellas dispone de ciertos ficheros de configuración o ejecutables para cambiar el fondo del login, el lenguaje, gestor de ventanas, etc. Consulte los ficheros en los paquetes relacionados.Haga “man runlevel” para mas información sobre runlevels.

En las últimas versiones de Redhat, el programa Xconfigurator le permite elegir si desea o no arrancar directamente en XWindow (él mismo modifica el runlevel por defecto) mediante una simple pregunta a la que se debe responder SI (Si desea arrancar en runlevel 5) o NO (si desea arrancar en runlevel 3). Esta pregunta se le suele realizar al finalizar la selección de resoluciones y antes de salir de Xconfigurator.

Una vez arranque en XWindow, puede volver a cualquier consola de texto mediante las teclas Ctrl+Alt+F1, Ctrl+Alt+F2, etc. (por defecto entre F1 y F6 tendrás 6 consolas de texto), y volver a XWindow en cualquier momento mediante Ctrl+Alt+F7 en adelante.

En algunas distribuciones puede ser necesario indicarle a inittab dónde está el gestor de runlevel 5 que debe arrancar:

Para xdm:

  #Run xdm in runlevel 5
 x:5:respawn:/usr/X11R6/bin/wdm -nodaemon

Para gdm:

  x:5:respawn:/etc/X11/prefdm -nodaemon

Estas líneas suelen ser automáticamente incluidas en el fichero por los rpm/deb instaladores de xdm, kdm y gdm. Consulte en la ayuda de dichos programas para más información.

Salu2,

Lester Espinosa Martínez

Uso de la memoria RAM

Este tema, aunque no lo crea, también se relaciona con los procesos. Además, es una de las mayores diferencias con otros sistemas operativos.Apenas use el comando free usted verá algo como esto:

[lester@Centos lester]$ free
            total       used       free     shared    buffers     cached
Mem:        251960     246884       5076          0      16136     110072
-/+ buffers/cache:     120676     131284
Swap:       393552       3612     389940
[lester@Centos lester]$

Interpretemos esto: el comando nos devuelve información ordenada a partir del archivo /proc/meminfo. La primera línea de free muestra datos de la RAM instalada en el sistema, empezando por la total (256 MB, de los cuales más o menos 5 se usan para ocultar el kernel y algunas otras cosas); con aparentemente 246 MB usados, y sólo unos 5 MB libres. Esto es lo que a muchos usuarios nuevos (a nosotros incluídos) les hizo alguna vez sorprenderse. Ahora, sigamos leyendo hasta el final: hay aproximadamente 110 MB de memoria cacheada, es decir, con datos almacenados por si acaso. Esa cantidad de memoria en realidad está disponible si algún proceso la usa, pero si no, almacena librerías compartidas o accesos a directorios, lo que acelera su carga.

Es por esta razón que no hay que apagar de manera “incorrecta” la PC: gran parte del sistema de archivos puede estar abierto y cargado en la RAM, por lo que un Reset “duro” puede provocar la pérdida de datos. Esto se hace cada vez más difícil a medida que los sistemas de archivos de Linux mejoran, pero lo mejor siempre será tomarse la molestia de apagar con el comando halt -p o desde el modo gráfico.

Como siempre espero que les haya resultado de gran utilidad… ;)

Salu2,

Lester Espinosa Martínez

Uso de pipes o tuberías

¿Recuerda el principio de estos tutoriales, donde dijimos que una de las virtudes de Unix es la modularidad? Bueno, lo que conecta entre sí todos estos pequeños programas o módulos son los pipes o tuberías. Se usa el símbolo | (en un teclado con mapeado español se obtiene con Alt Gr + 1) para representar un pipe entre un proceso y otro. Los pipes permiten que la información que da un comando esté disponible directamente para otro comando. ¿Ejemplos? Veamos:

[lester@Centos foo]$ rpm -qa | grep gnomeicu
gnomeicu-0.98.126-2mdk

Como ve, usamos el resultado del comando rpm -qa (mostrar la lista de todos los paquetes rpm) como entrada para el comando grep gnomeicu Resultado: buscamos dentro de la lista de todos los paquetes los que contuvieran la frase “gnomeicu”. Otro ejemplo:

[root@Centos foo]# cat /var/log/messages | less

Le mostrará el contenido del archivo de log messages (deberá conectarse como root). No hay límite a la cantidad de pipes que pueda usar. Ultimo ejemplo:

tar -cvf docs.tar docs/ | gzip -v docs.tar
docs.tar: 65.2% -- replaced with docs.tar.gz

Esto crea un archivo agrupado con el comando tar, y luego gzipea (comprime) ese archivo.

Espero que les haya resultado de gran utilidad… ;)

Salu2,

Lester Espinosa Martínez

nice y renice

Estos programas permiten algo importante: cambiar la prioridad de un proceso. En Linux, los procesos corren con un número de importancia entre 19 (la menor) y -20 (la más alta). Los procesos con mayor prioridad tienen preferencia de procesamiento.

¿De qué puede servir esto? Bueno, suponga que quiere grabar un CD y seguir trabajando (suponga también que la PC puede hacer el trabajo). Podría iniciar el comando cdrecord con una prioridad alta, y despreocuparse. Para esto tendrá que conectarse como root, eso sí: un usuario común no puede elevar la prioridad a números negativos (recuerde que la máxima prioridad es -20):

[lester@Centos foo]$ nice -n 8 aterm &
[2] 5782
[1]   Done                    nice -n 8 aterm
[lester@Centos foo]$ nice -n -10 aterm &
[3] 5814
nice: no se puede establecer la prioridad: Permission denied
[3]+  Exit 1                  nice -n -10 aterm
[lester@Centos foo]$

Como ve, el uso de nice es simple: la opción -n número le permite cambiar el número de prioridad. Para cambiar la prioridad de un proceso que ya está corriendo, deberá usar el comando renice, con las mismas limitaciones que nice: un usuario común no puede elevar demasiado la prioridad de un proceso. Deberá conocer el PID del proceso que quiere modificar, y aprovecharemos esto para introducir el siguiente concepto a tratar: variables de shell:

[lester@Centos foo]$ nice -n 3 gvim &
[1] 6630
[lester@Centos foo]$ renice 4 $(/sbin/pidof gvim)
6631: prioridad antigua 3, nueva prioridad 4
[1]+  Done                    nice -n 3 gvim

A ver qué hicimos aquí. Primero iniciamos el editor de texto gvim con una prioridad de 3 y en segundo plano. Posteriormente le cambiamos la prioridad a cuatro, usando renice. Esta es la explicación simple, y deja varias cosas por comentar, que veremos inmediatamente. Pero antes, una aclaración: el comando renice sólo funcionará para procesos que el usuario pueda alterar (es decir, que él haya iniciado) y sólo para incrementar prioridades (es decir, para “quitarle importancia” al proceso. Conectándonos como root podremos además aplicar prioridades negativas, y cambiar el factor nice de usuarios (con la opción -u): todos los procesos de esos usuarios correrán por defecto con ese valor de nice.

Espero que les sea de gran utilidad… ;)

Salu2,

Lester Espinosa Martínez

PIDs

Ha llegado el momento de hablar un poco más sobre los procesos y su creación. Como ya habrá notado, llamamos proceso a cualquier programa corriendo. En Unix, un proceso se inicia y puede dar nacimiento a otros, que son sus hijos, mediante lo que se conoce como forking o ramificación. Si conoce de biología, el forking es similar a la división celular: allí donde había un proceso hay una división, y quedan dos. Para ordenar esto y poder llamar a cada uno de los programas que corren, el sistema usa la tabla de procesos, en la que cada proceso lleva un número único, dado por el orden de aparición. El primer proceso es init, y de él se desprenden todos los otros al arrancar el sistema. Podríamos tener entonces algo como esto:

[root@Centos foo]# pstree
init-+-bbpager
    |-bdflush
    |-login---bash---startx---xinit-+-X
    |                               `-blackbox---xscreensaver

La lista será más larga, pero aquí podemos ver los conceptos de los que hablábamos: pstree (árbol de procesos) muestra todos los procesos principales en árbol. Cuando un proceso se ramifica se muestra un símbolo +, y todos los procesos forkeados aparecen a igual altura. Además, un proceso hijo se muestra como una rama de su padre. En el ejemplo, bash es hijo de login, y startx es hijo de bash.

Ya que hemos hablado de padres e hijos, hablemos de herencia. Como verá en el tutorial sobre usuarios y permisos, cada archivo (y también cada programa) tienen permisos de usuario. Ahora bien, cuando un proceso “nace” hereda algunos de los privilegios o permisos de su padre, a menos que (aquí empieza la diferencia con la vida real) tenga otros propios. Un servidor web o un programa no corren con privilegios de root sólo porque init sí lo hace. Esto depende en parte de que antes de usarlos hay que conectarse usando login, y en parte de que algunos procesos tienen definida su propia cuenta de usuario.

Pero basta de teoría, y sigamos viendo cómo administrar procesos. Ya vimos dos o tres programas importantes: top, ps y kill. Ahora seguiremos con nice y renice.

Colas de comandos

Hola a todos nuevamente, hoy les dejo un importante proceso, el de las colas de comandos en la shell.

Cuando está trabajando, puede alguna vez querer ejecutar un montón de comandos y dedicar su atención de nuevo a otra cosa (digamos centericq, por ejemplo). El tipo de orden que de depende de una cosa: la relación entre los comandos. Si el resultado de un comando no influye en el comando siguiente, basta usar el símbolo ; para separar comandos en una línea. Si en cambio usted está haciendo una tarea (como compilar el núcleo) que necesita que cada uno de los comandos tenga éxito antes de empezar el siguiente, usará el símbolo &&.

Por ejemplo:

[lester@Centos lester]$ cd docs/foo/ ; ls ~
borrados.log  docs/  tmp/  xcdroast/
[lester@Centos foo]$

Nos lleva al directorio ~/docs/foo (como se ve por el prompt) y además muestra los archivos del directorio personal. Pero note esto:

[lester@Centos foo]$ cd docs/foo/bar/ ; ls ~
-bash: cd: docs/foo/bar/: No such file or directory
borrados.log  docs/  tmp/  xcdroast/
[lester@Centos foo]$

Aquí, aunque la primera orden tiene un error (no existe el directorio bar dentro de foo) la segunda orden sigue cumpliéndose.

Una última nota antes de seguir: cuando vea scripting en otros lenguajes, como perl, python o PHP, notará que el punto y coma se usa para separar comandos de la misma manera.

Ahora veamos el segundo modo con un ejemplo: compilar un programa es una tarea que implica una serie de pasos, y cada uno de ellos debe completarse sin errores para pasar al siguiente, y por eso usamos &&: sólo se pasa a la segunda etapa si la primera terminó correctamente:

[root@Centos foo]# ./configure && make && make install

Compilará correctamente el programa, o se detendrá al primer error. Note que estamos logueados como el usuario root para poder ejecutar make install normalmente.

Espero que les haya resultado de gran utilidad… ;)

Salu2,

Lester Espinosa Martínez

BG y FG: “minimizar” y “restaurar” en consola

Hola a todos nuevamente, aquí les traigo un tema de mucho interés, dado que la mayoría de los que utilizamos sistemas operativos GNU/Unix son con propósitos de servidores y para el ahorro de memoria y demás lo hacemos en consolas, no en pantalla gráfica.

Dado que Linux es un kernel con capacidades de multitarea, el shell incorpora comandos para hacer que los programas pasen al frente o al fondo, es decir, son el equivalente en el shell de las acciones “minimizar” y “restaurar”. bg envía un trabajo o proceso (un programa que está corriendo) atrás, y fg lo vuelve a traer. Si ha lanzado un comando en una consola puede pulsar Control + Z para pausar el proceso y bg para enviarlo al fondo. Ejemplo:

[lester@Centos docs]$ gnomeicu
(presionamos Control + Z)
[1]+  Stopped                 gnomeicu
[lester@Centos docs]$ bg
[1]+ gnomeicu &
[lester@Centos docs]$ fg
gnomeicu

Luego de ejecutar gnomeicu, pulsamos Control + Z. El trabajo se detuvo, y lo hicimos rearrancar en segundo plano con la orden bg. Note que el mismo resultado puede obtenerse ejecutando directamente gnomeicu &. El símbolo & aplicado al final de un comando hace que se ejecute en segundo plano. Por supuesto, eso no se limita a un solo programa: puede iniciar en segundo plano todos los programas que necesite. Ejecute el comando jobs para verlos a todos:

[lester@Centos lester]$ jobs
[1]-  Running                 gnomeicu &
[2]+  Running                 aterm &

Tenemos dos procesos corriendo ahora en segundo plano. Note el número a la izquierda: fg permite traer al primer plano selectivamente un proceso (por defecto el último) usando ese número. Por ejemplo:

[lester@Centos lester]$ fg
aterm
[lester@Centos lester]$ fg 1
gnomeicu

Espero les haya resultado de gran utilidad…

Salu2,

Lester Espinosa Martínez

Cómo monitorear procesos en las consolas desde la 8 a la 12…

Hola a todos nuevamente, aquí les dejo un importante proceso de un administrador de redes, el de utilizar las consolas desde la 8 a la 12 para monitorear lo que está sucediendo en nuestro sistema…

El truco básicamente está en editar el fichero:

Fichero –> /etc/rc.d/rd.local

###################################################################
#!/bin/sh
#
# This script will be executed *after* all the other init scripts.
# You can put your own initialization stuff in here if you don’t
# want to do the full Sys V style init stuff.

##########################################
# Ejecutando fetchmail como demonio al comienzo
#
/etc/fetchmail/run-fetchmail
##########################################
# Observando las conexiones TCP en la consola tty8
#
/usr/bin/watch -n 5 /bin/netstat -tn > /dev/tty8 &
#
#########################################
# Observando el fichero squid.log en la consola tty9
#
/usr/bin/tail -f /var/log/squid/access.log > /dev/tty9 &
#
###################################
# Observando el fichero fetchmail.log en la consola tty10
#
/usr/bin/tail -f /var/log/fetchmail/fetchmail.log > /dev/tty10 &
#
###########################################
# Observando el log del correo en la consola tty11
#
/usr/bin/tail -f /var/log/maillog > /dev/tty11 &
#
########################################
# Observando el log de mensajes en la consola tty12
#
/usr/bin/tail -f /var/log/messages > /dev/tty12 &
#
###################################################################

Espero que les sea de gran utilidad… ;)

Salu2,

Lester Espinosa Martínez

Comandos más utilizados…

Hola a todos, nuevamente…, aquí les dejo algunos de los comandos más utilizados y su explicación:

ls <– Igual que dir

mc <– Midnight Commander igual que el Norton Commander en MS-DOS, cuando lo utilice conectado por SSH (Secure SHell) con cualquier programa, como el PuTTY, entonces utilícelo con la opción -a (fuerza a usar caracteres como +,| y - para dibujar las líneas) Ejemplo: mc -a

su - <– Obtener privilegios root desde un usuario normal

locate nombre_fichero <– Buscar un fichero, primeramente deberás ejecutar el comando

updatedb como usuario root para llenar los índices de la base de datos de búsqueda

cat nombre_fichero <– Listar el contenido de un fichero, igual que el comando type de MS-DOS

ln -s directorio_origen directorio_destino <– Crear un enláce simbólico (acceso directo) desde un directorio a un directorio

rpm -q paquete_rpm <– Para saber si tienes el paquete RPM ese instalado

ps -faxu | grep fetchmail <– Ver procesos fetchmail (fetchmail es solo un ejemplo)

kill ### <– Matar proceso ### sabiendo el PID del proceso con el ejemplo anterior

switchdesk Tipo_escritorio <– Iniciar siempre en un escritorio predeterminado, donde Tipo_escritorio es KDE o GNOME por ejemplo.

Bueno, espero que les resulten de gran utilidad… ;)

Salu2,

Lester Espinosa Martínez

Montando particiones NTFS con LINUX

¿Qué versión de LINUX tenemos?

Lo primero que debemos conocer es la versión de la distribución y el kernel, para lo cual tecleamos el siguiente comando en la terminal:

cat /etc/redhat-release

Con esto, debemos de ver sólo una de las siguientes líneas; la que corresponda a la versión que utilizamos:

Fedora Core release 5 (Bordeaux)     
Fedora Core release 4 (Stentz)Fedora Core release 3 (Heidelberg)
Fedora Core release 2 (Tettnang)
Fedora Core release 1 (Yarrow)
Red Hat Linux release 9 (Shrike)
Red Hat Linux release 8.0 (Psyche)

Ahora, checamos la versión del kernel:

uname -r

Con lo cual veremos también sólo una de estas líneas, que nos dice la versión de kernel con la que contamos:
2.6.16-1.2080_FC5
2.6.12.-1.1447
2.6.9-1.667
2.6.5-1.358

Puede que la versión contenga alguno de estos sufijos:

smp            bigmemBOOT

Si nuestra versión termina con “smp”, entonces contamos con un equipo con multiprocesador.

Ahora veamos con qué tipo de procesador contamos (los usuarios con multiprocesador deben reemplazar “kernel” con “kernel-smp”):

rpm -q –queryformat “%{ARCH}n” kernel

Lo que probablemente nos diga que contamos con un “i686″ (si es que tenemos un equipo reciente con procesador Pentium). Otras opciones son “athlon”, “i586″ ó “i386″.

Ahora, descargamos los RPM necesarios de éste enlace, según nuestra versión de distribución, kernel y procesador que tengamos en nuestro equipo (vienen casi todas las combinaciones), y procedemos a instalar.

Instalación

Debemos contar con privilegios de root para ejecutar estos comandos. Supongamos que descargamos el rpm kernel-ntfs-2.6.12-1.447_FC4.i686.rpm. Entonces lo instalamos:

rpm -Uhv kernel-ntfs-2.6.12-1.447_FC4.i686.rpm     
Preparing...      ############################### [100%]
  1:kernel-ntfs  ############################### [100%]

Si éste fue el rpm correcto, entonces no debemos de tener ningún error.

Ahora cagramos el módulo en el kernel.

/sbin/modprobe ntfs

Con lo cual, tampoco nos debe mostrar ningún mensaje de error. Después checamos la versión del controlador:

dmesg | grep NTFS      NTFS driver v2.2.50 [Flags: R/O MODULE]

Con esto, podemos comprobar que el kernel realmente comprenda el NTFS (el desplegado puede variar, por lo que sólo checamos que diga la palabra ntfs):

cat /proc/filesystems      nodev   rootfsnodev   bdev

nodev   proc

nodev   sockfs

nodev   tmpfs

nodev   shm

nodev   pipefs

ext3

ext2

nodev   ramfs

nodev   devpts

ntfs

Montar la partición

Para esto utilizaremos los mismos comandos que se describen a continuación, con los cuales chequearemos nuestras particiones:

/sbin/fdisk -l Disk /dev/hda: 64 heads, 63 sectors, 4465 cylindersUnits = cylinders of 4032 * 512 bytes

Device Boot    Start       End    Blocks   Id  System

/dev/hda1             1      2125   4283968+  07  NTFS/HPFS

/dev/hda2          2126     19851  35735616   0f  Win95 Ext’d (LBA)

/dev/hda5   *      2126      4209   4201312+  83  Linux

/dev/hda6          4210      4465    516064+  82  Linux swap

creamos un directorio como punto de partición:

mkdir /mnt/windows

Le decimos al kernel que monte la partición en ese directorio:

mount /dev/hda1 /mnt/windows -t ntfs -r -o umask=0222

Y si todo salió bien, podemos acceder a la partición de Windows desde nuestro Red Hat.

ls -l /mnt/windows      …-r-xr–r– 1 root root  9719 Aug 24 1996 ansi.sys

-r-xr–r– 1 root root 15252 Aug 24 1996 attrib.exe

-r-xr–r– 1 root root 28096 Aug 24 1996 chkdsk.exe

-r-xr–r– 1 root root  5175 Aug 24 1996 choice.com

Montar la partición al arrancar el sistema

Para lograr esto, sólo agregaremos una línea al archivo “/etc/fstab” (tabla de sistemas de archivos).

La línea que ejecutamos para montar la partición:

mount /dev/hda1 /mnt/windows -t ntfs -r -o umask=0222

tiene como equivalente en el archivo /etc/fstab:

/dev/hda1 /mnt/windows ntfs ro,umask=0222                         0 0

que es la línea que debemos de agregarle al archivo.

Espero que este artículo les haya sido de mucha utilidad… ;)

Salu2,

Lester Espinosa Martínez

Problemas con YUM (Yellow dog Updater Modified)

Hola a todos…, aquí les traigo algo interesante que me sucedió. El caso es que tengo CentOS 4.0 instalado y mi conexión a INTERNET es mediante un proxy, entonces el comando yum necesario para descargar actualizaciones, instalaciones y/o dependencias no se me ejecuta correctamente, pues no sé en qué parte de la configuración debo especificarle el proxy de mi conexión. Les he traido una solución para si a algunos de ustedes les pasa lo mismo que a mi puedan solucionarla temporalmente.

Esto es lo que me pasaba antes de la solución:

[root]# yum install GFS
Setting up Install Process
Setting up repositories
Reading repository metadata in from local files
Parsing package install arguments
Resolving Dependencies
–> Populating transaction set with selected packages. Please wait.
—> Downloading header for GFS to pack into transaction set.
GFS-6.1.5-0.i386.rpm 100% |=========================| 138 kB 00:00
http://mirror.centos.org/centos/4/csgfs/i386/RPMS/GFS-6.1.5-0.i386.rpm: [Errno -1] Header is not complete.
Trying other mirror.
Error: failure: RPMS/GFS-6.1.5-0.i386.rpm from csgfs: [Errno 256] No more mirrors to try.

Tengo 2 soluciones:

1.- Crear 2 variables locales, las cuales responderán a las peticiones del proxy…
[root]# export http_proxy=http://IP_del_proxy:Puerto/
[root] # export ftp_proxy=http://IP_del_proxy:Puerto/

Probando el yum:

# yum install GFS
Setting up Install Process
Setting up repositories
Reading repository metadata in from local files
Parsing package install arguments
Resolving Dependencies
–> Populating transaction set with selected packages. Please wait.
—> Downloading header for GFS to pack into transaction set.
GFS-6.1.5-0.i386.rpm 100% |=========================| 4.6 kB 00:00
—> Package GFS.i386 0:6.1.5-0 set to be updated
–> Running transaction check

Dependencies Resolved

=============================================================================
Package Arch Version Repository Size
=============================================================================
Installing:
GFS i386 6.1.5-0 csgfs 138 k

Transaction Summary
=============================================================================
Install 1 Package(s)
Update 0 Package(s)
Remove 0 Package(s)
Total download size: 138 k
Is this ok [y/N]: y
Downloading Packages:
(1/1): GFS-6.1.5-0.i386.r 100% |=========================| 138 kB 00:00
Running Transaction Test
Finished Transaction Test
Transaction Test Succeeded
Running Transaction
Installing: GFS ######################### [1/1]

Installed: GFS.i386 0:6.1.5-0
Complete!
Y listo, ya pueden intentar nuevamente a utilizar el yum…

2.- Esta solución está basada principalmente en descargar el paquete e instalarlo utilizando un repositorio local. La dirección URL de dónde se encuentra el paquete que queremos instalar nos la dio en el primer mensaje de error…

Obviamente, un repositorio local no tendrá ningún tipo de problemas…

# cd /tmp

# wget ftp://192.168.1.203/pub/centos/4/csgfs/i386/RPMS/GFS-6.1.5-0.i386.rpm

# yum localinstall /tmp/GFS-6.1.5-0.i386.rpm
Setting up Local Package Process
Examining /tmp/GFS-6.1.5-0.i386.rpm: GFS - 6.1.5-0.i386
Marking /tmp/GFS-6.1.5-0.i386.rpm to be installed
Resolving Dependencies
–> Populating transaction set with selected packages. Please wait.
—> Package GFS.i386 0:6.1.5-0 set to be updated
–> Running transaction check

Dependencies Resolved

=============================================================================
Package Arch Version Repository Size
=============================================================================
Installing:
GFS i386 6.1.5-0 /tmp/GFS-6.1.5-0.i386.rpm 327 k

Transaction Summary
=============================================================================
Install 1 Package(s)
Update 0 Package(s)
Remove 0 Package(s)
Total download size: 327 k
Is this ok [y/N]: y
Downloading Packages:
Running Transaction Test
Finished Transaction Test
Transaction Test Succeeded
Running Transaction
Installing: GFS ######################### [1/1]

Installed: GFS.i386 0:6.1.5-0
Complete!

Y listo, tendremos nuestro paquete instalado!!! ;)

Espero que les sirva de algo…

Salu2,

Lester Espinosa Martínez