🚀 go-pugleaf

My sample is only sample to explain my point of view.
It is not suitable to write code for both processes here 
so may be my sample is not very succesful.

"Remy Lebeau \(TeamB\)" <gambit47@yahoo.com> wrote:
>
>Well, of course.  But the whole point of sharing memory that is the other
>processes know about it, thus they will know the name of the mapping and can
>use Create/OpenFileMapping to get at it.  However, that is not the issue
>being discussed.  

Of course (not discussed) but main point of sharing memory is 
sharing memory. If processes cooperate in their work it is not 
very important how they will do it. It is not obligatery to 
know name if they really need in right handle to define virtual 
address.

>The original question was how to restrict access to
>read-only for other processes who do want to use the shared memory.  In that
>regard, the answer is as stated earlier - the process who initially creates
>the memory can't control that aspect of the memory, as each process
>obtaining a pointer to the memory can specify their own individual settings
>for how they want to access the memory.  Each process is only responsible
>for its own local pointers to the memory, to to other process's pointers.

It is just the question is it process that create mapping 
restricts access for another processes.


>
>> If to return to question:
>> >> Is there a way to share the memory, but to make
>> >> it read-only to other processes?
>> The answer is yes and DuplicateHandle just for it.
>
>That can only work if you are actually passing the duplicated handle to the
>other process directly, which I get the feeling is not the actual case in
>MWP's situation, but that the other processes are accessing his mapped
>memory directly.  


I told upper - it's only sample.
Really DuplicateHandle should be called from another process.
It only must know ProcessId of source process (that is create 
handle) and value of source handle:
"DuplicateHandle can be called by either the source process
or the target process."
"If the process that calls DuplicateHandle is not the 
target process, the duplicating process must use 
interprocess communication to pass the value of the 
duplicate handle to the target process."

>DuplicateHandle() does not copy the new handle to other
>processes, and certainly is not doing so in your examples.  

As I said before this operation should do another process.

>To do that, the
>other process would have to not be allowed to know the memory's mapped name
>(aka, make it random), and the other process would have to know the process
>handle of the memory's initial owner as well as the numeric value of the
>original read-only handle inside that process.  That last step is not one
>you have shown yet in your examples, as the other process has to make the
>call to DuplicateHandle() passing it the original process's information.

So for another process no need to call OpenFileMapping if 
it know ProcessId of source process and value of handle 
(the handle with RESTRICTION for writing).

Vladimir.