[X25]: Fast select with no restriction on response

This patch is a follow up to patch 1 regarding "Selective Sub Address
matching with call user data".  It allows use of the Fast-Select-Acceptance
optional user facility for X.25.

This patch just implements fast select with no restriction on response
(NRR).  What this means (according to ITU-T Recomendation 10/96 section
6.16) is that if in an incoming call packet, the relevant facility bits are
set for fast-select-NRR, then the called DTE can issue a direct response to
the incoming packet using a call-accepted packet that contains
call-user-data.  This patch allows such a response.  

The called DTE can also respond with a clear-request packet that contains
call-user-data.  However, this feature is currently not implemented by the
patch.

How is Fast Select Acceptance used?
By default, the system does not allow fast select acceptance (as before).
To enable a response to fast select acceptance,  
After a listen socket in created and bound as follows
	socket(AF_X25, SOCK_SEQPACKET, 0);
	bind(call_soc, (struct sockaddr *)&locl_addr, sizeof(locl_addr));
but before a listen system call is made, the following ioctl should be used.
	ioctl(call_soc,SIOCX25CALLACCPTAPPRV);
Now the listen system call can be made
	listen(call_soc, 4);
After this, an incoming-call packet will be accepted, but no call-accepted 
packet will be sent back until the following system call is made on the socket
that accepts the call
	ioctl(vc_soc,SIOCX25SENDCALLACCPT);
The network (or cisco xot router used for testing here) will allow the 
application server's call-user-data in the call-accepted packet, 
provided the call-request was made with Fast-select NRR.

Signed-off-by: Shaun Pereira <spereira@tusc.com.au>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 29 insertions, 5 deletions

diff --git a/net/x25/x25_facilities.c b/net/x25/x25_facilities.c
index a21bdb95f9a8..54278b962f4c 100644
--- a/net/x25/x25_facilities.c
+++ b/net/x25/x25_facilities.c
@@ -17,6 +17,8 @@
  *      X.25 001        Split from x25_subr.c
  *      mar/20/00       Daniela Squassoni Disabling/enabling of facilities 
  *                                        negotiation.
+ *      apr/14/05       Shaun Pereira - Allow fast select with no restriction
+ *                                      on response.
  */
 
 #include <linux/kernel.h>
@@ -43,9 +45,31 @@ int x25_parse_facilities(struct sk_buff *skb,
                 case X25_FAC_CLASS_A:
                         switch (*p) {
                         case X25_FAC_REVERSE:
-                                facilities->reverse = p[1] & 0x01;
-                                *vc_fac_mask |= X25_MASK_REVERSE;
-                                break;
+                                if((p[1] & 0x81) == 0x81) {
+                                        facilities->reverse = p[1] & 0x81;
+                                        *vc_fac_mask |= X25_MASK_REVERSE;
+                                        break;
+                                }
+
+                                if((p[1] & 0x01) == 0x01) {
+                                        facilities->reverse = p[1] & 0x01;
+                                        *vc_fac_mask |= X25_MASK_REVERSE;
+                                        break;
+                                }
+
+                                if((p[1] & 0x80) == 0x80) {
+                                        facilities->reverse = p[1] & 0x80;
+                                        *vc_fac_mask |= X25_MASK_REVERSE;
+                                        break;
+                                }
+
+                                if(p[1] == 0x00) {
+                                        facilities->reverse
+                                                = X25_DEFAULT_REVERSE;
+                                        *vc_fac_mask |= X25_MASK_REVERSE;
+                                        break;
+                                }
+
                         case X25_FAC_THROUGHPUT:
                                 facilities->throughput = p[1];
                                 *vc_fac_mask |= X25_MASK_THROUGHPUT;
@@ -122,7 +146,7 @@ int x25_create_facilities(unsigned char *buffer,
 
         if (facilities->reverse && (facil_mask & X25_MASK_REVERSE)) {
                 *p++ = X25_FAC_REVERSE;
-                *p++ = !!facilities->reverse;
+                *p++ = facilities->reverse;
         }
 
         if (facilities->throughput && (facil_mask & X25_MASK_THROUGHPUT)) {
@@ -171,7 +195,7 @@ int x25_negotiate_facilities(struct sk_buff *skb, struct sock *sk,
         /*
          *      They want reverse charging, we won't accept it.
          */
-        if (theirs.reverse && ours->reverse) {
+        if ((theirs.reverse & 0x01 ) && (ours->reverse & 0x01)) {
                 SOCK_DEBUG(sk, "X.25: rejecting reverse charging request");
                 return -1;
         }