"Después del juego es antes del juego"
Sepp Herberger

domingo, 27 de julio de 2014

Configuracion NAT-DHCP para aulas mixtas de Linux-Windows

Un escenario con el que me encuentro frecuentemente es un aula en el que el ordenador del profesor tiene dos tarjetas de red. Con una de ellas tiene conexión con la red general y con la otra da conexión a una red privada con los ordenadores de los alumnos.

Para que esto funcione, el ordenador del profesor tiene que tener configurado el NAT y un servicio DHCP para ofrecer IP y conectividad a los ordenadores de los alumnos. La cosa se complica cuando tanto el ordenador de profesor como el de alumnos tienen arranque dual y queremos que todo funcione indistintamente tanto Windows como en Linux, independientemente de lo que tenga arrancado cada ordenador de la estancia.

El esquema que he usado es el siguiente:

  • En el profesor, el interfaz que conecta con la red del centro tiene configuración de red dinámica, recibe todo por DHCP, tanto en windows como en Linux.
  • En el profesor, el interfaz que conecta con la red privada del aula tiene configuracion IP fija, con IP 192.168.0.254, máscara 255.255.255.0 y el resto de parámetros sin definir.
  • Los ordenadores de los alumnos son fáciles de configurar: simplemente los dejamos que cojan la configuración de red por DHCP, tanto en Windows como en Linux y ya es suficiente. Recibirán direcciones fijas en función de su MAC en el rango 192.168.0.201-225 (son 25 pc). Debemos recopilar sus MACs en una lista antes de empezar la configuración.

viernes, 25 de julio de 2014

Bono social de Iberdrola para familias numerosas

Este post no va de Linux (ni de Windows :-), pero como me ha costado tanto que Iberdrola me mande los impresos para solicitar el bono social para familias numerosas y no tengo otro blog, pues lo pongo aquí y santas pascuas. Ni el correo bonosocial@iberdrola.es, ni el teléfono han funcionando, al final tuve que hacerlo por twitter y eso es una ofensa para un anti-redes sociales como yo.
 
El documento pinta tal que así:

Descárgalo aquí.

miércoles, 23 de julio de 2014

Actualizo Windows XP a SP3 y me dejan de funcionar las impresoras compartidas desde CUPS: me dicen que están desconectadas.

Tengo varias impresoras compartidas con CUPS desde mis Linux y configuradas en diversos Windows XP como impresoras de red con rutas del estilo:

http://spro-o04:631/printers/COLOR_SALAPROFESORES

Pues no que voy y actualizo el Windows XP de SP2 a SP3 y me dejan de funcionar las impresoras: aparecen como desconectadas. Mando trabajos y se quedan encolados en el Windows sin que éste llegue a conectar con el servidor CUPS del Linux. Lo primero que hago es borrar la impresora y volver a crearla. Bien, funciona. No, cuando reinicio deja de funcionar otra vez.

¿Qué está pasando?. No lo sé, pero aquí encuentro la solución. Los pasos son:

  • Entrar en regedit.
  • Ir a la clave de registro:

HKLM\System\CurrentControlSet\Control\Print\Printers\<nombre de impresora>

  • Allí, cambiar el valor de Attributes a 0X00000A50 hex o 2640 decimal.
  • Reiniciar el servicio de impresión (net stop spooler y net start spooler) o el PC.

Y ya no se vuelven a poner offline de motu propio. Aquí se explican el valor de los atributos activados con este truquito: Network, Local, DoCompleteFirst y EnableBIDI. Estos parámetros no se pueden configurar con el entorno gráfico, deben configurarse desde regedit.

Cuando esto pasa en Linux es imperdonable. Si pasa en Windows es "no sós vos, soy yo".

martes, 22 de julio de 2014

Configurar una impresora Olivetti P200 en Linux

Hace tiempo me encasquetaron la tarea de hacer funcionar una impresora USB Olivetti JobJet P200 en Linux. Ni que decir tiene que funcionaba perfectamente en Windows. El CUPS seleccionaba en la autodetección unos drivers que no funcionaban y en OpenPrinting ni siquiera aparecía. En estos días tengo que actualizar el PC donde está y he recordado como lo hice.

Tras varias pruebas fallidas con los escasos drivers para Olivetti que tiene CUPS, recordé haber leído que muchas impresoras de inyección de marcas diversas son en realidad impresoras HP 500 con la piel cambiada. Entonces me puse a probar drivers de HP Deskjet 500 hasta que di con el adecuado, que imprimía correctamente en blanco y negro y a color.

