Lluís Franco on Geeks.ms : Explorer, Utilidad

Acceder a la caché de Internet Explorer (V y final)

Lluis Franco — Tue, 10 Jun 2008 13:12:31 GMT

Éste es el último post de esta serie, en la cual se ha desarrollado un proyecto de ejemplo de cómo acceder a la caché de archivos temporales de Internet Explorer. De hecho, he aprovechado la excusa para montar un pequeño proyecto de ejemplo en el que poder enseñar varias cosas que tenía en mente y por falta de tiempo no podía postear.

ASí pues en éste ejercicio hemos mostrado entre otras cosas cómo:

Utilizar el API para acceder a los archivos temporales de Internet (post 1)
Persistir objetos .NET en ficheros XML mediante serialización (post 2)
Impersonar, para ejecutar temporalmente muestra aplicación con las credenciales de otro usuario (post 3)
Crear y distribuir nuestra aplicación como un servicio de Windows (post 4)

Y aquí os dejo el código completo del ejemplo:

Espero que os guste,

Acceder a la caché de Internet Explorer (IV)

Lluis Franco — Fri, 30 May 2008 15:22:53 GMT

En los dos primeros artículos pudimos ver los objetos del API de Windows que íbamos a usar para poder acceder a la caché de los archivos temporales de Internet, cómo persistir estos datos en formato XML, y finalmente cómo permitir que temporalmente nuestra aplicacación se ejecute con las credenciales de otro usuario, para poder realizar una serie de acciones que de otro modo no podría efectuar por falta de privilegios.

Siguiendo con el objetivo de este ejercicio hoy vamos a encapsular la lógica de negocio de nuestra aplicación en forma de servicio de Windows, y éste va a encargarse de realizar una consulta a la caché de Internet de nuestro ordenador cada X tiempo (configurable mediante un fichero XML).

Lo primero de todo va a ser construir la base de nuestro servicio mediante un proyecto de tipo Windows Service. Esta plantilla nos genera un proyecto con un componente de tipo ServiceBase, que servirá para ir construyendo nuestro pequeño juguetito.

A continuación vamos a cambiar el nombre al servicio, en nuestro caso lo llamaremos "IECacheQueryService". Y posteriormente estableceremos a True los valores de las propiedades CanPauseAndContinue y CanShutdown, para poder pausar y detener nuestro servicio en tiempo de ejecución.

Importante: Comprobar que el nombre sel servicio se ha cambiado correctamente en el punto de entrada de la aplicación (si no fuese así tendremos que modificarlo manualmente):

static class Program

        static void Main()

            ServiceBase[] ServicesToRun;

            ServicesToRun = new ServiceBase[]

                new IECacheQueryService()

};

            ServiceBase.Run(ServicesToRun);

Implementando funcionalidad al servicio:

De momento el servicio será capaz de iniciarse, pero no realizará nada. Ahora debemos dotarlo de funcionalidad, y para ello vamos a crear un temporizador que se encargue de realizar una tarea cada X tiempo (por defecto una hora). Éste lo crearemos como un miembro dentro de nuestra clase:

public partial class IECacheQueryService : ServiceBase

    private Timer clock = new Timer();

Y lo usaremos desde el constructor de la misma, así como en los eventos OnStart y OnStop. Observar que en el constructor lo inicializamos con un valor que proviene del fichero de configuración del proyecto (propiedades del proyecto/settings) llamado TimerInterval y se ha establecido a un valor de 3.600.000 (1 hora en milisegundos).

public IECacheQueryService()

    InitializeComponent();

    clock = new Timer(Properties.Settings.Default.TimerInterval);

    clock.Elapsed += new ElapsedEventHandler(clock_Elapsed);

    clock.Enabled = true;

    //...

protected override void OnStart(string[] args)

    ExecuteQuery();

    clock.Start();

    //...

protected override void OnStop()

    clock.Stop();

Del mismo modo también especificamos el manejador de evento asociado que se ejecutará cada vez que se cumpla este intervalo de tiempo (clock_Elapsed). Éste será el corazón de nuestro servicio y será el encargado de invocar la consulta a la caché de IE:

void clock_Elapsed(object sender, ElapsedEventArgs e)

try

            ExecuteQuery();

        catch (Exception ex)

            appEventLog.WriteEntry("Exception: " + ex.Message,

                EventLogEntryType.Error);

