26 respuestas en este tema

[escafandra]

A raíz de este hilo, en el que se preguntaba cómo podía nuestra aplicación enterarse de la creación de un nuevo archivo, me acordé de que esta utilidad la había implementado mas ampliamente en el hilo Treeview como explorer con checkboxes que alguno seguisteis.

Aunque egostar me aconsejó no traducir el código desde el C al delphi, por la razón de que delphi tiene un componente que abarca esas utilidades, lo he hecho por un motivo. La implementación que realizo es sencilla y se basa sólo en la API de Windows, con lo que su utilidad se hará patente en aquellos programas en que por los motivos que sean, queramos utilizar API pura sin librerías de clase alguna.

La filosofía es sencilla. Debemos dar a una ventana de nuestra aplicación de la capacidad de recibir y responder a los mensajes que se envían al Shell y sus extensiones al producirse cambios. Esas notificaciones se envían mediante la API SHChangeNotify. Los mensajes que a los que debemos responder los encontramos también aquí. Con esa misma API, podemos notificar al Shell de los cambios que nos parezcan oportunos.

El código que nos habilita para recibir los mensajes está en una unit:

delphi

unit ShellMonitor;
 
interface
 
uses
  Windows, Messages, Shlobj;
 
function StartNotification(hWnd: THandle; Msg: integer): DWORD;
procedure EndNotification(NotifyRegister: DWORD);
 
implementation
 
type
 
PCIDLIST_ABSOLUTE = ^ITEMIDLIST;
 
SHChangeNotifyEntry = record
  pidl:      PCIDLIST_ABSOLUTE;
  fRecursive: boolean;
end;
PSHChangeNotifyEntry = ^SHChangeNotifyEntry;
 
const
  SHCNRF_INTERRUPT_LEVEL    = $0001;
  SHCNRF_SHELL_LEVEL        = $0002;
 
function SHChangeNotifyRegister(hwnd: THandle; fSources, fEvents, wMsg, cEntries: integer; pshcne: PSHChangeNotifyEntry): ULONG; stdcall; external 'shell32.dll' name 'SHChangeNotifyRegister';
function SHChangeNotifyDeregister(ulID: integer): boolean; stdcall; external 'shell32.dll' name 'SHChangeNotifyDeregister';
 
function StartNotification(hWnd: THandle; Msg: integer): DWORD;
var
    shCNE: SHChangeNotifyEntry;
    Events: DWORD;
begin
    shCNE.pidl := nil;
    shCNE.fRecursive := TRUE;
 
    // Eventos que se van a registrar
    Events := SHCNE_MEDIAINSERTED or SHCNE_MEDIAREMOVED or SHCNE_DRIVEADD or
              SHCNE_DRIVEREMOVED or SHCNE_UPDATEDIR or SHCNE_UPDATEITEM or
              SHCNE_RENAMEFOLDER or SHCNE_RENAMEITEM or SHCNE_MKDIR or
              SHCNE_RMDIR or SHCNE_CREATE or SHCNE_DELETE;
 
    Result := SHChangeNotifyRegister(hWnd, SHCNRF_INTERRUPT_LEVEL or SHCNRF_SHELL_LEVEL, Events, Msg, 1, @shCNE);
end;
 
procedure EndNotification(NotifyRegister: DWORD);
begin
    if (NotifyRegister <> 0) then
      SHChangeNotifyDeregister(NotifyRegister);
 
end;
 
end.

StartNotification habilita a la ventana dada por hWnd a la recepción del mensaje Msg, que será el que el Sistema nos enviará al producirse alguno de los eventos que hemos registrado. EndNotification deshabilita la recepción.

Ahora voy a poner un ejemplo hecho con la VCL tradicional para mostrar cómo localizar y responder a los eventos deseados. Esto podría trasladarse a un programa sin VCL. Muestro la función de respuesta al mensaje:

delphi

procedure TForm1.WMShellChanged(var Msg: TMessage);
var
  i: integer;
  ppidl: PPITEMIDLIST;
  Path: array [0..MAX_PATH] of CHAR;