En concreto el driver es el cdj500 del modelo HP-DeskJet_500C, dentro de la colección de drivers de foomatic. Tan sólo tendríamos que buscar y seleccionar dicho driver en CUPS dentro de la lista de drivers de HP.

Si queremos dar de alta la impresora desde linea de comandos sería (la URI incluye el número de serie, habría que encontrar la URI adecuada para nuestra impresora mirando como la autodetecta CUPS):

 foomatic-configure -s cups -p "HP-DeskJet_500C" -n "OLIVETTI_P200" -N "Impresora color" -c "usb://Olivetti/Job_Jet%20P200?serial=MY31R1C1BV81" -d "cdj500"
 lpadmin -p "OLIVETTI_P200" -o PageSize=A4
 /etc/init.d/cups restart

Y ya la tenemos funcionando.

jueves, 17 de julio de 2014

No dejes para mañana lo que puedas ejecutar hoy....

El otro día tenía  que lanzar un proceso muy largo en un PC (en concreto, buscar los ficheros de mas de 100MB en una máquina concreta) y quedaba poco rato para irme a casa. Tenía varias opciones:

  1. Ejecutarlo por ssh en mi PC y dejarlo encendido hasta el día siguiente. Un poco exagerado dejar mi PC encendido sólo para eso, ¿no?.
  2. Ejecutarlo en la consola física del PC destino y dejarla abierta con la sesión del usuario root. No es una buena práctica eso de dejar sesiones de root abiertas en un PC cualquiera.
  3. Meterlo en un script y lanzarlo con el comando nohup, que permite lanzar un programa que se ejecutará aun cuando cortemos la conexión ssh. El problema su salida a pantalla se pierde en el limbo y habría que usar un fichero donde volcar la salida para ver el resultado mas tarde.
  4. Usar la utilidad screen, que me descubrió mi compañero Carlos Martín y que fué por la que me decanté y que voy a contar ahora.

domingo, 13 de julio de 2014

Cazando al servidor DHCP intruso

De repente a veces nos encontramos con que los equipos de nuestra red empiezan a recibir direcciones IP que no son de nuestro rango. La causa es que tenemos algún dispositivo en la red que está sirviendo IPs en concurrencia con nuestro servicio DHCP "oficial". Los rangos típicos son 192.168.X.X o 10.0.X.X. Vamos a ver como localizarlo y neutralizarlo.

viernes, 11 de julio de 2014

Monitorizar una impresora de red con snmpwalk

En todos los sitios donde he trabajado había una o varias "impresoras críticas", esto es, una impresora comunitaria usada por todo tipo de usuarios y que era sistemáticamente maltratada, sobreexplotada y humillada. Muchas veces esa impresora presenta un problema y nadie se ocupa de resolverlo o avisar de él, con lo cual la cosa suele pasar a mayores y el culpable es el informático, claro está.
 
Si es una impresora de red y tiene opción para activar el SNMP (esto se hace entrando en la página web de configuración de la impresora  o bien con el menú del panel de estado) , podremos acceder a su árbol MIB y obtener información sobre su estado desde un programa externo. Es el método usado por suites como Nagios, que es demasiado compleja para lo que queremos hacer nosotros.
 

miércoles, 9 de julio de 2014

Mover perfiles de usuarios Windows a otra unidad de disco

Esta va de Windows: en Linux es muy fácil cambiar de sitio un perfil de usuario cuando el disco o partición donde está ya no da más de sí. Simplemente tenemos que cambiar la ruta de su home en el fichero /etc/passwd y mover el home preservando los permisos y propietarios de los archivos a la nueva ubicación y ya está. En Windows XP es un pelín mas complicado, pero como veremos también se puede hacer.

Para ello uso un script hecho con la potente herramienta de scripting kix32 y la excelente utilidad de copiado Robocopy. Debemos descargar ambos programas y ponerlos en algun directorio del path de nuestro sistema, por ejemplo en c:\windows\system32.

martes, 8 de julio de 2014

Impresoras duplicadas en CUPS

Un problema bastante desconcertante que me ocurría a veces es que las impresoras conectadas por USB me aparecían dos veces en la lista de impresoras y en /etc/cups/printers.conf, como si CUPS  pensase que eran impresoras distintas, aun cuando su DeviceURI era igual. Este problema se hacía mas frecuente cuando cambiaba el nombre de la impresora y ponía uno a mi gusto, en lugar de el que le había dado CUPS en la autodetección, o cuando usaba el filtro tea4cups para controlar los trabajos enviados a las cola de impresión. 

