Newsgroup: it.comp.programmare.win32
Titolo: Ancora Hook

Ho creato una DLL con la Procedura di Hook per la tastiera e ho installato
l'hook su tutti i processi e tutto funziona.
Ora dovrei salvare le sequenze dei tasti premuti in un file:
Pensavo di mettere la sequenza dei tasti decodificati in in buffer char[] e
scriverlo in un file superata una certa dimensione.
il buffer l'ho dichiarato globale (quindi sotto gli #include) ma ho notato che
si svuota da solo cambiando applicazione.
Come faccio ad avere un buffer(o un file) condiviso per tutti i processi a cui
viene attaccata la DLL in modo che quando la KeyboardProc() scrive nel buffer
questo rimane lo stesso per tutti i processi a cui e` attaccata e non perdo
nulla?
Grazie.
-- 
Posted from  [217.57.247.125] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 tutti i processi a
Lo devi allocare in una sezione di memoria condivisa. Nel tuo codice:
#pragma data_segment( ".sharedata")
char buffer[1024];
#pragma data_segment()
Poi crei un file .DEF (che poi includerai nel progetto) cosi` fatto:
SECTIONS
    .sharedata READ WRITE SHARED
Ovviamente dopo dovrai "inventarti" anche un metodo di accesso concorrente a
questa risorsa, per fare in modo che i vari processi non facciano dei
casini. Il modo semplice e` "bloccare" gli altri processi mentre uno sta
accedendo ai dati, ad esempio usando un mutex; oppure se vuoi una soluzione
piu` elegante, al posto del buffer potresti condividere direttamente
l'handle del file, con l'accortezza di aprirlo e gestirlo in modalita`
overlapped (mi sembra che nel caso di piu` processi che vi accedono
contemporaneamente sia necessario).
--
Lorenzo

 casini.
mi intrometto più che altro per un chiarimento ... come potrebbero
verificarsi degli accessi concorrenti ad una risorsa che memorizza i tasti
premuti? In teoria c'è sempre un solo processo che richiede l'accesso alla
risorsa (quello che ha il keyboard focus) ... grazie per l'eventuale
chiarimento.
--
- Carlo -
c.b...@libero.it

 risorsa (quello che ha il keyboard focus) ...
Io facevo un discorso "generale", non avevo fatto caso che si trattasse di
un logger per la tastiera. In effetti non hai tutti i torti, anche se
bisognerebbe verificare in che modo vengono chiamate le hook procedures. E`
un'eventualita` remota (vista la lentezza di ripetizione dei tasti), ma cosa
succederebbe se - all'interno dello stesso processo - arrivasse una nuova
notifica mentre si sta gestendo ancora quella precedente?
Onestamente non mi sono mai posto una domanda del genere... sarebbe
interessante indagare.
--
Lorenzo

 Lorenzo
In effetti ci aveo provato a condividere l'handle del file ad ogni chiamata
alla
DllEntryPoint con DLL_PROCESS_ATTACH ma in qualche caso lo stesso programma che
vi
ha acceduto una volta non lo fa piu` se chiudi il programma di Hook e lo fai
ripartire
senza aver prima chiuso l'altro e a volte anche facendo cosi` non funzionava lo
stesso
(spero di essere stato chiaro...).
Comunque ho trovato un modo ancora piu` elegante anche se un po` complesso
nell'Help
delle Win32 SDK usnado CreateFileMapping():
static LPVOID lpvMem = NULL; // pointer to shared memory
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void*
lpReserved)
{
  HANDLE hMapObject = NULL;  // handle to file mapping
 
    BOOL fInit, fIgnore;
    switch (reason)
    {
        // The DLL is loading due to process
        // initialization or a call to LoadLibrary.
          case DLL_PROCESS_ATTACH:
            // Create a named file mapping object.
            hMapObject = CreateFileMapping(
                (HANDLE) 0xFFFFFFFF, // use paging file
                NULL,                // no security attributes
                PAGE_READWRITE,      // read/write access
                0,                   // size: high 32-bits
                SHMEMSIZE,           // size: low 32-bits
                "dllmemfilemap");    // name of map object
            if (hMapObject == NULL)
                return FALSE;
            // The first process to attach initializes memory.
            fInit = (GetLastError() != ERROR_ALREADY_EXISTS);
            // Get a pointer to the file-mapped shared memory.
            lpvMem = MapViewOfFile(
                hMapObject,     // object to map view of
                FILE_MAP_WRITE, // read/write access
                0,              // high offset:  map from
                0,              // low offset:   beginning
                0);             // default: map entire file
            if (lpvMem == NULL)
                return FALSE;
            // Initialize memory if this is the first process.
            if (fInit)
                memset(lpvMem, '\0', SHMEMSIZE);
 
         case DLL_PROCESS_DETACH:
            // Unmap shared memory from the process's address space.
            fIgnore = UnmapViewOfFile(lpvMem);
            // Close the process's handle to the file-mapping object.
            fIgnore = CloseHandle(hMapObject);
            // Unmap shared memory from the process's address space.
         default:
         break;
    }
  return TRUE;
}
in questo modo lpvMem diventa il puntatore alla memoria condivisa.
In qualsiasi funzione dichiarando 
LPTSTR memBuff;
posso accedere alla memoria condivisa:
memBuff=(LPTSTR) lpvMem; // Riceve il puntatore alla memoria condivisa
e posso gestire memBuff[] come un normale array di caratteri.


 Come faccio ad avere un buffer(o un file) condiviso per tutti i processi
Per esempio, usando un memory mapped file.
-- 
Posted from  [80.105.34.80] 
