El problema del TS es que utiliza un sistema de sesiones que impide que haya más de 2 sesiones de administrador en el equipo. Si la gente no tiene costumbre de cerrar correctamente su sesión nos podemos encontrar con que no podemos conectar a pesar de que nadie esté trabajando con el servidor remotamente. Pues atención, niños y niñas, que nada es imposible en esta vida. A continuación se lista lo que hay que hacer para desbloquear esas sesiones colgadas (al menos para los que trabajéis con Windows):

1. Abrid un terminal de línea de comandos (Inicio -> ejecutar -> cmd)
2. Ejecutad la siguiente orden (cambiando los valores), pedirá la contraseña del usuario:

   > net use /user:[usuario] \\[ip servidor]\c$

   El 99% de los Windows con los que he trabajado tienen compartido de forma predeterminada todo el disco C a través de C$.

3. Después hay que ejecutar:

   > query session /server:[ip servidor]

   Nunca me ha funcionado así, sino poniendo la ruta completa, esto es, c:\Winnt\system32\dllcache\query ...

4. Mostrará un listado con las sesiones. Habrá que mirar que la que se quiere desconectar no esté activa (esté en Listen, o Disconnected o algo así). Una vez seleccionada la sesión, hay que ejecutar:

   > reset session [ID] /server:[ip servidor]

Voilá. Ya podemos ir a nuestro cliente de Terminal y conectarnos al servidor.

Traducido del original en How-To Geek, donde además os pone capturas de lo que veréis por pantalla, por si a alguno no le ha quedado clara mi espartana explicación.

• Añadir la macro _CRTDBG_MAP_ALLOC del preprocesador, ya sea definiéndola en algún archivo del proyecto o en las opciones de compilación del proyecto.
• Incluir en el siguiente orden stdlib.h y crtdbg.h en los archivos dónde se busquen las fugas de memoria. El archivo crtdgb.h sustituye las funciones malloc y free por unas propias que registran la memoria reservada y liberada.
• Añadir la función _CrtDumpMemoryLeaks () al final del programa en el que se buscan las fugas de memoria. Esta función muestra por la salida de depuración las fugas de memoria detectadas.

Todo esto sólo funcionará cuando el proyecto se compile con la macro _DEBUG definida, es decir, en lo que debería ser para todos la versión de depuración del programa.

La macro _CRTDBG_MAP_ALLOC sirve para que la función _CrtDumpMemoryLeaks () muestre información sobre el archivo y la línea en la que se produjo la fuga de memoria.

Un pequeño ejemplo de cómo quedaría todo:

#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>

int
main (int argc, char *argv[])
{
    /* Código del programa */

    _CrtDumpMemoryLeaks ();

    return 0;
}

Si este programa tuviera alguna fuga de memoria, al compilarlo en modo depuración y ejecutar el depurador de Visual Studio, se obtendría en la salida de éste un listado con las fugas de memoria del programa.

Para más información, leed el artículo Enabling Memory Leak Detection de la MSDN.

Pero si encima para rematar la faena te toca insertar un applet, quieres que cumpla con XHTML 1.1 y que se vea en IE, pues acojona un poco al ver que la etiqueta applet dejó de formar parte del estándar hace ya un tiempo.

Sin más dilación, os dejo aquí el código:

<!--[if !IE]>-->
<object id="applet" name="applet" classid="java:es.4bits.applet.Applet"
 type="application/x-java-applet"
 archive="applets/Applet.jar"></object>
<!--<![endif]-->

<!--[if IE]>
<object id="applet" name="applet" code="es.4bits.applet.Applet"
 archive="applets/Applet.jar"></object>
<![endif]-->

Al final, lo único necesario es utilizar los asquerosos hacks de IE, para que no cargue la versión que no entiende de la etiqueta object y cargue la que entiende.

Basado en XHTML Strict Applets.

Así que estuve buscando diferentes opciones, siendo importante que funcionase en Linux y en Windows (por si las moscas). Al final había dos opciones Truecrypt (el archiconocido) y dm-crypt (un gestor de dispositivos cifrados de Linux), me decanté por dm-crypt porque Truecrypt, curiosamente, no está en los repositorios de Debian y porque con dm-crypt no necesitaría de un programa a parte para utilizar mi dispositivo en Linux (aunque sí, en Windows).

Pasos a seguir

Directo al grano, estos son los pasos que realicé:

1. Paquetes necesarios:

   # apt-get install cryptsetup hashalot dmsetup

2. Rellenar la memoria con datos aleatorios (no es necesario, aunque sí recomendable):

   # dd if=/dev/urandom of=/dev/sdX

3. Cargar los siguientes módulos si no lo están ya:

   # modprobe aes
   # modprobe dm_crypt
   # modprobe dm_mod
   # modprobe sha256

4. Crear el contenedor cifrado (pedirá la contraseña para poder luego descifrarlo):

   # cryptsetup -v --key-size 256 luksFormat /dev/sdX NOMBRE-CONTENEDOR

5. Formatear el contenedor (yo utilicé FAT para que funcione en Windows) para ello primero hay que montar el contenedor utilizando cryptsetup:

   # cryptsetup -v luksOpen /dev/sdX NOMBRE-CONTENEDOR
   # mkfs.vfat /dev/mapper/NOMBRE-CONTENEDOR

6. Y ya está, ya se puede montar:

   # mount -t vfat /dev/mapper/NOMBRE-CONTENEDOR /mnt/usb_cifrado

Uso

Lo bueno de este método es que al enchufar la memoria en Linux, éste pedirá la contraseña y se montará automáticamente, aunque en la versión de GNOME que uso no lo monta. Así que, por si las moscas, siempre lo puedes montar ejecutando:

$ pmount-hal /dev/sdX

Y desmontar ejecutando:

$ pumount /dev/sdX

Para poder utilizar el dispositivo cifrado en Windows se necesita un programa llamado FreeOTFE que es compatible con este tipo de cifrado.

Basado en Manual de Cifrado de una particion concreta desde Linux Debian/Ubuntu.

He de decir que este libro no me ha sorprendido mucho, ya que en cuanto llevas algo de tiempo programando sobre Win32 y visitando la MSDN a menudo, te acabas conociendo las partes más utilizadas. Además, este libro es bastante antiguo (del 2004).

En general, no me convence la forma de explicar los temas por parte del autor, casi todos los capítulos se limita a copiar las diferentes funciones que se utilizan para hacer lo que sea, y a explicar cada uno de sus parámetros. Por lo que el libro se transforma en una especie de resumen de la MSDN.

De todo el contenido del libro me quedaría con los capítulos sobre los servicios de Windows y las estructuras de seguridad (SIDs, ACLs, ACEs) de Windows.

Aún así, puede servir como punto de partida para empezar a programar sobre Windows utilizando Win32, si no fuera por las pegas que he comentado.

Recomendación: Baja.
Nivel: Medio.
Idioma: Inglés.

Instrucciones

Voy a partir de qué tenemos la siguiente estructura de directorios que se quiere compartir:

drwxr-x--- user group dir01
drwxr-x--- user group dir02
drwxr-x--- user group dir03

Como se puede ver, a estos directorios sólo puede acceder el usuario user y los usuarios del grupo group, aunque estos últimos sólo con permisos de lectura sobre los directorios.

Lo primero que se debe hacer es añadir el usuario (o los usuarios) que podrán acceder a nuestros datos compartidos. Para ello se ejecuta:

# smbpasswd -a user

Nos pedirá una contraseña, ésta puede ser distinta a la que tenga el usuario para acceder a la máquina.

Una vez añadido el usuario (o los usuarios), se podrá configurar Samba para que comparta los directorios. Para ello se modifica el archivo /etc/samba/smb.conf y se añade un elemento del siguiente tipo por cada directorio a compartir:

[nombre_directorio_a_compartir]
  comment = Comentario del directorio compartido
  path = /ruta/al/directorio
  read only = yes # Indica si el acceso será sólo lectura
  write list = user # Usuarios/grupos que tendrán acceso de escritura
  create mask = 0640 # Máscara de los permisos al crear archivos
  directory mask = 0750 # Máscara de los permisos al crear directorios
  guest ok = no # Acceso sin autenticación

De este modo, para el ejemplo que he puesto se tendrían que añadir tres elementos de este tipo, quedando el archivo similar a este:

[global]
  display charset = UTF-8
  server string = NOMBRE-DE-LA-MAQUINA
  workgroup = GRUPO-DE-TRABAJO
  netbios name = NOMBRE-NETBIOS-MAQUINA
  invalid users = root # Para que no se pueda acceder como root

[dir01]
  comment = Directorio 01
  path = /home/user/dir01
  read only = yes
  write list = user
  create mask = 0640
  directory mask = 0750
  guest ok = no

