If I'm understanding you correctly, you want your connection thread in MHD
to essentially submit some data/request to a 'main loop' thread, and for it
to then wait for the main loop to process it before returning/sending the
response back to the client? If so, and assuming MHD and your main loop
are just threads within the same process... The way I do that kind of
thing is to use condition variables and/or a blocking queue.
Your MHD thread would submit the request to the main loop (very likely into
a queue that the main loop processes), then wait for a response. You can
wait for a response by "waiting" on a condition variable that the main loop
will "notify" when it has completed processing the data. ('Wait' and
'notify' are the proper terms - you'll see them if you search around for
this stuff.)
Or, if you have access to one and/or want to write one, you can do
something similar using a blocking queue. First, have your MHD thread
submit the request to the main loop (again, into some kind of queue).
Then, have your MHD thread read/pull from a one-item request-specific
blocking queue that the main loop will write/submit the response to. (The
blocking queue will likely use a condition variable under the covers, by
the way.) In other words - when the main loop writes to that
request-specific blocking queue that the MHD thread is waiting on, the MHD
thread will wake up and pull it from the blocking queue to finish
processing the request - necessary data in hand. This is probably slightly
less efficient than the raw condition variable stuff, but it makes the code
simpler because it allows you to hide that condition variable from the code
that's using it.
In both cases and if you want to, you should be able to 'wait' for a
maximum amount of time. E.g., if it takes longer than 3 seconds to get a
response, the MHD thread could wake up anyway and submit an error message
back to the client.
This all may be a lot easier in C++ (using the std lib) than it is in C -
I'm not sure. I know raw pthreads have support for condition variables,
but I've never played with them myself. Writing a blocking queue is not
particularly difficult if you don't have one - less than 50 lines of code
(at least that's how it is in C++).
If your MHD-based web server is in fact a separate process from your 'main
loop' (not just separate threads), well.. then you're doing real IPC, which
can bring a whole host of pain. The simplest (and likely least efficient)
way is probably just to use sockets and send messages back and forth.
Search around for IPC methodologies to see what your options are - I'm no
expert (I vaguely recall a Beej guide to IPC that I found informative).
MHD is so lightweight, I'd suggest going the thread-based route, myself -
just make your MHD-based-webserver part of the application rather than a
standalone process and use some kind of thread-handoff methodology (e.g.,
like one of the 2 I suggest above).
Hope that helps.
Ken
On Wed, Mar 18, 2015 at 9:17 PM, Bob Furber <[email protected]> wrote:
> |I realize this is not really a MHD issue, but, it is likely an issue your
> readers have encountered.||
>
> I have a ||custom ||server [C] ||program ||on a Linux-Arm platform ||which
> uses MHD ||as its||front end to receive and respond to http requests.| |||
>
> Currently, each request is processed in its own thread ||to obtain the
> response||, with the processing code sandwiched inside a mutex to protect
> data from being altered by code in the main-loop ..which also accesses the
> same data. ||Think of the data as a home-baked database that is being
> altered by the main-loop AND by http requests.| |||
>
> Dreaming in Technicolor, I would like to have all the data processing done
> in the main-loop. That is, request||s||would be transferred from the
> connection threads to the main-loop by means of some IPC ||FIFO ||process
> such as a message queue or named pipe. ||My problem is||, I cannot figure
> out how the main-loop would get the response back to the requesting
> thread.||
>
> Again, d||reaming in Technicolor, ||I would like to use some magic IPC
> process where the MHD thread would tag the request with a
> return_response_to_this_pid ||return address ||to allow the main loop to
> deliver the response messages addressed to the corresponding corresponding
> MHD_thread ...an IPC method along the lines of send_ipc_msg( message,
> receiving_pid ). | |||
>
> Clues anybody?| I am not even sure how to ask the right question. ||
>
>
