RE: ASP Capabilities value 0x2 of interworking field

[..snip..]
> > [TOLGA]What about in IP domain? The goal with the protocols is
> to define a
> > sound architecture, which allows interoperability and does not
> allow room
> > for ambiguity. IMO allowing IPSP functionality to allow
> relaying is against
> > those principles. I also want to reemphasize that here we are
> speaking of
> > different roles played by SUA stack, i.e. we can have SUA-node which can
> > both relay and use IPSP communication. What we are discussing is, where
> > those different functionalites should reside.
>
> Functional placement is an implementation issue.
To clarify what I mean, consider the following figure (SUA stands for SUA
functionalities, it does not refer to any specific implementation, e.g. it
can be one or more than one stack instance)

 +-------+
 | App4  |
 +-------+
 |  SUA  +            +-------+              +-------+
 +--+----+            | App1  |              | App2  |
    |    SGP/ASP      +-------+              +-------+
    +--procedures-----+  SUA  +---IPSP-------+  SUA  |
             +--------+--+----+   procedures +-------+
             |           |
           SGP/ASP       |
 +-------+ procedures  SGP/ASP
 | App5  |   |         procedures
 +-------+   |           |
 |  SUA  +---+           |                   +-------+
 +-------+               |                   | App3  |
                      +--+----+              +-------+
                      |  SUA  +---SGP/ASP----+  SUA  |
                      +-------+   procedures +-------+

Let's suppose for App1/App2 communication, there is no need for GTT -nor for
any other type of relay-, so IPSP procedures are used.

For App1/App3 communication we need GTT, so messages are sent from App1 to
an entity which can perform GTT and relay. For that communication SGP/ASP
procedures are used.

Let's suppose the node hosting App1 performs certain GTT functions as well
and they are used for communication between App4/App5. In this case, again
SGP/ASP procedures will be used.

This, IMO allows a clean separation between interfaces used for different
purposes.