Como utilizo tea4cups para llevar una contabilidad de las páginas impresas, el que las impresoras apareciesen duplicadas me originaba un problema a la hora de recopilar los datos, además de desconcertar al usuario a la hora de imprimir.

Mi compañero Ubaldo me puso en la pista de como resolver el problema. En el paquete system-config-printer-udev están los scripts encargados de manejar las impresoras USB detectadas por udev. En concreto el script /lib/udev/udev-add-printer es el que se encarga de añadir a CUPS una nueva impresora cuando es detectada por primera vez. Estaba claro que algo fallaba ahí y que había que retocar el código del script para evitar que se duplicase. Afortunadamente el script estaba en python.

El script retocado queda así (pongo en rojo las líneas añadidas por mí):

 #!/usr/bin/python  
 ## udev-add-printer  
 ## Copyright (C) 2009, 2010 Red Hat, Inc.  
 ## Author: Tim Waugh <twaugh@redhat.com>  
 ## This program is free software; you can redistribute it and/or modify  
 ## it under the terms of the GNU General Public License as published by  
 ## the Free Software Foundation; either version 2 of the License, or  
 ## (at your option) any later version.  
 ## This program is distributed in the hope that it will be useful,  
 ## but WITHOUT ANY WARRANTY; without even the implied warranty of  
 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  
 ## GNU General Public License for more details.  
 ## You should have received a copy of the GNU General Public License  
 ## along with this program; if not, write to the Free Software  
 ## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
 import cups  
 import cupshelpers  
 import dbus  
 import os  
 import sys  
 import traceback  
 from syslog import *  
 MFG_BLACKLIST=[  
   "graphtec",  
   ]  
 def create_queue (c, printers, name, device_uri, ppdname, info, installer):  
   # Make sure the name is unique.  
   namel = unicode (name.lower ())  
   unique = False  
   suffix = 1  
   while not unique:  
     unique = True  
     for printer in printers.values ():  
       if (not printer.discovered and  
         ((suffix == 1 and printer.name.lower () == namel) or  
          (suffix > 1 and  
          printer.name.lower () == namel + "-" + str (suffix)))):  
         unique = False  
         break  
     if not unique:  
       suffix += 1  
       if suffix == 100:  
         break  
   if suffix > 1:  
     name += "-" + str (suffix)  
   c.addPrinter (name,  
          device=device_uri,  
          ppdname=ppdname,  
          info=info,  
          location=os.uname ()[1])  
   if not installer:  
     # There is no session applet running to deal with installing  
     # drivers so there is a good chance that this queue won't work  
     # right now. If that's the case, delete it. The user can  
     # reconnect the printer when they log in, and everything will  
     # be set up correctly for them at that point.  
     try:  
       ppdfile = c.getPPD (name)  
       ppd = cups.PPD (ppdfile)  
       os.unlink (ppdfile)  
       (pkgs, exes) = cupshelpers.missingPackagesAndExecutables (ppd)  
       if pkgs or exes:  
         # There are filters missing. Delete the queue.  
         syslog (LOG_ERROR, "PPD %s requires %s" % (ppdname,  
                               repr ((pkgs, exes))))  
         syslog (LOG_ERROR, "Deleting non-functional queue")  
         c.deletePrinter (name)  
         name = None  
     except cups.IPPError, (e, m):  
       pass  
     except RuntimeError:  
       pass  
   if name:  
     cupshelpers.activateNewPrinter (c, name)  
   return name  
 def add_queue (device_id, device_uris, fax_basename=False):  
   """  
   Create a CUPS queue.  
   device_id: the IEEE 1284 Device ID of the device to add a queue for.  
   device_uris: device URIs, best first, for this device  
   fax_basename: False if this is not a fax queue, else name prefix  
   """  
   id_dict = cupshelpers.parseDeviceID (device_id)  
   if id_dict["MFG"].lower () in MFG_BLACKLIST:  
     syslog (LOG_DEBUG, "Ignoring blacklisted manufacturer %s", id_dict["MFG"])  
     return  
   syslog (LOG_DEBUG, "add_queue: URIs=%s" % device_uris)  
   installer = None  
   if fax_basename != False:  
     notification = None  
   else:  
     try:  
       bus = dbus.SystemBus ()  
       obj = bus.get_object ("com.redhat.NewPrinterNotification",  
                  "/com/redhat/NewPrinterNotification")  
       notification = dbus.Interface (obj,  
                       "com.redhat.NewPrinterNotification")  
       notification.GetReady ()  
     except dbus.DBusException, e:  
       syslog (LOG_DEBUG, "D-Bus method call failed: %s" % e)  
       notification = None  
     try:  
       obj = bus.get_object ("com.redhat.PrinterDriversInstaller",  
                  "/com/redhat/PrinterDriversInstaller")  
       installer = dbus.Interface (obj,  
                     "com.redhat.PrinterDriversInstaller")  
     except dbus.DBusException, e:  
       syslog (LOG_DEBUG, "Failed to get D-Bus object for "  
           "PrinterDriversInstaller: %s" % e)  
   id_dict = cupshelpers.parseDeviceID (device_id)  
   if installer:  
     cmd = id_dict["CMD"]  
     if cmd:  
       cmd = reduce (lambda x, y: x + ',' + y, cmd)  
     else:  
       cmd = ""  
     try:  
       installer.InstallDrivers (id_dict["MFG"], id_dict["MDL"], cmd,  
                    timeout=3600)  
     except dbus.DBusException, e:  
       syslog (LOG_DEBUG, "Failed to install drivers: %s" % repr (e))  
   c = cups.Connection ()  
   ppds = cupshelpers.ppds.PPDs (c.getPPDs ())  
   (status, ppdname) = ppds.getPPDNameFromDeviceID (id_dict["MFG"],  
                            id_dict["MDL"],  
                            id_dict["DES"],  
                            id_dict["CMD"],  
                            device_uris[0])  
   syslog (LOG_DEBUG, "PPD: %s; Status: %d" % (ppdname, status))  
   if status == 0:  
     # Think of a name for it.  
     name = id_dict["MDL"]  
     name = name.replace (" ", "-")  
     name = name.replace ("/", "-")  
     name = name.replace ("#", "-")  
     if fax_basename != False:  
       name = fax_basename + "-" + name  
     printers = cupshelpers.getPrinters (c)  
     #Comprobamos si ya existe un dispositivo con esa URI igual  
     #o precedida por tea4cups  
     uri=device_uris[0].lower()  
     ya_existe=False  
     for printer in printers.values ():  
       device_uri=printer.device_uri.lower()  
       if device_uri == "tea4cups://" + uri or device_uri == uri :   
         ya_existe=True  
         break  
     if ya_existe:   
       syslog (LOG_DEBUG, "Alta abortada, URI Repetido: %s" % device_uri)   
       return  
     #Fin de la comprobacion      
     uniquename = create_queue (c, printers, name, device_uris[0], ppdname,  
                   "%s %s" % (id_dict["MFG"], id_dict["MDL"]),  
                   installer)  
     if uniquename != None and fax_basename == False:  
       # Look for a corresponding fax queue. We can only  
       # identify these by looking for device URIs that are the  
       # same as this one but with a different scheme. If we  
       # find one whose scheme ends in "fax", use that as a fax  
       # queue. Note that the HPLIP backends do follow this  
       # pattern (hp and hpfax).  
       used_uris = map (lambda x: x.device_uri, printers.values ())  
       for uri in device_uris[1:]:  
         if uri.find (":") == -1:  
           continue  
         (scheme, rest) = uri.split (":", 1)  
         if scheme.endswith ("fax"):  
           # Now see if the non-scheme parts of the URI match  
           # any of the URIs we were given.  
           for each_uri in device_uris:  
             if each_uri == uri:  
               continue  
             (s, device_uri_rest) = each_uri.split (":", 1)  
             if rest == device_uri_rest:  
               # This one matches. Check there is not  
               # already a queue using this URI.  
               if uri in used_uris:  
                 break  
               try:  
                 devices = c.getDevices(include_schemes=[scheme])  
               except TypeError:  
                 # include_schemes requires pycups 1.9.46  
                 devices = c.getDevices ()  
               device_dict = devices.get (uri)  
               if device_dict == None:  
                 break  
               add_queue (device_dict.get ("device-id", ""),  
                     [uri], fax_basename=uniquename)  
   else:  
     # Not an exact match.  
     uniquename = device_uris[0]  
   if uniquename != None and notification:  
     try:  
       cmd = id_dict["CMD"]  
       if cmd:  
         cmd = reduce (lambda x, y: x + ',' + y, cmd)  
       else:  
         cmd = ""  
       notification.NewPrinter (status, uniquename, id_dict["MFG"],  
                    id_dict["MDL"], id_dict["DES"], cmd)  
     except dbus.DBusException, e:  
       syslog (LOG_DEBUG, "D-Bus method call failed: %s" % e)  
 if len (sys.argv) < 3:  
   print "Syntax: %s {Device ID} {Device URI} [other device URIs...]"  
   sys.exit (1)  
 openlog ("udev-add-printer", 0, LOG_LPR)  
 try:  
   add_queue (sys.argv[1], sys.argv[2:])  
 except SystemExit, e:  
   sys.exit (e)  
 except:  
   (type, value, tb) = sys.exc_info ()  
   tblast = traceback.extract_tb (tb, limit=None)  
   if len (tblast):  
     tblast = tblast[:len (tblast) - 1]  
   for line in traceback.format_tb (tb):  
     syslog (LOG_ERR, line.strip ())  
   extxt = traceback.format_exception_only (type, value)  
   syslog (LOG_ERR, extxt[0].strip ())  