Simple verdad? Ahora vamos a construir este método ExecuteQuery a apartir de las piezas que vimos en anteriores entradas de la misma serie. No os preocupeis que en el último post estará un enlace al código completo del ejemplo (incluido el instalable).

Que hace exactamente este método?

Primero de todo crea un objeto de tipo StopWatch para medir con precisión el tiempo que transcurre en la ejecución del mismo.
Llama al método getResults que se encarga de efectuar la consulta y devolver un objeto que es una lista genérica de entradas de la caché.
Construye el nombre de fichero en el que guardaremos los resultados y llama al método saveResults, encargado de realizar la suplantación de identidad y serializar los resultados en el fichero antes mencionado.

private void ExecuteQuery()

try

        Stopwatch watch = new Stopwatch();

        watch.Start();

        List<IECacheEntry> results = getResults(

            Properties.Settings.Default.SearchPattern);

        string filename = string.Format("{0}{1}_{2}.xml",

            Properties.Settings.Default.TargetPathLocation,

            Environment.MachineName,

            DateTime.Now.ToString("ddMMyyyy_hhmm"));

        watch.Stop();

        TimeSpan ts = watch.Elapsed;

        saveResults(results, filename);

        appEventLog.WriteEntry(string.Format(

            "Query executed successfully at {0} in '{1}' by user '{2}'. Elapsed time (ms): {3}",

            DateTime.Now.ToString(), Environment.MachineName,

            WindowsIdentity.GetCurrent().Name,ts.Milliseconds));

    catch (Exception ex)

        appEventLog.WriteEntry("Exception: " + ex.Message,

            EventLogEntryType.Error);

Está el servicio terminado? Bueno, si asumimos que el código está completo y funciona sin errores, sí, lo está :-P

Y ahora cómo lo probamos? Pues... bueno, para probarlo antes tenemos que instalarlo.

Agregando los elementos necesarios para instalar el servicio:

No he encontrado demasiada documentación al respecto, de modo que intentaré mostrar los pasos a seguir mediante capturas de pantalla.

Vamos a agregar un elemento que nos permita distribuir el servicio:

Le agregaremos dos componentes serviceProcessInstaller y serviceInstaller (es posible que no aparezcan en la barra de herramientas, así que tendremos que agregarlos mediante la opción "Choose Items..."

A continuación los configuraremos del siguiente modo:

Control	Propiedad	Valor
serviceProcessInstaller1	Account	LocalSystem (*)
serviceProcessInstaller1	Parent	Installer1
serviceInstaller1	Description	Internet Explorer Query Cache
serviceInstaller1	Display Name	Internet Explorer Query Cache
serviceInstaller1	Parent	Installer1
serviceInstaller1	ServiceName	IEQueryCache
serviceInstaller1	StartType	Automatic

(*) Habitualmente se utilizará siempre la cuenta con menos nivel de privilegios (LocalService), pero en nuestro caso necesitamos acceder a la caché de IE, de modo que es posible que incluso tengamos que configurar la cuenta de un usuario de windows con suficientes permisos.

Cruzamos los dedos, compilamos el proyecto y vamos a agegar un proyecto de instalación a la solución.

Creando el proyecto de instalación:

Agregaremos un proyecto de tipo Setup and deployment, que será el encargado de instalar nuestro servicio en las estaciones Windows que deseamos monitorizar.

Agregamos la salida del proyecto anterior al nuevo proyecto de instalación:

Ahora mostraremos la ventana de "custom actions" para agregar como acción al instalador la salida de nuestro proyecto de servicio de Windows.

Una vez realizado esto ya podemos compilar el proyecto de instalación e instalarlo en las estaciones cliente. Si quereis instalarlo en vuestra estación para probarlo y configurarlo adecuadamente, la opción más sencilla es seleccionar la opción Install del menú contextual del proyecto de instalación, en el explorador de proyectos.

Una vez instalado, aparecerá en el administrador de servicios, para que podamos configurarlo del modo deseado. En este caso particular, si deseamos monitorizar la caché de un usuario en particular, deberemos usar las credenciales de éste usuario, ya que si no el S.O. no será capaz de montar el fichero Index.dat correspondiente a la caché de Internet Explorer.

Bueno, hasta aquí ha llegado este ejemplo. En el próximo post haremos un resumen de lo que se ha visto hasta ahora y publicaré un enlace con el código completo del proyecto para que sirva de ejemplo (o de mal ejemplo :-P).

Saludos desde andorra,

Acceder a la caché de Internet Explorer (I)

Lluis Franco — Thu, 15 May 2008 15:59:45 GMT

En algunos casos puede ser interesante acceder a la caché de navegación de Internet Explorer. Por ejemplo, para poder guardar un registro de los sitios que visitan los usuarios de nuestra organización sin tener que montar un ISA server o similar.

Para ello, y como todavía no he encontrado nada implementado en el propio Framework, vamos a hacer uso de algunos elementos del API de Windows. Ese gran amigo que todavía nos sigue sacando las castañas del fuego algunas veces... :-D

El punto de partida:

Cuando accedemos a la carpeta de archivos temporales de Internet, podemos eliminar el contenido o cambiar la ubicación de la carpeta que utilizamos para almacenar este información:

Incluso si pulsamos la opción de ver archivos, el explorador nos muestra una vista similar a esto:

Sin embargo, esta vista se genera automáticamente a partir del contenido de un fichero llamado Index.dat, que se encuentra en la carpeta "Archivos temporales de Internet\Content.IEX", siendo X la versión de IE del sistema. De modo que, para poder acceder a la información contenida en este fichero no nos queda más remedio que utilizar algunas funciones del API de Windows.

Presentando a los protagonistas:

Como os decía anteriormente, a falta de poder usar código manejado vamos a utilizar los ladrillos del propio S.O.

Esta estructura representa un elemento dentro de la caché de Internet.

[StructLayout(LayoutKind.Sequential)]

public struct INTERNET_CACHE_ENTRY_INFO

    public UInt32 dwStructSize;

    public string lpszSourceUrlName;

    public string lpszLocalFileName;

    public UInt32 CacheEntryType;

    public UInt32 dwUseCount;

    public UInt32 dwHitRate;

    public UInt32 dwSizeLow;

    public UInt32 dwSizeHigh;

    public Win32API.FILETIME LastModifiedTime;

    public Win32API.FILETIME ExpireTime;

    public Win32API.FILETIME LastAccessTime;

    public Win32API.FILETIME LastSyncTime;

    public IntPtr lpHeaderInfo;

    public UInt32 dwHeaderInfoSize;

    public string lpszFileExtension;

    public UInt32 dwExemptDelta;

};

Más información acerca de esta estructura en:

INTERNET_CACHE_ENTRY_INFO Structure

http://msdn.microsoft.com/en-us/library/aa385134(VS.85).aspx

También nos basaremos en estas dos funciones, encargadas de devolver un puntero a un elemento del tipo INTERNET_CACHE_ENTRY_INFO dentro de la caché. La primera de ellas devuelve el primer valor encontrado en la caché, a partir de un puntero a una cadena que representa el patrón a buscar. Mientras que la segunda recibe el manejador devuelto por la primera llamada a FindFirstUrlCacheEntry.

[DllImport("wininet.dll", SetLastError=true)]

private static extern IntPtr FindFirstUrlCacheEntry(

  string lpszUrlSearchPattern, IntPtr lpFirstCacheEntryInfo,

  out UInt32 lpdwFirstCacheEntryInfoBufferSize );

[DllImport("wininet.dll", SetLastError=true)]

private static extern long FindNextUrlCacheEntry(

  IntPtr hEnumHandle, IntPtr lpNextCacheEntryInfo,

  out UInt32 lpdwNextCacheEntryInfoBufferSize );

Podéis encontrar más información acerca de ellas en:

FindNextUrlCacheEntry Function
http://msdn.microsoft.com/en-us/library/aa384049(VS.85).aspx

FindFirstUrlCacheEntry Function
http://msdn.microsoft.com/en-us/library/aa384026(VS.85).aspx

Y ahora que?

Pues ahora nada, que me he quedado sin tiempo... hasta aquí este primer post. Mañana continuaremos con la construcción de un pequeño proyecto de ejemplo que utiliza estas funciones para acceder a la caché de Internet y muestre el contenido en pantalla. Y si da tiempo, sería interesante crear una aplicación o servicio que vaya monitorizando y guardando este contenido en algún medio persistente (tal vez XML o una base de datos).

Hasta mañana!