dn_nsp_out.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722
  1. /*
  2. * DECnet An implementation of the DECnet protocol suite for the LINUX
  3. * operating system. DECnet is implemented using the BSD Socket
  4. * interface as the means of communication with the user level.
  5. *
  6. * DECnet Network Services Protocol (Output)
  7. *
  8. * Author: Eduardo Marcelo Serrat <emserrat@geocities.com>
  9. *
  10. * Changes:
  11. *
  12. * Steve Whitehouse: Split into dn_nsp_in.c and dn_nsp_out.c from
  13. * original dn_nsp.c.
  14. * Steve Whitehouse: Updated to work with my new routing architecture.
  15. * Steve Whitehouse: Added changes from Eduardo Serrat's patches.
  16. * Steve Whitehouse: Now conninits have the "return" bit set.
  17. * Steve Whitehouse: Fixes to check alloc'd skbs are non NULL!
  18. * Moved output state machine into one function
  19. * Steve Whitehouse: New output state machine
  20. * Paul Koning: Connect Confirm message fix.
  21. * Eduardo Serrat: Fix to stop dn_nsp_do_disc() sending malformed packets.
  22. * Steve Whitehouse: dn_nsp_output() and friends needed a spring clean
  23. * Steve Whitehouse: Moved dn_nsp_send() in here from route.h
  24. */
  25. /******************************************************************************
  26. (c) 1995-1998 E.M. Serrat emserrat@geocities.com
  27. This program is free software; you can redistribute it and/or modify
  28. it under the terms of the GNU General Public License as published by
  29. the Free Software Foundation; either version 2 of the License, or
  30. any later version.
  31. This program is distributed in the hope that it will be useful,
  32. but WITHOUT ANY WARRANTY; without even the implied warranty of
  33. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  34. GNU General Public License for more details.
  35. *******************************************************************************/
  36. #include <linux/errno.h>
  37. #include <linux/types.h>
  38. #include <linux/socket.h>
  39. #include <linux/in.h>
  40. #include <linux/kernel.h>
  41. #include <linux/timer.h>
  42. #include <linux/string.h>
  43. #include <linux/sockios.h>
  44. #include <linux/net.h>
  45. #include <linux/netdevice.h>
  46. #include <linux/inet.h>
  47. #include <linux/route.h>
  48. #include <net/sock.h>
  49. #include <asm/system.h>
  50. #include <linux/fcntl.h>
  51. #include <linux/mm.h>
  52. #include <linux/termios.h>
  53. #include <linux/interrupt.h>
  54. #include <linux/proc_fs.h>
  55. #include <linux/stat.h>
  56. #include <linux/init.h>
  57. #include <linux/poll.h>
  58. #include <linux/if_packet.h>
  59. #include <net/neighbour.h>
  60. #include <net/dst.h>
  61. #include <net/flow.h>
  62. #include <net/dn.h>
  63. #include <net/dn_nsp.h>
  64. #include <net/dn_dev.h>
  65. #include <net/dn_route.h>
  66. static int nsp_backoff[NSP_MAXRXTSHIFT + 1] = { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };
  67. static void dn_nsp_send(struct sk_buff *skb)
  68. {
  69. struct sock *sk = skb->sk;
  70. struct dn_scp *scp = DN_SK(sk);
  71. struct dst_entry *dst;
  72. struct flowi fl;
  73. skb->h.raw = skb->data;
  74. scp->stamp = jiffies;
  75. dst = sk_dst_check(sk, 0);
  76. if (dst) {
  77. try_again:
  78. skb->dst = dst;
  79. dst_output(skb);
  80. return;
  81. }
  82. memset(&fl, 0, sizeof(fl));
  83. fl.oif = sk->sk_bound_dev_if;
  84. fl.fld_src = dn_saddr2dn(&scp->addr);
  85. fl.fld_dst = dn_saddr2dn(&scp->peer);
  86. dn_sk_ports_copy(&fl, scp);
  87. fl.proto = DNPROTO_NSP;
  88. if (dn_route_output_sock(&sk->sk_dst_cache, &fl, sk, 0) == 0) {
  89. dst = sk_dst_get(sk);
  90. sk->sk_route_caps = dst->dev->features;
  91. goto try_again;
  92. }
  93. sk->sk_err = EHOSTUNREACH;
  94. if (!sock_flag(sk, SOCK_DEAD))
  95. sk->sk_state_change(sk);
  96. }
  97. /*
  98. * If sk == NULL, then we assume that we are supposed to be making
  99. * a routing layer skb. If sk != NULL, then we are supposed to be
  100. * creating an skb for the NSP layer.
  101. *
  102. * The eventual aim is for each socket to have a cached header size
  103. * for its outgoing packets, and to set hdr from this when sk != NULL.
  104. */
  105. struct sk_buff *dn_alloc_skb(struct sock *sk, int size, gfp_t pri)
  106. {
  107. struct sk_buff *skb;
  108. int hdr = 64;
  109. if ((skb = alloc_skb(size + hdr, pri)) == NULL)
  110. return NULL;
  111. skb->protocol = __constant_htons(ETH_P_DNA_RT);
  112. skb->pkt_type = PACKET_OUTGOING;
  113. if (sk)
  114. skb_set_owner_w(skb, sk);
  115. skb_reserve(skb, hdr);
  116. return skb;
  117. }
  118. /*
  119. * Calculate persist timer based upon the smoothed round
  120. * trip time and the variance. Backoff according to the
  121. * nsp_backoff[] array.
  122. */
  123. unsigned long dn_nsp_persist(struct sock *sk)
  124. {
  125. struct dn_scp *scp = DN_SK(sk);
  126. unsigned long t = ((scp->nsp_srtt >> 2) + scp->nsp_rttvar) >> 1;
  127. t *= nsp_backoff[scp->nsp_rxtshift];
  128. if (t < HZ) t = HZ;
  129. if (t > (600*HZ)) t = (600*HZ);
  130. if (scp->nsp_rxtshift < NSP_MAXRXTSHIFT)
  131. scp->nsp_rxtshift++;
  132. /* printk(KERN_DEBUG "rxtshift %lu, t=%lu\n", scp->nsp_rxtshift, t); */
  133. return t;
  134. }
  135. /*
  136. * This is called each time we get an estimate for the rtt
  137. * on the link.
  138. */
  139. static void dn_nsp_rtt(struct sock *sk, long rtt)
  140. {
  141. struct dn_scp *scp = DN_SK(sk);
  142. long srtt = (long)scp->nsp_srtt;
  143. long rttvar = (long)scp->nsp_rttvar;
  144. long delta;
  145. /*
  146. * If the jiffies clock flips over in the middle of timestamp
  147. * gathering this value might turn out negative, so we make sure
  148. * that is it always positive here.
  149. */
  150. if (rtt < 0)
  151. rtt = -rtt;
  152. /*
  153. * Add new rtt to smoothed average
  154. */
  155. delta = ((rtt << 3) - srtt);
  156. srtt += (delta >> 3);
  157. if (srtt >= 1)
  158. scp->nsp_srtt = (unsigned long)srtt;
  159. else
  160. scp->nsp_srtt = 1;
  161. /*
  162. * Add new rtt varience to smoothed varience
  163. */
  164. delta >>= 1;
  165. rttvar += ((((delta>0)?(delta):(-delta)) - rttvar) >> 2);
  166. if (rttvar >= 1)
  167. scp->nsp_rttvar = (unsigned long)rttvar;
  168. else
  169. scp->nsp_rttvar = 1;
  170. /* printk(KERN_DEBUG "srtt=%lu rttvar=%lu\n", scp->nsp_srtt, scp->nsp_rttvar); */
  171. }
  172. /**
  173. * dn_nsp_clone_and_send - Send a data packet by cloning it
  174. * @skb: The packet to clone and transmit
  175. * @gfp: memory allocation flag
  176. *
  177. * Clone a queued data or other data packet and transmit it.
  178. *
  179. * Returns: The number of times the packet has been sent previously
  180. */
  181. static inline unsigned dn_nsp_clone_and_send(struct sk_buff *skb,
  182. gfp_t gfp)
  183. {
  184. struct dn_skb_cb *cb = DN_SKB_CB(skb);
  185. struct sk_buff *skb2;
  186. int ret = 0;
  187. if ((skb2 = skb_clone(skb, gfp)) != NULL) {
  188. ret = cb->xmit_count;
  189. cb->xmit_count++;
  190. cb->stamp = jiffies;
  191. skb2->sk = skb->sk;
  192. dn_nsp_send(skb2);
  193. }
  194. return ret;
  195. }
  196. /**
  197. * dn_nsp_output - Try and send something from socket queues
  198. * @sk: The socket whose queues are to be investigated
  199. * @gfp: The memory allocation flags
  200. *
  201. * Try and send the packet on the end of the data and other data queues.
  202. * Other data gets priority over data, and if we retransmit a packet we
  203. * reduce the window by dividing it in two.
  204. *
  205. */
  206. void dn_nsp_output(struct sock *sk)
  207. {
  208. struct dn_scp *scp = DN_SK(sk);
  209. struct sk_buff *skb;
  210. unsigned reduce_win = 0;
  211. /*
  212. * First we check for otherdata/linkservice messages
  213. */
  214. if ((skb = skb_peek(&scp->other_xmit_queue)) != NULL)
  215. reduce_win = dn_nsp_clone_and_send(skb, GFP_ATOMIC);
  216. /*
  217. * If we may not send any data, we don't.
  218. * If we are still trying to get some other data down the
  219. * channel, we don't try and send any data.
  220. */
  221. if (reduce_win || (scp->flowrem_sw != DN_SEND))
  222. goto recalc_window;
  223. if ((skb = skb_peek(&scp->data_xmit_queue)) != NULL)
  224. reduce_win = dn_nsp_clone_and_send(skb, GFP_ATOMIC);
  225. /*
  226. * If we've sent any frame more than once, we cut the
  227. * send window size in half. There is always a minimum
  228. * window size of one available.
  229. */
  230. recalc_window:
  231. if (reduce_win) {
  232. scp->snd_window >>= 1;
  233. if (scp->snd_window < NSP_MIN_WINDOW)
  234. scp->snd_window = NSP_MIN_WINDOW;
  235. }
  236. }
  237. int dn_nsp_xmit_timeout(struct sock *sk)
  238. {
  239. struct dn_scp *scp = DN_SK(sk);
  240. dn_nsp_output(sk);
  241. if (!skb_queue_empty(&scp->data_xmit_queue) ||
  242. !skb_queue_empty(&scp->other_xmit_queue))
  243. scp->persist = dn_nsp_persist(sk);
  244. return 0;
  245. }
  246. static inline __le16 *dn_mk_common_header(struct dn_scp *scp, struct sk_buff *skb, unsigned char msgflag, int len)
  247. {
  248. unsigned char *ptr = skb_push(skb, len);
  249. BUG_ON(len < 5);
  250. *ptr++ = msgflag;
  251. *((__le16 *)ptr) = scp->addrrem;
  252. ptr += 2;
  253. *((__le16 *)ptr) = scp->addrloc;
  254. ptr += 2;
  255. return (__le16 __force *)ptr;
  256. }
  257. static __le16 *dn_mk_ack_header(struct sock *sk, struct sk_buff *skb, unsigned char msgflag, int hlen, int other)
  258. {
  259. struct dn_scp *scp = DN_SK(sk);
  260. unsigned short acknum = scp->numdat_rcv & 0x0FFF;
  261. unsigned short ackcrs = scp->numoth_rcv & 0x0FFF;
  262. __le16 *ptr;
  263. BUG_ON(hlen < 9);
  264. scp->ackxmt_dat = acknum;
  265. scp->ackxmt_oth = ackcrs;
  266. acknum |= 0x8000;
  267. ackcrs |= 0x8000;
  268. /* If this is an "other data/ack" message, swap acknum and ackcrs */
  269. if (other) {
  270. unsigned short tmp = acknum;
  271. acknum = ackcrs;
  272. ackcrs = tmp;
  273. }
  274. /* Set "cross subchannel" bit in ackcrs */
  275. ackcrs |= 0x2000;
  276. ptr = (__le16 *)dn_mk_common_header(scp, skb, msgflag, hlen);
  277. *ptr++ = dn_htons(acknum);
  278. *ptr++ = dn_htons(ackcrs);
  279. return ptr;
  280. }
  281. static __le16 *dn_nsp_mk_data_header(struct sock *sk, struct sk_buff *skb, int oth)
  282. {
  283. struct dn_scp *scp = DN_SK(sk);
  284. struct dn_skb_cb *cb = DN_SKB_CB(skb);
  285. __le16 *ptr = dn_mk_ack_header(sk, skb, cb->nsp_flags, 11, oth);
  286. if (unlikely(oth)) {
  287. cb->segnum = scp->numoth;
  288. seq_add(&scp->numoth, 1);
  289. } else {
  290. cb->segnum = scp->numdat;
  291. seq_add(&scp->numdat, 1);
  292. }
  293. *(ptr++) = dn_htons(cb->segnum);
  294. return ptr;
  295. }
  296. void dn_nsp_queue_xmit(struct sock *sk, struct sk_buff *skb,
  297. gfp_t gfp, int oth)
  298. {
  299. struct dn_scp *scp = DN_SK(sk);
  300. struct dn_skb_cb *cb = DN_SKB_CB(skb);
  301. unsigned long t = ((scp->nsp_srtt >> 2) + scp->nsp_rttvar) >> 1;
  302. cb->xmit_count = 0;
  303. dn_nsp_mk_data_header(sk, skb, oth);
  304. /*
  305. * Slow start: If we have been idle for more than
  306. * one RTT, then reset window to min size.
  307. */
  308. if ((jiffies - scp->stamp) > t)
  309. scp->snd_window = NSP_MIN_WINDOW;
  310. if (oth)
  311. skb_queue_tail(&scp->other_xmit_queue, skb);
  312. else
  313. skb_queue_tail(&scp->data_xmit_queue, skb);
  314. if (scp->flowrem_sw != DN_SEND)
  315. return;
  316. dn_nsp_clone_and_send(skb, gfp);
  317. }
  318. int dn_nsp_check_xmit_queue(struct sock *sk, struct sk_buff *skb, struct sk_buff_head *q, unsigned short acknum)
  319. {
  320. struct dn_skb_cb *cb = DN_SKB_CB(skb);
  321. struct dn_scp *scp = DN_SK(sk);
  322. struct sk_buff *skb2, *list, *ack = NULL;
  323. int wakeup = 0;
  324. int try_retrans = 0;
  325. unsigned long reftime = cb->stamp;
  326. unsigned long pkttime;
  327. unsigned short xmit_count;
  328. unsigned short segnum;
  329. skb2 = q->next;
  330. list = (struct sk_buff *)q;
  331. while(list != skb2) {
  332. struct dn_skb_cb *cb2 = DN_SKB_CB(skb2);
  333. if (dn_before_or_equal(cb2->segnum, acknum))
  334. ack = skb2;
  335. /* printk(KERN_DEBUG "ack: %s %04x %04x\n", ack ? "ACK" : "SKIP", (int)cb2->segnum, (int)acknum); */
  336. skb2 = skb2->next;
  337. if (ack == NULL)
  338. continue;
  339. /* printk(KERN_DEBUG "check_xmit_queue: %04x, %d\n", acknum, cb2->xmit_count); */
  340. /* Does _last_ packet acked have xmit_count > 1 */
  341. try_retrans = 0;
  342. /* Remember to wake up the sending process */
  343. wakeup = 1;
  344. /* Keep various statistics */
  345. pkttime = cb2->stamp;
  346. xmit_count = cb2->xmit_count;
  347. segnum = cb2->segnum;
  348. /* Remove and drop ack'ed packet */
  349. skb_unlink(ack, q);
  350. kfree_skb(ack);
  351. ack = NULL;
  352. /*
  353. * We don't expect to see acknowledgements for packets we
  354. * haven't sent yet.
  355. */
  356. WARN_ON(xmit_count == 0);
  357. /*
  358. * If the packet has only been sent once, we can use it
  359. * to calculate the RTT and also open the window a little
  360. * further.
  361. */
  362. if (xmit_count == 1) {
  363. if (dn_equal(segnum, acknum))
  364. dn_nsp_rtt(sk, (long)(pkttime - reftime));
  365. if (scp->snd_window < scp->max_window)
  366. scp->snd_window++;
  367. }
  368. /*
  369. * Packet has been sent more than once. If this is the last
  370. * packet to be acknowledged then we want to send the next
  371. * packet in the send queue again (assumes the remote host does
  372. * go-back-N error control).
  373. */
  374. if (xmit_count > 1)
  375. try_retrans = 1;
  376. }
  377. if (try_retrans)
  378. dn_nsp_output(sk);
  379. return wakeup;
  380. }
  381. void dn_nsp_send_data_ack(struct sock *sk)
  382. {
  383. struct sk_buff *skb = NULL;
  384. if ((skb = dn_alloc_skb(sk, 9, GFP_ATOMIC)) == NULL)
  385. return;
  386. skb_reserve(skb, 9);
  387. dn_mk_ack_header(sk, skb, 0x04, 9, 0);
  388. dn_nsp_send(skb);
  389. }
  390. void dn_nsp_send_oth_ack(struct sock *sk)
  391. {
  392. struct sk_buff *skb = NULL;
  393. if ((skb = dn_alloc_skb(sk, 9, GFP_ATOMIC)) == NULL)
  394. return;
  395. skb_reserve(skb, 9);
  396. dn_mk_ack_header(sk, skb, 0x14, 9, 1);
  397. dn_nsp_send(skb);
  398. }
  399. void dn_send_conn_ack (struct sock *sk)
  400. {
  401. struct dn_scp *scp = DN_SK(sk);
  402. struct sk_buff *skb = NULL;
  403. struct nsp_conn_ack_msg *msg;
  404. if ((skb = dn_alloc_skb(sk, 3, sk->sk_allocation)) == NULL)
  405. return;
  406. msg = (struct nsp_conn_ack_msg *)skb_put(skb, 3);
  407. msg->msgflg = 0x24;
  408. msg->dstaddr = scp->addrrem;
  409. dn_nsp_send(skb);
  410. }
  411. void dn_nsp_delayed_ack(struct sock *sk)
  412. {
  413. struct dn_scp *scp = DN_SK(sk);
  414. if (scp->ackxmt_oth != scp->numoth_rcv)
  415. dn_nsp_send_oth_ack(sk);
  416. if (scp->ackxmt_dat != scp->numdat_rcv)
  417. dn_nsp_send_data_ack(sk);
  418. }
  419. static int dn_nsp_retrans_conn_conf(struct sock *sk)
  420. {
  421. struct dn_scp *scp = DN_SK(sk);
  422. if (scp->state == DN_CC)
  423. dn_send_conn_conf(sk, GFP_ATOMIC);
  424. return 0;
  425. }
  426. void dn_send_conn_conf(struct sock *sk, gfp_t gfp)
  427. {
  428. struct dn_scp *scp = DN_SK(sk);
  429. struct sk_buff *skb = NULL;
  430. struct nsp_conn_init_msg *msg;
  431. __u8 len = (__u8)dn_ntohs(scp->conndata_out.opt_optl);
  432. if ((skb = dn_alloc_skb(sk, 50 + len, gfp)) == NULL)
  433. return;
  434. msg = (struct nsp_conn_init_msg *)skb_put(skb, sizeof(*msg));
  435. msg->msgflg = 0x28;
  436. msg->dstaddr = scp->addrrem;
  437. msg->srcaddr = scp->addrloc;
  438. msg->services = scp->services_loc;
  439. msg->info = scp->info_loc;
  440. msg->segsize = dn_htons(scp->segsize_loc);
  441. *skb_put(skb,1) = len;
  442. if (len > 0)
  443. memcpy(skb_put(skb, len), scp->conndata_out.opt_data, len);
  444. dn_nsp_send(skb);
  445. scp->persist = dn_nsp_persist(sk);
  446. scp->persist_fxn = dn_nsp_retrans_conn_conf;
  447. }
  448. static __inline__ void dn_nsp_do_disc(struct sock *sk, unsigned char msgflg,
  449. unsigned short reason, gfp_t gfp,
  450. struct dst_entry *dst,
  451. int ddl, unsigned char *dd, __le16 rem, __le16 loc)
  452. {
  453. struct sk_buff *skb = NULL;
  454. int size = 7 + ddl + ((msgflg == NSP_DISCINIT) ? 1 : 0);
  455. unsigned char *msg;
  456. if ((dst == NULL) || (rem == 0)) {
  457. if (net_ratelimit())
  458. printk(KERN_DEBUG "DECnet: dn_nsp_do_disc: BUG! Please report this to SteveW@ACM.org rem=%u dst=%p\n", dn_ntohs(rem), dst);
  459. return;
  460. }
  461. if ((skb = dn_alloc_skb(sk, size, gfp)) == NULL)
  462. return;
  463. msg = skb_put(skb, size);
  464. *msg++ = msgflg;
  465. *(__le16 *)msg = rem;
  466. msg += 2;
  467. *(__le16 *)msg = loc;
  468. msg += 2;
  469. *(__le16 *)msg = dn_htons(reason);
  470. msg += 2;
  471. if (msgflg == NSP_DISCINIT)
  472. *msg++ = ddl;
  473. if (ddl) {
  474. memcpy(msg, dd, ddl);
  475. }
  476. /*
  477. * This doesn't go via the dn_nsp_send() function since we need
  478. * to be able to send disc packets out which have no socket
  479. * associations.
  480. */
  481. skb->dst = dst_clone(dst);
  482. dst_output(skb);
  483. }
  484. void dn_nsp_send_disc(struct sock *sk, unsigned char msgflg,
  485. unsigned short reason, gfp_t gfp)
  486. {
  487. struct dn_scp *scp = DN_SK(sk);
  488. int ddl = 0;
  489. if (msgflg == NSP_DISCINIT)
  490. ddl = dn_ntohs(scp->discdata_out.opt_optl);
  491. if (reason == 0)
  492. reason = dn_ntohs(scp->discdata_out.opt_status);
  493. dn_nsp_do_disc(sk, msgflg, reason, gfp, sk->sk_dst_cache, ddl,
  494. scp->discdata_out.opt_data, scp->addrrem, scp->addrloc);
  495. }
  496. void dn_nsp_return_disc(struct sk_buff *skb, unsigned char msgflg,
  497. unsigned short reason)
  498. {
  499. struct dn_skb_cb *cb = DN_SKB_CB(skb);
  500. int ddl = 0;
  501. gfp_t gfp = GFP_ATOMIC;
  502. dn_nsp_do_disc(NULL, msgflg, reason, gfp, skb->dst, ddl,
  503. NULL, cb->src_port, cb->dst_port);
  504. }
  505. void dn_nsp_send_link(struct sock *sk, unsigned char lsflags, char fcval)
  506. {
  507. struct dn_scp *scp = DN_SK(sk);
  508. struct sk_buff *skb;
  509. unsigned char *ptr;
  510. gfp_t gfp = GFP_ATOMIC;
  511. if ((skb = dn_alloc_skb(sk, DN_MAX_NSP_DATA_HEADER + 2, gfp)) == NULL)
  512. return;
  513. skb_reserve(skb, DN_MAX_NSP_DATA_HEADER);
  514. ptr = skb_put(skb, 2);
  515. DN_SKB_CB(skb)->nsp_flags = 0x10;
  516. *ptr++ = lsflags;
  517. *ptr = fcval;
  518. dn_nsp_queue_xmit(sk, skb, gfp, 1);
  519. scp->persist = dn_nsp_persist(sk);
  520. scp->persist_fxn = dn_nsp_xmit_timeout;
  521. }
  522. static int dn_nsp_retrans_conninit(struct sock *sk)
  523. {
  524. struct dn_scp *scp = DN_SK(sk);
  525. if (scp->state == DN_CI)
  526. dn_nsp_send_conninit(sk, NSP_RCI);
  527. return 0;
  528. }
  529. void dn_nsp_send_conninit(struct sock *sk, unsigned char msgflg)
  530. {
  531. struct dn_scp *scp = DN_SK(sk);
  532. struct nsp_conn_init_msg *msg;
  533. unsigned char aux;
  534. unsigned char menuver;
  535. struct dn_skb_cb *cb;
  536. unsigned char type = 1;
  537. gfp_t allocation = (msgflg == NSP_CI) ? sk->sk_allocation : GFP_ATOMIC;
  538. struct sk_buff *skb = dn_alloc_skb(sk, 200, allocation);
  539. if (!skb)
  540. return;
  541. cb = DN_SKB_CB(skb);
  542. msg = (struct nsp_conn_init_msg *)skb_put(skb,sizeof(*msg));
  543. msg->msgflg = msgflg;
  544. msg->dstaddr = 0x0000; /* Remote Node will assign it*/
  545. msg->srcaddr = scp->addrloc;
  546. msg->services = scp->services_loc; /* Requested flow control */
  547. msg->info = scp->info_loc; /* Version Number */
  548. msg->segsize = dn_htons(scp->segsize_loc); /* Max segment size */
  549. if (scp->peer.sdn_objnum)
  550. type = 0;
  551. skb_put(skb, dn_sockaddr2username(&scp->peer, skb->tail, type));
  552. skb_put(skb, dn_sockaddr2username(&scp->addr, skb->tail, 2));
  553. menuver = DN_MENUVER_ACC | DN_MENUVER_USR;
  554. if (scp->peer.sdn_flags & SDF_PROXY)
  555. menuver |= DN_MENUVER_PRX;
  556. if (scp->peer.sdn_flags & SDF_UICPROXY)
  557. menuver |= DN_MENUVER_UIC;
  558. *skb_put(skb, 1) = menuver; /* Menu Version */
  559. aux = scp->accessdata.acc_userl;
  560. *skb_put(skb, 1) = aux;
  561. if (aux > 0)
  562. memcpy(skb_put(skb, aux), scp->accessdata.acc_user, aux);
  563. aux = scp->accessdata.acc_passl;
  564. *skb_put(skb, 1) = aux;
  565. if (aux > 0)
  566. memcpy(skb_put(skb, aux), scp->accessdata.acc_pass, aux);
  567. aux = scp->accessdata.acc_accl;
  568. *skb_put(skb, 1) = aux;
  569. if (aux > 0)
  570. memcpy(skb_put(skb, aux), scp->accessdata.acc_acc, aux);
  571. aux = (__u8)dn_ntohs(scp->conndata_out.opt_optl);
  572. *skb_put(skb, 1) = aux;
  573. if (aux > 0)
  574. memcpy(skb_put(skb,aux), scp->conndata_out.opt_data, aux);
  575. scp->persist = dn_nsp_persist(sk);
  576. scp->persist_fxn = dn_nsp_retrans_conninit;
  577. cb->rt_flags = DN_RT_F_RQR;
  578. dn_nsp_send(skb);
  579. }