Grant,

>> But to make it absolutily clear, in my explanation the RPi is *passive*.
>> It waits for connections initiated by both hosts, and only than tries to
>> / can write received packets to the other interface.
>
> I think we have a nomenclature problem here.

Yeah, I also got that rather strong feeling, which is why I mentioned the
above.   To allow you to become aware of my usage of the word (and context),
and invite you to mention yours.  As you did.

> Where as some people in this thread have taken "active" vs "passive" to
> mean "doing something with the traffic to copy it from one interface to
> another".

:-)  Look at the package-exchanging method I described.   Although the Pi is
not attempting to do /anything/ to those packets, the end result is still
that the data connection (between A and C) is scrubbed.   Now, tell me if
that means the Pi is "passive", or "active" :-)

IOW, the definition of the word "passive" (and "active" ofcourse) is
strongly tied to the context:

Using my described method to shuttle datapackets to-and-fro:

- The Pi is passive because it does not initiate connections to either A or
C

- The Pi is passive because it does not attempt to alter the datapackets it
exchanges between the two sockets.

- From the POV of A and C the Pi is active, as it scrubs the datastream
between them.

And I'm sure I forgot a few POVs :-)

> You have stated that you want to /actively/ decide what traffic to allow
> through or not.

I'm sorry, but I never mentioned anything of the kind  (I read that
"actively decide" as "runtime" as opposed to "design time")

Also, as we are observing nomenclature, what does "traffic" mean to you ?
Everything that goes over the ethernet cable (or comparable), or perhaps
just the data thats left when all the different headers are peeled away ?
Maybe even something in between ?   And yeah, that does make (quite) a
difference I'm afraid. :-)

> Even if you don't consider traditional routing to be active, you have
> indicated that you are considering writing a custom program to read from
> one interface and write to another, possibly via sockets with the existing
> TCP/IP stack.  This sounds very active to me.

And there you have yet another context in which "passive" or its counterpart
"active" can be used.  On the other hand, can you make the RPi actually /do/
anything while its "passive" (not running any kind of program) ?   Other
than being a paperweight of some sort I mean.

I'm going to stop this here though, this is getting silly.  The next thing
we do is discussing what the definition of "is" is. :-(

> Hosts A and C will know the remote IP that they are talking to.  They can
> share that information in the data that passes between them (much like FTP
> does) and can detect that each other are not
> at the addresses they are talking to.

How do they detect that ?    You seem to assume that A and C know each
others IPs.   Why ?   What would that be good for ?

And even if they would know, there is no way they can reach each other.   As
you said it, if they could than this whole conversation would be moot (and a
big waste of time).

Regards,
Rudy Wieser

--- SoupGate-Win32 v1.05