Básicamente lo que hago es comprobar que el DeviceURI de la impresora no existe ya en la lista de impresoras previas, teniendo en cuenta que puede o no tener el prefijo del filtro "tea4cups://". Con esto estaremos a salvo de esas colas de impresión fantasma y tendremos la cola de impresión ajustada a la realidad.

A otra cosa, mariposa....


miércoles, 2 de julio de 2014

Monitorizar la conexión de teclados y ratones.

En un entorno con cientos de maquinas Linux y con usuarios que cambian constantemente es útil tener controlado algo tan trivial como la conexión de teclados y ratones para adelantarnos a las probables incidencias y localizar a los usuarios "graciosetes". Con este script consigo tenerlos controlados y programar un aviso ante cualquier evento de desconexión que acontezca.

El truco está en husmear en /proc/bus/input/devices y buscar allí la presencia del ratón y el teclado. Como la casuística de dispositivos de entrada y la manera en que se identifican es enorme, puede que nos encontremos con excepciones a aplicar, tal como se puede ver en el código del script en el caso de teclados de marcas Sweex y RML, que son los rara avis que yo me he encontrado. En ese caso bastará con adaptar el grep de búsqueda a las circunstancias particulares de cada caso.

El script en cuestión es:

 #!/bin/bash
 #Script: seguimiento_km
 maquina=$(hostname -s)