[dir02]
  comment = Directorio 02
  path = /home/user/dir02
  read only = yes
  write list = user
  create mask = 0640
  directory mask = 0750
  guest ok = no

[dir03]
  comment = Directorio 03
  path = /home/user/dir03
  read only = yes
  write list = user
  create mask = 0640
  directory mask = 0750
  guest ok = no

Después de esto sólo hay que reiniciar Samba y listo, ya se podrá acceder a dichos directorios compartidos utilizando el usuario user.

# /etc/init.d/samba restart

Basado en Compartir directorios con Samba del blog de Iván López.

Hasta hace poco este servidor utilizaba Windows 2003, hasta que un día decidió morir en extrañas circunstancias, así que como los que nos encargamos de dicho servidor nos manejamos mejor en Linux decidimos instalar Debian Lenny y utilizar Samba para los directorios compartidos y la impresora compartida, ya que en nuestra red tenemos variedad de Windows y Linux.

Instrucciones

Hay que tener instalado CUPS. Una vez instalado, realizar los siguientes pasos para configurar CUPS:

1. Añadir la siguiente línea al archivo /etc/cups/cupsd.conf, suponiendo que nuestra red sea 192.168.0.0/255.255.255.0:

   Allow From 192.168.0.*

2. Descomentar la siguiente línea del archivo /etc/cups/mime.convs:

   application/octet-stream application/vnd.cups-raw  0 - 

De este modo, CUPS permitirá compartir remotamente la impresora. Ahora hay que configurar Samba para que las máquinas con Windows puedan usar la impresora, así que a seguir los siguientes pasos:

Editar el archivo /etc/samba/smb.conf de modo que quede similar a este que muestro:

[global]
  workgroup = GRUPO-DE-TRABAJO
  netbios name = NOMBRE-NETBIOS-MAQUINA

  #this section is only to share the printer
  printcap name = cups
  disable spoolss = yes
  show add printer wizard = no
  printing = cups

[printers]
  comment = Printer in Linux
  path = /var/spool/samba
  create mode = 0700
  guest ok = yes
  print ok = yes
  use client driver = yes
  browseable = yes
  public = yes

El directorio /var/spool/samba se debe crear si no existe y tener permisos 0777.

Con esta configuración se comparte la impresora sin necesidad de autenticarse, ya que el nivel de seguridad lo permite (security = share) y se permite autenticarse como invitado (guest ok = yes). El elemento printers permite que samba comparta automáticamente todas las impresoras conectadas con las propiedades que se le indiquen en dicho elemento.

Si se quisiera obligar a autenticarse para poder usar la impresora, habría que añadir un usuario a samba ejecutando:

# smbpasswd -a usuario

Además, habría que cambiar el nivel de seguridad (con quitar la propiedad security valdría) y no permitir la autenticación como invitado (guest ok = no).

Para finalizar, sólo habría que reiniciar CUPS y Samba:

# /etc/init.d/cups restart
# /etc/init.d/samba restart

Basado en Sharing a printer to XP clients with Samba and Cups de Debian Administration (en inglés).

Windows emite estas señales a las aplicaciones correspondientes para que puedan manejarlas y terminar de una forma adecuada, por ejemplo: realizando las operaciones necesarias para no dejar archivos en algún estado catastrófico perdiendo la información de estos.

Manejando las señales

Para manejar estas señales las aplicaciones disponen de una lista de manejadores, en la que en principio sólo hay una función que termina la ejecución del proceso. Para añadir/borrar un manejador a la lista se dispone de la función SetConsoleCtrlHandler:

BOOL WINAPI SetConsoleCtrlHandler (PHANDLER_ROUTINE HandlerRoutine, BOOL Add);

Donde los parámetros son:

• HandlerRoutine: Es un puntero a la función que manejará las señales recibidas. Tendrá la forma:

  BOOL WINAPI CtrlHandler (DWORD CtrlType)

• Add: Si su valor es TRUE indica que la función se añadirá a la lista de manejadores de las señales, en cambio si es FALSE indica que la función se borrará de la lista de manejadores.

La función del manejador

Como se ha mencionado antes, la función del manejador tiene la forma:

BOOL CtrlHandler (DWORD CtrlType);

La función del manejador deberá tratar las señales que crea conveniente, utilizando el parámetro CtrlType que recibirá uno de los siguientes valores:

• CTRL_C_EVENT: Señal de Ctrl+C.
• CTRL_BREAK_EVENT: Señal de Ctrl+Break.
• CTRL_CLOSE_EVENT: Señal del cierre de la ventana de la consola.
• CTRL_LOGOFF_EVENT: Señal del cierre de la sesión.
• CTRL_SHUTDOWN_EVENT: Señal del apagado del sistema

Este manejador devolverá TRUE cuando haya tratado la señal, y FALSE cuando no la haya tratado, de modo que pasará a ejecutar el siguiente manejador.

Ejemplo

Como todo se entiende mejor con un ejemplo, aquí os dejo el ejemplo de la MSDN sobre registrar un manejador de señales de control de la consola:

#include <windows.h>
#include <stdio.h>

BOOL WINAPI CtrlHandler (DWORD CtrlType) {

    switch (CtrlType) {

        // Handle the CTRL-C signal.
        case CTRL_C_EVENT:
            printf ("Ctrl-C event\n\n");
            Beep (750, 300);
            return TRUE;

        // CTRL-CLOSE: confirm that the user wants to exit.
        case CTRL_CLOSE_EVENT:
            printf ("Ctrl-Close event\n\n");
            Beep (600, 200);
            return TRUE;

        // Pass other signals to the next handler.
        case CTRL_BREAK_EVENT:
            printf ("Ctrl-Break event\n\n");
            Beep (900, 200);
            return FALSE;

        case CTRL_LOGOFF_EVENT:
            printf ("Ctrl-Logoff event\n\n");
            Beep (1000, 200);
            return FALSE;

        case CTRL_SHUTDOWN_EVENT:
            printf ("Ctrl-Shutdown event\n\n");
            Beep (750, 500);
            return FALSE;

        default:
            return FALSE;
    }
}

int main (int argc, char *argv[]) {

    BOOL added;

    added = SetConsoleCtrlHandler ((PHANDLER_ROUTINE) CtrlHandler,
                                   TRUE);
    if (added) {
        printf ("\nThe Control Handler is installed.\n");
        printf ("\n -- Now try pressing Ctrl+C or Ctrl+Break, or");
        printf ("\n    try logging off or closing the console...\n");
        printf ("\n(...waiting in a loop for events...)\n\n");

        while (1) {
            Sleep (500);
        }

    } else
        printf ("\nERROR: Could not set control handler");

    return 0;
}

Gracias a las tuberías podemos redirigir la entrada estándar, la salida estándar y/o la salida de error de un programa que ejecutemos dentro de nuestro programa, de modo que podamos obtener dicha salida para posteriormente procesarla como queramos.

A continuación, os muestro cómo se redirige la salida estándar y la salida de error, en Windows, de un proceso que ejecutemos dentro de nuestro programa.

#include <windows.h>
#include <stdio.h>

#define BUFSIZE 4096 

HANDLE hChildStdoutRd, hChildStdoutWr, hStdout;

BOOL CreateChildProcess (char *cmdline) {

	PROCESS_INFORMATION piProcInfo;
	STARTUPINFO siStartInfo;
	BOOL bFuncRetn = FALSE;

	// Set up members of the PROCESS_INFORMATION structure.
	ZeroMemory (&piProcInfo, sizeof (PROCESS_INFORMATION));

	// Set up members of the STARTUPINFO structure.
	ZeroMemory (&siStartInfo, sizeof (STARTUPINFO));
	siStartInfo.cb = sizeof (STARTUPINFO);
	siStartInfo.hStdError = hChildStdoutWr;
	siStartInfo.hStdOutput = hChildStdoutWr;
	siStartInfo.dwFlags |= STARTF_USESTDHANDLES;

	// Create the child process.
	bFuncRetn = CreateProcess (NULL, cmdline, NULL, NULL, TRUE, 0, NULL,
							NULL, &siStartInfo, &piProcInfo);

	if (bFuncRetn == 0) {
		printf ("CreateProcess failed\n");
		return FALSE;
	} else {
		CloseHandle (piProcInfo.hProcess);
		CloseHandle (piProcInfo.hThread);
		return bFuncRetn;
	}
}

