Auf Resourcen prozessübergreifend zugreifen?

TomTom85

Hallo zusammen!

Ich hab folgendes Problem.
Ich habe eine Library die in C programmiert ist und die direkt über die WinApi COM-Operationen durchführt. Jetzt hat ein Kunde von uns folgenden Wunsch.
Er möchte, wenn er 2 verschiedene Anwendungen startet, die bei dieselbe DLL benutzen, auf Dieselbe COM-Schnittstelle schreiben können. Ich denke, dass ist ja schlecht möglich, da das HANDLE für die COM-Schnittstelle ja an einen Prozess gebunden ist. Trotzdem wollte ich hier nochmal kurz reinfragen ob mich hier jemand eines besseren belehren kann.
Hat hier jemand vielleicht Ahnung ob man diese System-Resource, also das Handle, von 2 verschiedenen Prozessen aus nutzen kann?

vielen Dank schonmal im voraus

Fake oder Echt

vllt. GlobalAddAtom ()? kA ob das wirklich hilft. Aber mir schwebt im Hinterkopf irgendwo noch ne Möglichketi rum, mit der am eine Variable Global, also für wikrlich alle Prozesse zur Verfügung stellen kann...

hustbaer

Mit DuplicateHandle müsste es schon gehen das Handle zu kopieren so dass der 2. Prozess es auch verwenden kann.

Die Schwierigkeit liegt dann wohl eher darin das ganze ordentlich zu synchronisieren, also wer ruft wo wie DuplicateHandle auf etc.

Variablen in DLLs wirklich "global" zu machen geht z.B. so:

#pragma data_seg(".my_section_name")

extern HANDLE g_my_handle = 0;
extern unsigned long g_my_handle_refs = 0;

#pragma data_seg()

Und im .def File dann:

SECTIONS

	.my_section_name	READ WRITE SHARED

Das alleine reicht aber nicht, es muss der Zugriff auch noch synchronisiert werden. Das könnte man z.B. über eine named mutex machen.

Pseudocode:

HANDLE open_handle()
{
    HANDLE rv;

    lock(named_mutex);

    if (g_my_handle == 0)
    {
        g_my_handle = open_handle();
        g_my_handle_refs = 0;
    }

    rv = duplicate_handle(g_my_handle);
    g_my_handle_refs++;

    unlock(named_mutex);

    return rv;
}

void close_handle(HANDLE h)
{
    lock(named_mutex);

    assert(g_my_handle != 0);
    assert(g_my_handle_refs > 0);

    close_handle(h);
    g_my_handle_refs--;
    if (g_my_handle_refs == 0)
    {
        close_handle(g_my_handle);
        g_my_handle = 0;
    }

    unlock(named_mutex);
}

Das sollte mal den Teil abdecken dass 2 Threads das gleiche Handle (bzw. eben "kopien" des gleichen Handles) verwenden können. Wie das dann mit overlapped vs. non-overlapped IO aussieht weiss ich nicht. Ich denke es wird wohl beides gehen und keine echten Probleme machen, hab sowas aber noch nie probiert.
Weiters könnten sich die beiden Threads in die Quere kommen wenn sie gewisse Dinge tun wie z.B. ClearCommError() oder ähnliches zu verwenden.

danke du homo

Fake oder Echt

#pragma data_seg(".my_section_name") 

extern HANDLE g_my_handle = 0; 
extern unsigned long g_my_handle_refs = 0; 

#pragma data_seg()

Das war das, was mir im Hinterkopf rumschworr.

TomTom85

Vielen Dank für die Info... werd mich dann da mal in die Sache stürzen

Eigentlich sollten die verschiedenen Handles egal sein, die COM-Schnittstelle bleibt doch identisch. Werden auch prozessübergreifende Daten benötigt, so geht dies compiler-abhängig über shared Deklarationen via pragma-Direktiven an den Compiler und den Linker der DLL. Alternativ und immer funktioniert der Einsatz von shared Dateien mit sopen(). Kann so schwer nicht sein!