#Detección raton #En teclados Sweex USB, aparece mouse en devices, aun cuando no haya ratón #conectado. Con el filtro grep -v kbd eliminamos esas lineas, para que solo #coja las corresponden a un ratón real. raton=$(cat /proc/bus/input/devices | grep -i mouse | grep -v kbd | wc -l)
#Detección teclado #En teclados RML, la cadena es "keykoard" en lugar de "keyboard" teclado=$(cat /proc/bus/input/devices | grep -i key[bk]oard | wc -l)
if [ $raton -ne 0 ] then raton="SI" else raton="NO" fi if [ $teclado -ne 0 ] then teclado="SI" else teclado="NO" fi echo "Maquina $maquina. Teclado: $teclado. Ratón: $raton."

Tal como está el script tan solo muestra en pantalla el resultado. Lo ideal sería un aviso por otro medio mas cómodo, pero eso ya depende de la infraestructura de avisos que quiera montar cada cual. En mi caso hago una llamada a una aplicación web mediante wget:

 peticion="http://url/aplicacion/web?maquina=$maquina&raton=$raton&teclado=$teclado"
 actualiza=$(wget -q -O - $peticion 2>/dev/null)

Y mi aplicación web se encarga de procesar los datos (en mi caso guardar un log de los diversos chequeos) y avisarme si es necesario. Este es el método usado en la aplicación controlies, con la cual tengo el honor de colaborar.

Otra opción podría ser enviar un mensaje de correo si cualquiera de los dos periféricos no es detectado. Una forma sencilla de hacerlo es con mailsend, que nos permite mandar correos a través de la cuenta de gmail (o cualquier otra cuenta que soporte smtp) sin tener que configurar nada especial en nuestra máquina:

 mailsend -to destinatario@gmail.com
      -from micorreo@gmail.com
      -ssl -smtp smtp.gmail.com -port 465
      -sub "Aviso de teclado/ratón"
      -M "Maquina $maquina. Teclado: $teclado. Ratón: $raton."
      +cc +bc -q -auth -user "micuenta" -pass "password"