int ReadFromPipe () {

	DWORD dwRead, dwWritten;
	char chBuf[BUFSIZE];

	// Close the write end of the pipe before reading from the
	// read end of the pipe.
	if (!CloseHandle (hChildStdoutWr)) {
		printf ("Closing handle failed");
		return -1;
	}

	// Read output from the child process, and write to parent's STDOUT.
	for (;;) {

		if (! ReadFile (hChildStdoutRd, chBuf, BUFSIZE, &dwRead, NULL)
			|| dwRead == 0)
		{
			break;
		}

		if (! WriteFile (hStdout, chBuf, dwRead, &dwWritten, NULL))
			break;
	}

	return 0;
}

int main (int argc, char *argv[]) {

	SECURITY_ATTRIBUTES saAttr;
	BOOL fSuccess;

	// Get a handle to the parent's input file.
	if (argc == 1) {
		printf ("Must be a parameter.\n");
		return -1;
	}

	// Set the bInheritHandle flag so pipe handles are inherited.
	saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
	saAttr.bInheritHandle = TRUE;
	saAttr.lpSecurityDescriptor = NULL;

	// Get the handle to the current STDOUT.
	hStdout = GetStdHandle (STD_OUTPUT_HANDLE);

	// Create a pipe for the child process's STDOUT.
 	if (! CreatePipe (&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0))
		return -2;

	// Ensure that the read handle to the child process's pipe for
	// STDOUT is not inherited.
	SetHandleInformation (hChildStdoutRd, HANDLE_FLAG_INHERIT, 0);

	// Now create the child process.
	fSuccess = CreateChildProcess (argv[1]);
	if (! fSuccess)
		return -3;

	printf ("\nContents of %s:\n\n", argv[1]);

	// Read from pipe that is the standard output for child process.
 	ReadFromPipe ();

	return 0;
}

Código basado en el ejemplo de la MSDN sobre la creación de tuberías.

Pero por razones sobrenaturales (trabajo), he tenido que programar en C sobre Windows. Al principio me dieron el Visual Studio 2005 (o algo así), y nada más ver que era bastante lioso para lo que quería hacer, me decidí a usar DevCpp que es libre, usa MinGW y puedo programar para Windows usando la API Win32.

Después de este rollo que os he soltado, viene lo que pretendía contaros, y es cómo acceder al registro de Windows usando el lenguaje C. Puede parecer difícil, pero la verdad es que los señores de Microsoft tienen una buena cosa llamada msdn, en la que encuentras cualquier cosa siempre que sepas más o menos donde buscar. Para este caso podemos encontrar toda la información relacionada con el registro aquí.

Pero no os voy a dejar a la buena de dios, así que os voy a poner un pequeño ejemplo de cómo acceder a una clave del registro, para que podáis saber más o menos cómo funciona.

#include <windows.h>

const char *ruta_reg = "Ruta\\del\\registro";

char *get_clave (char *clave) {

    DWORD BufferSize = 2048;
    DWORD cbData;
    DWORD dwRet;
    DWORD regType;
    HKEY hkey;

    if (RegOpenKeyEx (HKEY_CURRENT_USER, TEXT (ruta_reg), 0,
                      KEY_READ, &hkey) == ERROR_SUCCESS)
    {

        PPERF_DATA_BLOCK PerfData = (PPERF_DATA_BLOCK) malloc (BufferSize);
        if (PerfData == NULL) {
            printf ("Error\n");
            return NULL;
        }

        cbData = BufferSize;
        dwRet = RegQueryValueEx (hkey, TEXT (type), NULL, &regType,
                                 (LPBYTE) PerfData, &cbData);

        /* Get a buffer that is big enough. */
        while (dwRet == ERROR_MORE_DATA) {
            BufferSize *= 2;
            PerfData = (PPERF_DATA_BLOCK) realloc (PerfData, BufferSize);
            if (PerfData == NULL) {
                printf ("Error\n");
                return NULL;
            }

            cbData = BufferSize;

            /* Conseguimos el valor de la clave */
            dwRet = RegQueryValueEx (hkey, TEXT (clave), NULL, &regType,
                                     (LPBYTE) PerfData, &cbData);
        }

        /* Error */
        if (dwRet != ERROR_SUCCESS) {
            printf ("Error\n");
            return NULL;
        }

        printf ("%s\n", (char *) PerfData);

        return (char *) PerfData;
    }

    return NULL;
}

Sólo tenéis que cambiar la constante ruta_reg por una válida (que esté en HKEY_CURRENT_USER, ya que creo que si no eres administrador no puedes acceder a otra) y pasar como parámetro clave el nombre de la clave de la que queremos conocer su valor.