You should be able to call fileno on the descriptors and pass them as arguments (either command line or in the environment) and then use either dup(2) or open( HANDLE, "<&$fd" ) (see perlopentut and the docs for open for the exact syntax) to get a proper local endpoint in either C or Perl.

Thanks for the reply. I'm on my way out the door, so I will dig through the doc tonight, and try it in the morning. mhutch

Hi

Instead of getting fileno from Environment Variable, you can write a program in such a way that read from Shared Memory.

"Keep pouring your ideas"

The OP stated that he is running this on unix. The 'disk emulation' concept of shared memory is available under linux and POSIX, but if the unix system isn't POSIX compliant, then the shared memory style to fall back on wouldn't be accessible via a device driver nor is it file-structured. - Oops I thought you meant use a shared memory file until I reread your post.

-M

Free your mind

http://www.pcre.org/

Just to make me clear, here's the C part:

/* gcc callfilter.c -o callfilter */
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>

int main (int argc, char *argv[]) {
   int writer[2]; /* From the parent's point of view */
   int reader[2]; /* From the parent's point of view */
   int pid;
   char *msg = "hullo";
   char buf[10];
   int nread;

   /* Get pipes on */
   if (pipe(reader)) {
      perror("reader pipe(): ");
      return 1;
   }
   if (pipe(writer)) {
      perror("writer pipe(): ");
      return 1;
   }

   pid = fork();
   if (pid < 0) {
      perror("fork(): ");
      return 1;
   }
   else if (pid == 0) { /* In the child */
      /* close unneeded endpoints */
      close(reader[0]);
      close(writer[1]);
      /* Duplicate handles on STDIN and STDOUT for child */
      dup2(writer[0], 0);
      dup2(reader[1], 1);
      /* call filter */
      execl("./filter.pl", "./filter.pl", NULL); /* patched, thanks to
+ djp */
      perror("execl(): ");
      return 1;
   }
   else { /* In the parent */
      /* close unneeded endpoints */
      close(reader[1]);
      close(writer[0]);
      /* Send something to the filter */
      write(writer[1], msg, strlen(msg));
      close(writer[1]);
      /* Read response from the filter */
      printf("filter says:\n");
      while ((nread = read(reader[0], buf, 9)) > 0) {
         buf[nread] = '\x0';
         printf("%s", buf);
      }
      if (nread < 0) {
         perror("read(): ");
         return 1;
      }
      printf("\n");
      close(reader[0]);
   }

   return 0;
}
[download]

#!/usr/bin/perl
use strict;
use warnings;
local $/;
my $in = <STDIN>;
print {*STDOUT} scalar reverse $in;
[download]

poletti@PolettiX:~/sviluppo/perl/dup$ ./callfilter
filter says:
olluh
[download]

Update: patched C example, thanks to djp.

     execl("./filter.pl", NULL);
[download]

should be

      execl("./filter.pl", "./filter.pl", NULL);
[download]

Frodo72,

You have nearly what I need! Perhaps I've made the problem more difficult than it needs to be.

When I substitute my "filter.pl", it nearly works as needed.

Can I trouble you for advice on how to trigger the pipe to "swallow" additional strings without closing writer1 (on your original line 48). I'll need to read a series of address strings from a database and attempt substitution on each.

I test my filter.pl by firing from the comandline, after which I'm able to enter text, <cr>, and the substituted string appears. I enter <cr>, and it's ready for the next substitution. Ctl-D terminates it.

When I invoke it from callfilter, the msg line substitutes, but later lines do not. Is this behavior due to closure of the file/pipe?

Thanks in advance,

mhutch

(p.s. -- Any recommendations on where to RTFM about agnostic filters in perl?)

The example was clearly only a "proof of concept", you can modify it to suit your needs. In particular you can close the pipes' ends when you really need it. In my example:

   else { /* In the parent */
      /* close unneeded endpoints */
      close(reader[1]);
      close(writer[0]);
      /* Send something to the filter */
      write(writer[1], msg, strlen(msg));
      close(writer[1]);   /* HERE I CLOSE PARENT->FILTER */
      /* Read response from the filter */
      printf("filter says:\n");
      while ((nread = read(reader[0], buf, 9)) > 0) {
         buf[nread] = '\x0';
         printf("%s", buf);
      }
      if (nread < 0) {
         perror("read(): ");
         return 1;
      }
      printf("\n");
      close(reader[0]);  /* HERE I CLOSE FILTER->PARENT */
   }
[download]

I closed the file descriptors immediately when they were not needed any more. I wanted to send only one string, then I closed the writer[1]. But you can keep it open until you're done (note: the following code is "high-level"):

   else { /* In the parent */
      /* close unneeded endpoints */
      close(reader[1]);
      close(writer[0]);

      while (msg = next_string_to_filter()) {
         /* Send something to the filter */
         write(writer[1], msg, strlen(msg));

         /* Read response from the filter */
         read_and_consume_answer(reader[0]);
      }

      /* Close communication with filter */
      close(writer[1]);
      close(reader[0]);
   }
[download]

A little note is due here about read_and_consume: be very, very careful about synchronisation between the two processes. You probably want to use the filter in a line-oriented fashion (from what I see from your post): be careful that read() blocks! Otherwise, you could prepare all the input (i.e. all the lines that you have to filter), send them all to the filter at once and read the answers. But I'll cut it here before someone reminds me that we're in PerlMonks, not CMonks ;)

Any recommendations on where to RTFM about agnostic filters in perl?

With agnostic I tried to express the fact that the filter does not have to know anything more than "read from STDIN, write to STDOUT", which is what any program normally does. I fear that you aren't going to find much about "agnostic filters" in any language :)

More than this, be careful of buffering, use strict; and use warnings; ;)

Flavio
perl -ple'$_=reverse' <<<ti.xittelop@oivalf

Don't fool yourself.

The normal way to do this is as frodo72 describes: dup the pipe FDs to the child's STDIN and STDOUT. You may still have to turn off FD_CLOEXEC on them; at any rate it's probably safest and most portable.

If both the programs are running on the same server, you can handle the scenario as follows:-

open two pipe files, say pipe_1 and pipe_2
Let C program uses pipe_1 pipe for writing and pipe_2 for reading
Let perl program uses pipe_2 for writing and pipe_1 for reading.

In this way both the program can talk each other.

If both programs are running in different servers then you can use sockets.

How about simply embedding a perl interpreter into your c program? perlembed has some examples for that.

Cheers, Flo