Por último, debemos decidir cuando ejecutar el script de chequeo:

  • Podemos hacerlo en el arranque del sistema, llamando al script en /etc/init.d como un servicio a arrancar en el nivel 2
 cp /path/to/seguimiento_km /etc/init.d/seguimiento_km
 /usr/sbin/update-rc.d seguimiento_km start 05 2 .
  • O desde una línea que comienze con @reboot en el crontab.
 echo "@reboot root /path/to/seguimiento_km" >> /etc/crontab
  • Y otra opción es monitorizarlo cada cierto tiempo mediante una línea en el crontab con los minutos de intervalo (en el ejemplo, 10):
 echo "*/10 * * * * root /path/to/seguimiento_km" >> /etc/crontab

Y ya está. Hasta la próxima...

martes, 1 de julio de 2014

Acceso concurrente de usuarios en Windows

Aunque con los Linux tenemos más que suficiente, siempre es posible que tengamos varios (o muchos) Windows que administrar en nuestra red. Una de las cosas que primero eché de menos es la facilidad que tengo en Linux de conectarme a un puesto que está siendo usado con ssh -X y configurarlo sin moverme de mi sitio. ¿Existe esa posibilidad para Windows?. Pues si.

Linux tiene el programa cliente rdesktop, que permite conectarte a un Windows, que tenga previamente habilitado el acceso a escritorio remoto y configurados los permisos correctos, e iniciar sesión en él remotamente, realizándose la comunicación con el protocolo RDP (que es un protocolo muyyy eficiente, chapeau por Microsoft).

El problema es que Windows aparentemente no es multiusario: no se permite que haya dos usuarios trabajando la vez sobre él. Cuando iniciamos sesión con:

 rdesktop <ip>  

el usuario que está en ese momento trabajando físicamente en él es expulsado, con lo cual no tenemos lo que queremos.

O si: resulta que Microsoft en las versiones beta del SP1 de Windows XP posibilitó el acceso concurrente y luego lo quitó (aunque se mantiente activa la posiblidad en Windows Server). Pero una legión de hackers tomó nota e investigó como activarlo de nuevo. Lo único que hay que hacer es meter ciertas DLL parcheadas en los equipos y ya queda de nuevo habilitado. No os puedo decir si esto es legal, ilegal o todo lo contrario. Lo que si puedo decir es que funciona perfectamente.

Lo primero que debemos hacer es descargar los parches. Los hay para Windows XP con cualquier SP, Vista, Windows 7 y seguramente también los habrá para Windows 8. Enlaces para la descarga:


Se descargan los parches para nuestro sistema y se ejecutan siguiendo las instrucciones que van apareciendo en pantalla, en especial la de reiniciar justo después de aplicarlos para que Windows no intente deshacer los cambios. Otros requisitos son:

  • Tener desactivado el cambio rápido de usuario en Windows (http://www.microsoft.com/spain/accesibilidad/training/windowsxp/fastuserswitching.aspx)
  • El equipo no puede formar parte de un dominio Windows.
  • Tener activado el acceso a escritorio remoto en Mi PC->Botón derecho del ratón->Propiedades->Pestaña "Remoto"->Escritorio Remoto. El usuario con el que haremos el acceso remoto será "Administrador", pero podemos incluir otros usuarios o grupos en la lista.

La única limitación será que no podemos entrar con un usuario que ya ha iniciado sesión, es decir: no podemos iniciar sesión dos veces con el mismo usuario a la vez. En mi caso tengo reservado un usuario administrador en todos los Windows solo para mi con una contraseña que solo yo conozco y no tengo por tanto problemas de concurrencia del mismo usuaario.

Si esto lo hacemos a todas horas, como es mi caso, lo mejor es tener un script que lo automatice para que ni siquiera pida usuario y contraseña:

 #!/bin/bash  
 if [ "$1" == "" ]  
 then  
   echo "Uso: $0 <equipo>"  
   exit 1  
 fi  
 rdesktop -u administrador -p password -N -z -P -g 1024x680+0+0 $1  

Llamo al script con la IP o nombre del equipo Windows como parámetro y ¡voilá! ya estoy dentro para enredar. Con el administrador de tareas (ctrl-alt-supr) puedo ver si otro usuario ha iniciado sesión e incluso mandarle mensajes para su sorpresa.

Además, explorando los parámetros de rdesktop veremos que tenemos multitud de opciones que nos pueden servir en determinados casos: redirigir el sonido hacia nuestros altavoces, las impresoras, acceso a carpetas montadas en nuestro Linux de forma local desde el Windows remoto,.... un sinfín de posibilidades.

Hasta la próxima.....