Very Computer

Hello Gurus,

I have a C program (A) from which I call another program (B) through
its (B's) API.  I need to have a logic (in A) where I check to see if
I have to call B from A depending on some processing in the program A.

Program A gets called by many processes and if at one point of time
it is decided that the program B need not be called any longer from A
then it has to be seen by other processes that start A (some kind of
System Variable???) after the change takes place...

What is the best way of doing this?

I am sorry if I haven't explained my problem clearly enough, but any
help is appreciated.

Thanks.

Sent via Deja.com http://www.deja.com/
Before you buy.

Use a file.  A should check whether the file exists, and only call B if it
doesn't.  If some other process wants to indicate that B shouldn't be
called, it creates the file.

--

GTE Internetworking, Powered by BBN, Burlington, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.

I presume that you really mean "processes" and not "functions"
(it isn't completely clear from the post that this is the case)?

You'll need to use some IPC mechanism.  Shared memory, a
semaphore, or an I/O trick all seem to suggest themselves as
likely candidates.  I'll go with a I/O based suggestion, since
it is very portable, and reasonably low cost...

Start out by creating a FIFO:
  mknod("/some/path/or/other", S_FIFO|0444, 0);
Then, processes which want to know wheter A is done calling B
can check this by first opening:
  statfd = open("/some/path/or/other", O_RDONLY|O_NONBLOCK);
and then querying the status with:
  char junk;
  status = read(statfd, &junk, 1);
A status of -1 (errno==EWOULDBLOCK) indicates that A has not
yet indicated that it is done calling B; a status of 0
indicates that it is done.  (Note: if you actually want to
_wait_ for A to be done with B, leave off the O_NONBLOCK
on the open() call (or use fcntl() to turn off O_NONBLOCK);
then the read() command will block until A indicates that it
is done.

Now the only piece left is: how does A do its thing?  Well,
immediately after creating the FIFO, A should open it for
writing:
  statfd = open("/some/path/or/other", O_WRONLY);
Then, to indicate that it is done with B, A would simply:
  close(statfd);
Ta da!

                --Ken Pizzini

I use this trick myself, often enough to have discovered several ways
it can bite you.  First way: do a kill -9 on the program that should
remove the file before it gets around to doing so.  Second way: create
the file some other way (e.g. by running a program that doesn't know
that it's creating a "magic" file name, or by just doing a cat, vi,
etc.).  Third way: have the system go down (by power failure, kernel
panic, etc.) while the file exists.

Any of these things will ensure that B never gets called again
(at least until you manually remove the file), unless you take
precautionary measures (e.g. remove the file during boot, perhaps
in an rc file).

--

Remove the first period after the "at" sign to reply.