begin
  ppidl:= PPITEMIDLIST(Msg.WParam);
  SHGetPathFromIDList(ppidl^, Path);
  if Path[0] = #0 then exit;
  case Msg.LParam and $7FFFFFF of
    SHCNE_UPDATEDIR:
      Memo1.Lines.Add('Contenido de la carpeta cambiado: ' + String(Path));
    SHCNE_MKDIR:
      Memo1.Lines.Add('Carpeta creada: ' + String(Path));
    SHCNE_RMDIR:
      Memo1.Lines.Add('Carpeta borrada: ' + String(Path));
    SHCNE_CREATE:
      Memo1.Lines.Add('Archivo nuevo: ' + String(Path));
    SHCNE_DELETE:
      Memo1.Lines.Add('Archivo borrado: ' + String(Path));
    SHCNE_RENAMEFOLDER:
    begin
      i:=1;
      lstrcpy(Path, ' a ');
      SHGetPathFromIDList(PAPITEMIDLIST(ppidl)[i], Path + lstrlen(Path));
      Memo1.Lines.Add('Carpata renombrada: ' + String(Path));
    end;
    SHCNE_RENAMEITEM:
    begin
      i:=1;
      lstrcat(Path, ' a ');
      SHGetPathFromIDList(PAPITEMIDLIST(ppidl)[i], Path + lstrlen(Path));
      Memo1.Lines.Add('Archivo renombrado: ' + String(Path));
    end;
    SHCNE_DRIVEADD:
      Memo1.Lines.Add('Disco insertado: ' + String(Path));
    SHCNE_DRIVEREMOVED:
      Memo1.Lines.Add('Disco retirado: ' + String(Path));
    SHCNE_UPDATEITEM:
      // La desconexión del cable de red viene por aquí.
      Memo1.Lines.Add(Path);
  end;
end;

Subo un archivo con la unit ShellMonitor y una aplicación de ejemplo.

PD: Vuelvo a subir el archivo por problemas en las descargas.
Espero que sea de utilidad.

Saludos.

Archivos adjuntos

•  ShellMonitor.rar   162,41KB   70 descargas

[egostar]

Amigo escafandra, mis respetos, es usted un duro, llegando a casa lo descargaré.

Salud OS

[Wilson]

Gracias maestro Escafandra, como siempre muy buen código.

[enecumene]

   

[poliburro]

Amigo escafandra, como siempre sus aportaciones son impresionantes, Gracias por compartir.

[escafandra]

Vista la necesidad de presentar este truco en C++ aquí está el código:

cpp

//---------------------------------------------------------------------------
#define NO_WIN32_LEAN_AND_MEAN
 
#include <vcl.h>
#pragma hdrstop
#include <shlobj.h>
#include <shellapi.h>
#include <stdio.h>
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
 
TForm1 *Form1;
 
#define WM_USER_SHELLCHANGED WM_USER + 100
 
#define  SHCNRF_INTERRUPT_LEVEL    0x0001
#define  SHCNRF_SHELL_LEVEL        0x0002
#define  SHCNRF_RECURSIVE_INTERRUPT 0x1000
#define  SHCNRF_NEW_DELIVERY        0x8000  // Messages received use shared memory. Call SHChangeNotification_Lock to access the actual data
 
 
typedef struct _SHChangeNotifyEntry
{
    LPCITEMIDLIST pidl;
    BOOL  fRecursive;
} SHChangeNotifyEntry;
 
typedef ULONG(WINAPI *PSHChangeNotifyRegister)(HWND hwnd, int fSources, LONG fEvents, UINT wMsg,
                                    int cEntries, const SHChangeNotifyEntry *pshcne);
 
typedef BOOL (WINAPI *PSHChangeNotifyDeregister)(ULONG ulID);
 
 
ULONG m_ulSHChangeNotifyRegister;
 
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
 
