Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * DECnet       An implementation of the DECnet protocol suite for the LINUX
0004  *              operating system.  DECnet is implemented using the  BSD Socket
0005  *              interface as the means of communication with the user level.
0006  *
0007  *              DECnet Network Services Protocol (Output)
0008  *
0009  * Author:      Eduardo Marcelo Serrat <emserrat@geocities.com>
0010  *
0011  * Changes:
0012  *
0013  *    Steve Whitehouse:  Split into dn_nsp_in.c and dn_nsp_out.c from
0014  *                       original dn_nsp.c.
0015  *    Steve Whitehouse:  Updated to work with my new routing architecture.
0016  *    Steve Whitehouse:  Added changes from Eduardo Serrat's patches.
0017  *    Steve Whitehouse:  Now conninits have the "return" bit set.
0018  *    Steve Whitehouse:  Fixes to check alloc'd skbs are non NULL!
0019  *                       Moved output state machine into one function
0020  *    Steve Whitehouse:  New output state machine
0021  *         Paul Koning:  Connect Confirm message fix.
0022  *      Eduardo Serrat:  Fix to stop dn_nsp_do_disc() sending malformed packets.
0023  *    Steve Whitehouse:  dn_nsp_output() and friends needed a spring clean
0024  *    Steve Whitehouse:  Moved dn_nsp_send() in here from route.h
0025  */
0026 
0027 /******************************************************************************
0028     (c) 1995-1998 E.M. Serrat       emserrat@geocities.com
0029 
0030 *******************************************************************************/
0031 
0032 #include <linux/errno.h>
0033 #include <linux/types.h>
0034 #include <linux/socket.h>
0035 #include <linux/in.h>
0036 #include <linux/kernel.h>
0037 #include <linux/timer.h>
0038 #include <linux/string.h>
0039 #include <linux/sockios.h>
0040 #include <linux/net.h>
0041 #include <linux/netdevice.h>
0042 #include <linux/inet.h>
0043 #include <linux/route.h>
0044 #include <linux/slab.h>
0045 #include <net/sock.h>
0046 #include <linux/fcntl.h>
0047 #include <linux/mm.h>
0048 #include <linux/termios.h>
0049 #include <linux/interrupt.h>
0050 #include <linux/proc_fs.h>
0051 #include <linux/stat.h>
0052 #include <linux/init.h>
0053 #include <linux/poll.h>
0054 #include <linux/if_packet.h>
0055 #include <linux/jiffies.h>
0056 #include <net/neighbour.h>
0057 #include <net/dst.h>
0058 #include <net/flow.h>
0059 #include <net/dn.h>
0060 #include <net/dn_nsp.h>
0061 #include <net/dn_dev.h>
0062 #include <net/dn_route.h>
0063 
0064 
0065 static int nsp_backoff[NSP_MAXRXTSHIFT + 1] = { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };
0066 
0067 static void dn_nsp_send(struct sk_buff *skb)
0068 {
0069     struct sock *sk = skb->sk;
0070     struct dn_scp *scp = DN_SK(sk);
0071     struct dst_entry *dst;
0072     struct flowidn fld;
0073 
0074     skb_reset_transport_header(skb);
0075     scp->stamp = jiffies;
0076 
0077     dst = sk_dst_check(sk, 0);
0078     if (dst) {
0079 try_again:
0080         skb_dst_set(skb, dst);
0081         dst_output(&init_net, skb->sk, skb);
0082         return;
0083     }
0084 
0085     memset(&fld, 0, sizeof(fld));
0086     fld.flowidn_oif = sk->sk_bound_dev_if;
0087     fld.saddr = dn_saddr2dn(&scp->addr);
0088     fld.daddr = dn_saddr2dn(&scp->peer);
0089     dn_sk_ports_copy(&fld, scp);
0090     fld.flowidn_proto = DNPROTO_NSP;
0091     if (dn_route_output_sock(&sk->sk_dst_cache, &fld, sk, 0) == 0) {
0092         dst = sk_dst_get(sk);
0093         sk->sk_route_caps = dst->dev->features;
0094         goto try_again;
0095     }
0096 
0097     sk->sk_err = EHOSTUNREACH;
0098     if (!sock_flag(sk, SOCK_DEAD))
0099         sk->sk_state_change(sk);
0100 }
0101 
0102 
0103 /*
0104  * If sk == NULL, then we assume that we are supposed to be making
0105  * a routing layer skb. If sk != NULL, then we are supposed to be
0106  * creating an skb for the NSP layer.
0107  *
0108  * The eventual aim is for each socket to have a cached header size
0109  * for its outgoing packets, and to set hdr from this when sk != NULL.
0110  */
0111 struct sk_buff *dn_alloc_skb(struct sock *sk, int size, gfp_t pri)
0112 {
0113     struct sk_buff *skb;
0114     int hdr = 64;
0115 
0116     if ((skb = alloc_skb(size + hdr, pri)) == NULL)
0117         return NULL;
0118 
0119     skb->protocol = htons(ETH_P_DNA_RT);
0120     skb->pkt_type = PACKET_OUTGOING;
0121 
0122     if (sk)
0123         skb_set_owner_w(skb, sk);
0124 
0125     skb_reserve(skb, hdr);
0126 
0127     return skb;
0128 }
0129 
0130 /*
0131  * Calculate persist timer based upon the smoothed round
0132  * trip time and the variance. Backoff according to the
0133  * nsp_backoff[] array.
0134  */
0135 unsigned long dn_nsp_persist(struct sock *sk)
0136 {
0137     struct dn_scp *scp = DN_SK(sk);
0138 
0139     unsigned long t = ((scp->nsp_srtt >> 2) + scp->nsp_rttvar) >> 1;
0140 
0141     t *= nsp_backoff[scp->nsp_rxtshift];
0142 
0143     if (t < HZ) t = HZ;
0144     if (t > (600*HZ)) t = (600*HZ);
0145 
0146     if (scp->nsp_rxtshift < NSP_MAXRXTSHIFT)
0147         scp->nsp_rxtshift++;
0148 
0149     /* printk(KERN_DEBUG "rxtshift %lu, t=%lu\n", scp->nsp_rxtshift, t); */
0150 
0151     return t;
0152 }
0153 
0154 /*
0155  * This is called each time we get an estimate for the rtt
0156  * on the link.
0157  */
0158 static void dn_nsp_rtt(struct sock *sk, long rtt)
0159 {
0160     struct dn_scp *scp = DN_SK(sk);
0161     long srtt = (long)scp->nsp_srtt;
0162     long rttvar = (long)scp->nsp_rttvar;
0163     long delta;
0164 
0165     /*
0166      * If the jiffies clock flips over in the middle of timestamp
0167      * gathering this value might turn out negative, so we make sure
0168      * that is it always positive here.
0169      */
0170     if (rtt < 0)
0171         rtt = -rtt;
0172     /*
0173      * Add new rtt to smoothed average
0174      */
0175     delta = ((rtt << 3) - srtt);
0176     srtt += (delta >> 3);
0177     if (srtt >= 1)
0178         scp->nsp_srtt = (unsigned long)srtt;
0179     else
0180         scp->nsp_srtt = 1;
0181 
0182     /*
0183      * Add new rtt variance to smoothed varience
0184      */
0185     delta >>= 1;
0186     rttvar += ((((delta>0)?(delta):(-delta)) - rttvar) >> 2);
0187     if (rttvar >= 1)
0188         scp->nsp_rttvar = (unsigned long)rttvar;
0189     else
0190         scp->nsp_rttvar = 1;
0191 
0192     /* printk(KERN_DEBUG "srtt=%lu rttvar=%lu\n", scp->nsp_srtt, scp->nsp_rttvar); */
0193 }
0194 
0195 /**
0196  * dn_nsp_clone_and_send - Send a data packet by cloning it
0197  * @skb: The packet to clone and transmit
0198  * @gfp: memory allocation flag
0199  *
0200  * Clone a queued data or other data packet and transmit it.
0201  *
0202  * Returns: The number of times the packet has been sent previously
0203  */
0204 static inline unsigned int dn_nsp_clone_and_send(struct sk_buff *skb,
0205                          gfp_t gfp)
0206 {
0207     struct dn_skb_cb *cb = DN_SKB_CB(skb);
0208     struct sk_buff *skb2;
0209     int ret = 0;
0210 
0211     if ((skb2 = skb_clone(skb, gfp)) != NULL) {
0212         ret = cb->xmit_count;
0213         cb->xmit_count++;
0214         cb->stamp = jiffies;
0215         skb2->sk = skb->sk;
0216         dn_nsp_send(skb2);
0217     }
0218 
0219     return ret;
0220 }
0221 
0222 /**
0223  * dn_nsp_output - Try and send something from socket queues
0224  * @sk: The socket whose queues are to be investigated
0225  *
0226  * Try and send the packet on the end of the data and other data queues.
0227  * Other data gets priority over data, and if we retransmit a packet we
0228  * reduce the window by dividing it in two.
0229  *
0230  */
0231 void dn_nsp_output(struct sock *sk)
0232 {
0233     struct dn_scp *scp = DN_SK(sk);
0234     struct sk_buff *skb;
0235     unsigned int reduce_win = 0;
0236 
0237     /*
0238      * First we check for otherdata/linkservice messages
0239      */
0240     if ((skb = skb_peek(&scp->other_xmit_queue)) != NULL)
0241         reduce_win = dn_nsp_clone_and_send(skb, GFP_ATOMIC);
0242 
0243     /*
0244      * If we may not send any data, we don't.
0245      * If we are still trying to get some other data down the
0246      * channel, we don't try and send any data.
0247      */
0248     if (reduce_win || (scp->flowrem_sw != DN_SEND))
0249         goto recalc_window;
0250 
0251     if ((skb = skb_peek(&scp->data_xmit_queue)) != NULL)
0252         reduce_win = dn_nsp_clone_and_send(skb, GFP_ATOMIC);
0253 
0254     /*
0255      * If we've sent any frame more than once, we cut the
0256      * send window size in half. There is always a minimum
0257      * window size of one available.
0258      */
0259 recalc_window:
0260     if (reduce_win) {
0261         scp->snd_window >>= 1;
0262         if (scp->snd_window < NSP_MIN_WINDOW)
0263             scp->snd_window = NSP_MIN_WINDOW;
0264     }
0265 }
0266 
0267 int dn_nsp_xmit_timeout(struct sock *sk)
0268 {
0269     struct dn_scp *scp = DN_SK(sk);
0270 
0271     dn_nsp_output(sk);
0272 
0273     if (!skb_queue_empty(&scp->data_xmit_queue) ||
0274         !skb_queue_empty(&scp->other_xmit_queue))
0275         scp->persist = dn_nsp_persist(sk);
0276 
0277     return 0;
0278 }
0279 
0280 static inline __le16 *dn_mk_common_header(struct dn_scp *scp, struct sk_buff *skb, unsigned char msgflag, int len)
0281 {
0282     unsigned char *ptr = skb_push(skb, len);
0283 
0284     BUG_ON(len < 5);
0285 
0286     *ptr++ = msgflag;
0287     *((__le16 *)ptr) = scp->addrrem;
0288     ptr += 2;
0289     *((__le16 *)ptr) = scp->addrloc;
0290     ptr += 2;
0291     return (__le16 __force *)ptr;
0292 }
0293 
0294 static __le16 *dn_mk_ack_header(struct sock *sk, struct sk_buff *skb, unsigned char msgflag, int hlen, int other)
0295 {
0296     struct dn_scp *scp = DN_SK(sk);
0297     unsigned short acknum = scp->numdat_rcv & 0x0FFF;
0298     unsigned short ackcrs = scp->numoth_rcv & 0x0FFF;
0299     __le16 *ptr;
0300 
0301     BUG_ON(hlen < 9);
0302 
0303     scp->ackxmt_dat = acknum;
0304     scp->ackxmt_oth = ackcrs;
0305     acknum |= 0x8000;
0306     ackcrs |= 0x8000;
0307 
0308     /* If this is an "other data/ack" message, swap acknum and ackcrs */
0309     if (other)
0310         swap(acknum, ackcrs);
0311 
0312     /* Set "cross subchannel" bit in ackcrs */
0313     ackcrs |= 0x2000;
0314 
0315     ptr = dn_mk_common_header(scp, skb, msgflag, hlen);
0316 
0317     *ptr++ = cpu_to_le16(acknum);
0318     *ptr++ = cpu_to_le16(ackcrs);
0319 
0320     return ptr;
0321 }
0322 
0323 static __le16 *dn_nsp_mk_data_header(struct sock *sk, struct sk_buff *skb, int oth)
0324 {
0325     struct dn_scp *scp = DN_SK(sk);
0326     struct dn_skb_cb *cb = DN_SKB_CB(skb);
0327     __le16 *ptr = dn_mk_ack_header(sk, skb, cb->nsp_flags, 11, oth);
0328 
0329     if (unlikely(oth)) {
0330         cb->segnum = scp->numoth;
0331         seq_add(&scp->numoth, 1);
0332     } else {
0333         cb->segnum = scp->numdat;
0334         seq_add(&scp->numdat, 1);
0335     }
0336     *(ptr++) = cpu_to_le16(cb->segnum);
0337 
0338     return ptr;
0339 }
0340 
0341 void dn_nsp_queue_xmit(struct sock *sk, struct sk_buff *skb,
0342             gfp_t gfp, int oth)
0343 {
0344     struct dn_scp *scp = DN_SK(sk);
0345     struct dn_skb_cb *cb = DN_SKB_CB(skb);
0346     unsigned long t = ((scp->nsp_srtt >> 2) + scp->nsp_rttvar) >> 1;
0347 
0348     cb->xmit_count = 0;
0349     dn_nsp_mk_data_header(sk, skb, oth);
0350 
0351     /*
0352      * Slow start: If we have been idle for more than
0353      * one RTT, then reset window to min size.
0354      */
0355     if (time_is_before_jiffies(scp->stamp + t))
0356         scp->snd_window = NSP_MIN_WINDOW;
0357 
0358     if (oth)
0359         skb_queue_tail(&scp->other_xmit_queue, skb);
0360     else
0361         skb_queue_tail(&scp->data_xmit_queue, skb);
0362 
0363     if (scp->flowrem_sw != DN_SEND)
0364         return;
0365 
0366     dn_nsp_clone_and_send(skb, gfp);
0367 }
0368 
0369 
0370 int dn_nsp_check_xmit_queue(struct sock *sk, struct sk_buff *skb, struct sk_buff_head *q, unsigned short acknum)
0371 {
0372     struct dn_skb_cb *cb = DN_SKB_CB(skb);
0373     struct dn_scp *scp = DN_SK(sk);
0374     struct sk_buff *skb2, *n, *ack = NULL;
0375     int wakeup = 0;
0376     int try_retrans = 0;
0377     unsigned long reftime = cb->stamp;
0378     unsigned long pkttime;
0379     unsigned short xmit_count;
0380     unsigned short segnum;
0381 
0382     skb_queue_walk_safe(q, skb2, n) {
0383         struct dn_skb_cb *cb2 = DN_SKB_CB(skb2);
0384 
0385         if (dn_before_or_equal(cb2->segnum, acknum))
0386             ack = skb2;
0387 
0388         /* printk(KERN_DEBUG "ack: %s %04x %04x\n", ack ? "ACK" : "SKIP", (int)cb2->segnum, (int)acknum); */
0389 
0390         if (ack == NULL)
0391             continue;
0392 
0393         /* printk(KERN_DEBUG "check_xmit_queue: %04x, %d\n", acknum, cb2->xmit_count); */
0394 
0395         /* Does _last_ packet acked have xmit_count > 1 */
0396         try_retrans = 0;
0397         /* Remember to wake up the sending process */
0398         wakeup = 1;
0399         /* Keep various statistics */
0400         pkttime = cb2->stamp;
0401         xmit_count = cb2->xmit_count;
0402         segnum = cb2->segnum;
0403         /* Remove and drop ack'ed packet */
0404         skb_unlink(ack, q);
0405         kfree_skb(ack);
0406         ack = NULL;
0407 
0408         /*
0409          * We don't expect to see acknowledgements for packets we
0410          * haven't sent yet.
0411          */
0412         WARN_ON(xmit_count == 0);
0413 
0414         /*
0415          * If the packet has only been sent once, we can use it
0416          * to calculate the RTT and also open the window a little
0417          * further.
0418          */
0419         if (xmit_count == 1) {
0420             if (dn_equal(segnum, acknum))
0421                 dn_nsp_rtt(sk, (long)(pkttime - reftime));
0422 
0423             if (scp->snd_window < scp->max_window)
0424                 scp->snd_window++;
0425         }
0426 
0427         /*
0428          * Packet has been sent more than once. If this is the last
0429          * packet to be acknowledged then we want to send the next
0430          * packet in the send queue again (assumes the remote host does
0431          * go-back-N error control).
0432          */
0433         if (xmit_count > 1)
0434             try_retrans = 1;
0435     }
0436 
0437     if (try_retrans)
0438         dn_nsp_output(sk);
0439 
0440     return wakeup;
0441 }
0442 
0443 void dn_nsp_send_data_ack(struct sock *sk)
0444 {
0445     struct sk_buff *skb = NULL;
0446 
0447     if ((skb = dn_alloc_skb(sk, 9, GFP_ATOMIC)) == NULL)
0448         return;
0449 
0450     skb_reserve(skb, 9);
0451     dn_mk_ack_header(sk, skb, 0x04, 9, 0);
0452     dn_nsp_send(skb);
0453 }
0454 
0455 void dn_nsp_send_oth_ack(struct sock *sk)
0456 {
0457     struct sk_buff *skb = NULL;
0458 
0459     if ((skb = dn_alloc_skb(sk, 9, GFP_ATOMIC)) == NULL)
0460         return;
0461 
0462     skb_reserve(skb, 9);
0463     dn_mk_ack_header(sk, skb, 0x14, 9, 1);
0464     dn_nsp_send(skb);
0465 }
0466 
0467 
0468 void dn_send_conn_ack (struct sock *sk)
0469 {
0470     struct dn_scp *scp = DN_SK(sk);
0471     struct sk_buff *skb = NULL;
0472     struct nsp_conn_ack_msg *msg;
0473 
0474     if ((skb = dn_alloc_skb(sk, 3, sk->sk_allocation)) == NULL)
0475         return;
0476 
0477     msg = skb_put(skb, 3);
0478     msg->msgflg = 0x24;
0479     msg->dstaddr = scp->addrrem;
0480 
0481     dn_nsp_send(skb);
0482 }
0483 
0484 static int dn_nsp_retrans_conn_conf(struct sock *sk)
0485 {
0486     struct dn_scp *scp = DN_SK(sk);
0487 
0488     if (scp->state == DN_CC)
0489         dn_send_conn_conf(sk, GFP_ATOMIC);
0490 
0491     return 0;
0492 }
0493 
0494 void dn_send_conn_conf(struct sock *sk, gfp_t gfp)
0495 {
0496     struct dn_scp *scp = DN_SK(sk);
0497     struct sk_buff *skb = NULL;
0498     struct nsp_conn_init_msg *msg;
0499     __u8 len = (__u8)le16_to_cpu(scp->conndata_out.opt_optl);
0500 
0501     if ((skb = dn_alloc_skb(sk, 50 + len, gfp)) == NULL)
0502         return;
0503 
0504     msg = skb_put(skb, sizeof(*msg));
0505     msg->msgflg = 0x28;
0506     msg->dstaddr = scp->addrrem;
0507     msg->srcaddr = scp->addrloc;
0508     msg->services = scp->services_loc;
0509     msg->info = scp->info_loc;
0510     msg->segsize = cpu_to_le16(scp->segsize_loc);
0511 
0512     skb_put_u8(skb, len);
0513 
0514     if (len > 0)
0515         skb_put_data(skb, scp->conndata_out.opt_data, len);
0516 
0517 
0518     dn_nsp_send(skb);
0519 
0520     scp->persist = dn_nsp_persist(sk);
0521     scp->persist_fxn = dn_nsp_retrans_conn_conf;
0522 }
0523 
0524 
0525 static __inline__ void dn_nsp_do_disc(struct sock *sk, unsigned char msgflg,
0526             unsigned short reason, gfp_t gfp,
0527             struct dst_entry *dst,
0528             int ddl, unsigned char *dd, __le16 rem, __le16 loc)
0529 {
0530     struct sk_buff *skb = NULL;
0531     int size = 7 + ddl + ((msgflg == NSP_DISCINIT) ? 1 : 0);
0532     unsigned char *msg;
0533 
0534     if ((dst == NULL) || (rem == 0)) {
0535         net_dbg_ratelimited("DECnet: dn_nsp_do_disc: BUG! Please report this to SteveW@ACM.org rem=%u dst=%p\n",
0536                     le16_to_cpu(rem), dst);
0537         return;
0538     }
0539 
0540     if ((skb = dn_alloc_skb(sk, size, gfp)) == NULL)
0541         return;
0542 
0543     msg = skb_put(skb, size);
0544     *msg++ = msgflg;
0545     *(__le16 *)msg = rem;
0546     msg += 2;
0547     *(__le16 *)msg = loc;
0548     msg += 2;
0549     *(__le16 *)msg = cpu_to_le16(reason);
0550     msg += 2;
0551     if (msgflg == NSP_DISCINIT)
0552         *msg++ = ddl;
0553 
0554     if (ddl) {
0555         memcpy(msg, dd, ddl);
0556     }
0557 
0558     /*
0559      * This doesn't go via the dn_nsp_send() function since we need
0560      * to be able to send disc packets out which have no socket
0561      * associations.
0562      */
0563     skb_dst_set(skb, dst_clone(dst));
0564     dst_output(&init_net, skb->sk, skb);
0565 }
0566 
0567 
0568 void dn_nsp_send_disc(struct sock *sk, unsigned char msgflg,
0569             unsigned short reason, gfp_t gfp)
0570 {
0571     struct dn_scp *scp = DN_SK(sk);
0572     int ddl = 0;
0573 
0574     if (msgflg == NSP_DISCINIT)
0575         ddl = le16_to_cpu(scp->discdata_out.opt_optl);
0576 
0577     if (reason == 0)
0578         reason = le16_to_cpu(scp->discdata_out.opt_status);
0579 
0580     dn_nsp_do_disc(sk, msgflg, reason, gfp, __sk_dst_get(sk), ddl,
0581         scp->discdata_out.opt_data, scp->addrrem, scp->addrloc);
0582 }
0583 
0584 
0585 void dn_nsp_return_disc(struct sk_buff *skb, unsigned char msgflg,
0586             unsigned short reason)
0587 {
0588     struct dn_skb_cb *cb = DN_SKB_CB(skb);
0589     int ddl = 0;
0590     gfp_t gfp = GFP_ATOMIC;
0591 
0592     dn_nsp_do_disc(NULL, msgflg, reason, gfp, skb_dst(skb), ddl,
0593             NULL, cb->src_port, cb->dst_port);
0594 }
0595 
0596 
0597 void dn_nsp_send_link(struct sock *sk, unsigned char lsflags, char fcval)
0598 {
0599     struct dn_scp *scp = DN_SK(sk);
0600     struct sk_buff *skb;
0601     unsigned char *ptr;
0602     gfp_t gfp = GFP_ATOMIC;
0603 
0604     if ((skb = dn_alloc_skb(sk, DN_MAX_NSP_DATA_HEADER + 2, gfp)) == NULL)
0605         return;
0606 
0607     skb_reserve(skb, DN_MAX_NSP_DATA_HEADER);
0608     ptr = skb_put(skb, 2);
0609     DN_SKB_CB(skb)->nsp_flags = 0x10;
0610     *ptr++ = lsflags;
0611     *ptr = fcval;
0612 
0613     dn_nsp_queue_xmit(sk, skb, gfp, 1);
0614 
0615     scp->persist = dn_nsp_persist(sk);
0616     scp->persist_fxn = dn_nsp_xmit_timeout;
0617 }
0618 
0619 static int dn_nsp_retrans_conninit(struct sock *sk)
0620 {
0621     struct dn_scp *scp = DN_SK(sk);
0622 
0623     if (scp->state == DN_CI)
0624         dn_nsp_send_conninit(sk, NSP_RCI);
0625 
0626     return 0;
0627 }
0628 
0629 void dn_nsp_send_conninit(struct sock *sk, unsigned char msgflg)
0630 {
0631     struct dn_scp *scp = DN_SK(sk);
0632     struct nsp_conn_init_msg *msg;
0633     unsigned char aux;
0634     unsigned char menuver;
0635     struct dn_skb_cb *cb;
0636     unsigned char type = 1;
0637     gfp_t allocation = (msgflg == NSP_CI) ? sk->sk_allocation : GFP_ATOMIC;
0638     struct sk_buff *skb = dn_alloc_skb(sk, 200, allocation);
0639 
0640     if (!skb)
0641         return;
0642 
0643     cb  = DN_SKB_CB(skb);
0644     msg = skb_put(skb, sizeof(*msg));
0645 
0646     msg->msgflg = msgflg;
0647     msg->dstaddr    = 0x0000;       /* Remote Node will assign it*/
0648 
0649     msg->srcaddr    = scp->addrloc;
0650     msg->services   = scp->services_loc;    /* Requested flow control    */
0651     msg->info   = scp->info_loc;    /* Version Number            */
0652     msg->segsize    = cpu_to_le16(scp->segsize_loc);    /* Max segment size  */
0653 
0654     if (scp->peer.sdn_objnum)
0655         type = 0;
0656 
0657     skb_put(skb, dn_sockaddr2username(&scp->peer,
0658                       skb_tail_pointer(skb), type));
0659     skb_put(skb, dn_sockaddr2username(&scp->addr,
0660                       skb_tail_pointer(skb), 2));
0661 
0662     menuver = DN_MENUVER_ACC | DN_MENUVER_USR;
0663     if (scp->peer.sdn_flags & SDF_PROXY)
0664         menuver |= DN_MENUVER_PRX;
0665     if (scp->peer.sdn_flags & SDF_UICPROXY)
0666         menuver |= DN_MENUVER_UIC;
0667 
0668     skb_put_u8(skb, menuver);   /* Menu Version     */
0669 
0670     aux = scp->accessdata.acc_userl;
0671     skb_put_u8(skb, aux);
0672     if (aux > 0)
0673         skb_put_data(skb, scp->accessdata.acc_user, aux);
0674 
0675     aux = scp->accessdata.acc_passl;
0676     skb_put_u8(skb, aux);
0677     if (aux > 0)
0678         skb_put_data(skb, scp->accessdata.acc_pass, aux);
0679 
0680     aux = scp->accessdata.acc_accl;
0681     skb_put_u8(skb, aux);
0682     if (aux > 0)
0683         skb_put_data(skb, scp->accessdata.acc_acc, aux);
0684 
0685     aux = (__u8)le16_to_cpu(scp->conndata_out.opt_optl);
0686     skb_put_u8(skb, aux);
0687     if (aux > 0)
0688         skb_put_data(skb, scp->conndata_out.opt_data, aux);
0689 
0690     scp->persist = dn_nsp_persist(sk);
0691     scp->persist_fxn = dn_nsp_retrans_conninit;
0692 
0693     cb->rt_flags = DN_RT_F_RQR;
0694 
0695     dn_nsp_send(skb);
0696 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!