// SHChangeNotify
void __fastcall TForm1::WndProc(Messages::TMessage &Message)
{
  if (Message.Msg == WM_USER_SHELLCHANGED){
    //  ppidl[0] =  the previous PIDL or name of the folder.
    //  ppidl[0] =  the new PIDL or name of the folder.
    LPITEMIDLIST *ppidl = (LPITEMIDLIST*)Message.WParam;
    char Path[MAX_PATH];
 
    switch(Message.LParam & 0x7FFFFFF)
    {
      case SHCNE_UPDATEDIR:
        SHGetPathFromIDList(ppidl[0], Path);
        if(*Path)
            Memo1->Lines->Add("Contenido de la carpeta cambiado: " + String(Path));
      break;
      case SHCNE_MKDIR:
        SHGetPathFromIDList(ppidl[0], Path);
        if(*Path)
            Memo1->Lines->Add("Carpeta creada: " + String(Path));
      break;
      case SHCNE_RMDIR:
        SHGetPathFromIDList(ppidl[0], Path);
        if(*Path)
            Memo1->Lines->Add("Carpeta borrada: " + String(Path));
      break;
      case SHCNE_CREATE:
        SHGetPathFromIDList(ppidl[0], Path);
        if(*Path)
            Memo1->Lines->Add("Archivo nuevo: " + String(Path));
      break;
      case SHCNE_DELETE:
        SHGetPathFromIDList(ppidl[0], Path);
        if(*Path)
            Memo1->Lines->Add("Archivo borrado: " + String(Path));
      break;
      case SHCNE_RENAMEFOLDER:
        SHGetPathFromIDList(ppidl[0], Path);
        strcat(Path, " a ");
        SHGetPathFromIDList(ppidl[1], Path + strlen(Path));
        if(*Path)
          Memo1->Lines->Add("Carpata renombrada: " + String(Path));
      break;
      case SHCNE_RENAMEITEM:
        SHGetPathFromIDList(ppidl[0], Path);
        strcat(Path, " a ");
        SHGetPathFromIDList(ppidl[1], Path + strlen(Path));
        if(*Path)
          Memo1->Lines->Add("Archivo renombrado: " + String(Path));
      break;
      case SHCNE_DRIVEADD:
        SHGetPathFromIDList(ppidl[0], Path);
        if(*Path)
          Memo1->Lines->Add("Disco insertado: " + String(Path));
      break;
      case SHCNE_DRIVEREMOVED:
        SHGetPathFromIDList(ppidl[0], Path);
        if(*Path)
          Memo1->Lines->Add("Disco retirado: " + String(Path));
      case SHCNE_UPDATEITEM:
        // La desconexión del cable de red viene por aquí.
        SHGetPathFromIDList(ppidl[0], Path);
        if(*Path)
          Memo1->Lines->Add("SHCNE_UPDATEITEM " + String(Path));
 
      }
 
  }
 
  TForm::WndProc(Message);
}
 
void __fastcall TForm1::StartNotification()
{
    PSHChangeNotifyRegister SHChangeNotifyRegister =
          (PSHChangeNotifyRegister)GetProcAddress(GetModuleHandle("shell32.dll"), "SHChangeNotifyRegister");
 
    LPITEMIDLIST ppidl1, ppidl2;
    SHChangeNotifyEntry shCNE;
    DWORD Atributes;
 
    shCNE.pidl = 0;
    shCNE.fRecursive = TRUE;
 
 
    // Eventos que se van a registrar
    LONG Events = SHCNE_MEDIAINSERTED | SHCNE_MEDIAREMOVED | SHCNE_DRIVEADD |
                  SHCNE_DRIVEREMOVED | SHCNE_UPDATEDIR | SHCNE_UPDATEITEM |
                  SHCNE_RENAMEFOLDER | SHCNE_RENAMEITEM | SHCNE_MKDIR | SHCNE_RMDIR |
                  SHCNE_CREATE |SHCNE_DELETE;
 
    m_ulSHChangeNotifyRegister = SHChangeNotifyRegister(Handle, SHCNRF_INTERRUPT_LEVEL | SHCNRF_SHELL_LEVEL, Events, WM_USER_SHELLCHANGED, 1, &shCNE);
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::FormDestroy(TObject *Sender)
{
    PSHChangeNotifyDeregister SHChangeNotifyDeregister =
      (PSHChangeNotifyDeregister)GetProcAddress(GetModuleHandle("shell32.dll"), "SHChangeNotifyDeregister");
 
    if(m_ulSHChangeNotifyRegister)
      SHChangeNotifyDeregister(m_ulSHChangeNotifyRegister);
 
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::FormCreate(TObject *Sender)
{
  StartNotification();
}

Saludos.

[egostar]

Hola

Sólo para agradecer a escafandra por éste código, me ha resultado genial para una aplicación que estoy creando ahora mismo

Saludos

[egostar]

Hola

Trabajando con el código, veo que monitorea la actividad de todo el disco, no he podido encontrar donde se configura que el monitoreo sea solamente en un directorio en particular, lo que hago es validar que el evento se está produciendo en el directorio que quiero monitorear.

delphi

  //Verificamos que el evento ser haya producido en el directorio que deseamos
  Ruta := ExtractFilePath( String(Path) );
  if Ruta <> DirMonitoreo then exit;

¿ Hay alguna otra forma ?

Saludos

[escafandra]

Sólo para agradecer a escafandra por éste código, me ha resultado genial para una aplicación que estoy creando ahora mismo

Gracias a ti por usarlo.

Trabajando con el código, veo que monitorea la actividad de todo el disco, no he podido encontrar donde se configura que el monitoreo sea solamente en un directorio en particular, lo que hago es validar que el evento se está produciendo en el directorio que quiero monitorear...

...¿ Hay alguna otra forma ?

En realidad no monitorea la actividad de todo el disco, sino de todo el Shell. Puedes registrar los mensajes que quieres recibir, en el ejemplo registro muchos para explicar el significado de cada uno, pero tu debes registrar sólo los que te interesen.

El enfoque del evento lo haces bien, si no corresponde con la carpeta deseada, abortas... También puedes fijarte en los archivos, depende de la necesidad que tengas que cubrir.


Saludos.

[egostar]

En realidad no monitorea la actividad de todo el disco, sino de todo el Shell. Puedes registrar los mensajes que quieres recibir, en el ejemplo registro muchos para explicar el significado de cada uno, pero tu debes registrar sólo los que te interesen.

El enfoque del evento lo haces bien, si no corresponde con la carpeta deseada, abortas... También puedes fijarte en los archivos, depende de la necesidad que tengas que cubrir.

Saludos.

En realidad no me interesa el archivo, es un directorio para almacenar archivos específicos y que está parametrizado en el programa que los genera.

Y si, lo conceptualicé mal se monitorea el shell . Y me di cuenta porque una vez que obtengo ese archivo lo muevo a otro directorio y lo envió dos veces .

Bueno, además como sólo me interesa los nuevos archivos hice esto:

delphi

  Events := SHCNE_CREATE;
  Result := SHChangeNotifyRegister(hWnd, SHCNRF_INTERRUPT_LEVEL or SHCNRF_SHELL_LEVEL, Events, Msg, 1, @shCNE);

Pero pensando en la posibilidad de que el programa lo cierren..... cosa mas frecuente de lo que uno cree debo idear un proceso alterno, pero bueno eso ya es menos complejo, con un Findfirst lo puedo resolver, pero... (como siempre hay un pero jejeje) necesito "parar" la lectura del shell cuando haga eso.

Ya veré la mejor forma

Gracias amigo.

[escafandra]

Pero pensando en la posibilidad de que el programa lo cierren..... cosa mas frecuente de lo que uno cree debo idear un proceso alterno...

Pues dependiendo de la naturaleza del programa puedes diseñarlo como servicio, o ejecutarlo como otro usuario (administrador, por ejemplo) así es mas difícil cerrarlo desde un taskmanager, anular éste o también puedes usar el truco que publiqué en platino ProcessProtector.
 

...pero bueno eso ya es menos complejo, con un Findfirst lo puedo resolver, pero... (como siempre hay un pero jejeje) necesito "parar" la lectura del shell cuando haga eso.

En el mismo ejemplo tienes la respuesta:

delphi

procedure EndNotification(NotifyRegister: DWORD);
begin
    if (NotifyRegister <> 0) then
      SHChangeNotifyDeregister(NotifyRegister);
 
end;

Saludos.

[egostar]

Pues dependiendo de la naturaleza del programa puedes diseñarlo como servicio, o ejecutarlo como otro usuario (administrador, por ejemplo) así es mas difícil cerrarlo desde un taskmanager, anular éste o también puedes usar el truco que publiqué en platino ProcessProtector.

Si, eso no me preocupa, solo que debo tomarlo en cuenta
 

En el mismo ejemplo tienes la respuesta:

Si, ya lo había visto, pero me refería a la logística de como y cuando

Saludos

[escafandra]

...me refería a la logística de como y cuando

En ese caso, tu mejor que nadie, te darás cuenta del detalle... Quizás en cada arranque nuevo del programa...


Saludos.

[luk2009]

Hola Como estan

 

Probando el codigo de escafandra he visto que si los cambios los realiza un programa, estos no se detectan por este metodo.

Me explico, tengo un programa que graba las llamadas telefonicas y que segun la fecha, crea un archivo de audio con esa llamada. La idea es monitorear esas carpetas y cuando se genere un nuevo archivo de audio, tomar la ruta completa del archivo para guardarlo en una base de datos firebird. 

 

Si cambio algo, de forma manual en esos directorios, los cambios son detectados, pero cuando el programa crea un archivo nuevo, no pasa nada.

 

Que se puede hacer en estos casos?

[escafandra]

Probando el codigo de escafandra he visto que si los cambios los realiza un programa, estos no se detectan por este metodo.

No se como lo estás usando. Como me ha llamado la atención tu comentario he abierto la aplicación ShellMonitor publicada como adjunto en este tema, he dado al botón start y he compilado un programa que estoy escribiendo. Resultado: todos los archivos creados han aparecido el el monitor. Luego he puesto mi keylogger en marcha y el resultado es que ha aparecido en el monitor el archivo donde graba lo capturado. Ninguno de los casos ha sido a mano...

Lo que te puede ocurrir es que no detecte cambios en un archivo no nuevo, el monitor de la shell no lo detecta, a no ser que M$ haya cambiado algo en los nuevos S.O. eso ya se discutió aquí.

No se puede monitorizar un archivo concreto pero si detectará un cambio ocurrido en la carpeta, con esa información se puede recorrer y verificar las fechas...

 

 

Saludos.

[luk2009]

Gracias Esca por responder tan rapido

 

Estoy usando windows 7 y he bajado el archivo de este hilo y sin hacer ningun cambio, no me detecta esos cambios.

 

El programa lo que hace es crear un archivo de audio  nuevo, por cada llamada que se genera y le da el nombre segun la fecha, la hora y el telefono al cual se llamó.

 

C:\U2_V3.11\usb-record\2015\09\19\2015-09-19_01-17-10_000_8095487273

 

te reitero si hago cualquier cambio de forma manual en este directorio o copio el nombre o lo que sea, lo detecta inmediatamente, pero cuando se crea el archivo, no detecta nada.

[luk2009]

https://www.youtube....h?v=289CyRPn3QE

 

ese es el programa que utilizo para grabar las llamadas y como ves crea un archivo nuevo por cada llamada

[escafandra]

Creo que ya se lo que pasa. ¿Que usuario ejecuta esa app?. El Monitor solo puede capturar el shell del usuario que lo ejecuta, no de otro, pues no se mandan notificaciones.

Prueba con programas ejecutados por el mismo usuario que el monitor y me cuentas.

 

Saludos.

[luk2009]

pues los ejecute los dos como administrador y nada.

 

por si acaso abri el shellmonitor primero y luego el usbrecorder y nada.

 

estuve probando con otro programa que encontre en la red http://www.ajpdsoft....article&sid=427 y tampoco detecta nada.

[escafandra]

Ejecuta el monitor y el notepad como usuario normal. Guarda el archivo del notepad a ver que pasa.

 

Se subo el monitor por si acaso...

 

 

Saludos.

Archivos adjuntos

•  ShellMonitorBin.rar   158,52KB   19 descargas