af_decnet.c 53 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432
  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 Socket Layer Interface
  7. *
  8. * Authors: Eduardo Marcelo Serrat <emserrat@geocities.com>
  9. * Patrick Caulfield <patrick@pandh.demon.co.uk>
  10. *
  11. * Changes:
  12. * Steve Whitehouse: Copied from Eduardo Serrat and Patrick Caulfield's
  13. * version of the code. Original copyright preserved
  14. * below.
  15. * Steve Whitehouse: Some bug fixes, cleaning up some code to make it
  16. * compatible with my routing layer.
  17. * Steve Whitehouse: Merging changes from Eduardo Serrat and Patrick
  18. * Caulfield.
  19. * Steve Whitehouse: Further bug fixes, checking module code still works
  20. * with new routing layer.
  21. * Steve Whitehouse: Additional set/get_sockopt() calls.
  22. * Steve Whitehouse: Fixed TIOCINQ ioctl to be same as Eduardo's new
  23. * code.
  24. * Steve Whitehouse: recvmsg() changed to try and behave in a POSIX like
  25. * way. Didn't manage it entirely, but its better.
  26. * Steve Whitehouse: ditto for sendmsg().
  27. * Steve Whitehouse: A selection of bug fixes to various things.
  28. * Steve Whitehouse: Added TIOCOUTQ ioctl.
  29. * Steve Whitehouse: Fixes to username2sockaddr & sockaddr2username.
  30. * Steve Whitehouse: Fixes to connect() error returns.
  31. * Patrick Caulfield: Fixes to delayed acceptance logic.
  32. * David S. Miller: New socket locking
  33. * Steve Whitehouse: Socket list hashing/locking
  34. * Arnaldo C. Melo: use capable, not suser
  35. * Steve Whitehouse: Removed unused code. Fix to use sk->allocation
  36. * when required.
  37. * Patrick Caulfield: /proc/net/decnet now has object name/number
  38. * Steve Whitehouse: Fixed local port allocation, hashed sk list
  39. * Matthew Wilcox: Fixes for dn_ioctl()
  40. * Steve Whitehouse: New connect/accept logic to allow timeouts and
  41. * prepare for sendpage etc.
  42. */
  43. /******************************************************************************
  44. (c) 1995-1998 E.M. Serrat emserrat@geocities.com
  45. This program is free software; you can redistribute it and/or modify
  46. it under the terms of the GNU General Public License as published by
  47. the Free Software Foundation; either version 2 of the License, or
  48. any later version.
  49. This program is distributed in the hope that it will be useful,
  50. but WITHOUT ANY WARRANTY; without even the implied warranty of
  51. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  52. GNU General Public License for more details.
  53. HISTORY:
  54. Version Kernel Date Author/Comments
  55. ------- ------ ---- ---------------
  56. Version 0.0.1 2.0.30 01-dic-97 Eduardo Marcelo Serrat
  57. (emserrat@geocities.com)
  58. First Development of DECnet Socket La-
  59. yer for Linux. Only supports outgoing
  60. connections.
  61. Version 0.0.2 2.1.105 20-jun-98 Patrick J. Caulfield
  62. (patrick@pandh.demon.co.uk)
  63. Port to new kernel development version.
  64. Version 0.0.3 2.1.106 25-jun-98 Eduardo Marcelo Serrat
  65. (emserrat@geocities.com)
  66. _
  67. Added support for incoming connections
  68. so we can start developing server apps
  69. on Linux.
  70. -
  71. Module Support
  72. Version 0.0.4 2.1.109 21-jul-98 Eduardo Marcelo Serrat
  73. (emserrat@geocities.com)
  74. _
  75. Added support for X11R6.4. Now we can
  76. use DECnet transport for X on Linux!!!
  77. -
  78. Version 0.0.5 2.1.110 01-aug-98 Eduardo Marcelo Serrat
  79. (emserrat@geocities.com)
  80. Removed bugs on flow control
  81. Removed bugs on incoming accessdata
  82. order
  83. -
  84. Version 0.0.6 2.1.110 07-aug-98 Eduardo Marcelo Serrat
  85. dn_recvmsg fixes
  86. Patrick J. Caulfield
  87. dn_bind fixes
  88. *******************************************************************************/
  89. #include <linux/module.h>
  90. #include <linux/errno.h>
  91. #include <linux/types.h>
  92. #include <linux/slab.h>
  93. #include <linux/socket.h>
  94. #include <linux/in.h>
  95. #include <linux/kernel.h>
  96. #include <linux/sched.h>
  97. #include <linux/timer.h>
  98. #include <linux/string.h>
  99. #include <linux/sockios.h>
  100. #include <linux/net.h>
  101. #include <linux/netdevice.h>
  102. #include <linux/inet.h>
  103. #include <linux/route.h>
  104. #include <linux/netfilter.h>
  105. #include <linux/seq_file.h>
  106. #include <net/sock.h>
  107. #include <net/tcp_states.h>
  108. #include <net/flow.h>
  109. #include <asm/system.h>
  110. #include <asm/ioctls.h>
  111. #include <linux/capability.h>
  112. #include <linux/mm.h>
  113. #include <linux/interrupt.h>
  114. #include <linux/proc_fs.h>
  115. #include <linux/stat.h>
  116. #include <linux/init.h>
  117. #include <linux/poll.h>
  118. #include <net/neighbour.h>
  119. #include <net/dst.h>
  120. #include <net/fib_rules.h>
  121. #include <net/dn.h>
  122. #include <net/dn_nsp.h>
  123. #include <net/dn_dev.h>
  124. #include <net/dn_route.h>
  125. #include <net/dn_fib.h>
  126. #include <net/dn_neigh.h>
  127. struct dn_sock {
  128. struct sock sk;
  129. struct dn_scp scp;
  130. };
  131. static void dn_keepalive(struct sock *sk);
  132. #define DN_SK_HASH_SHIFT 8
  133. #define DN_SK_HASH_SIZE (1 << DN_SK_HASH_SHIFT)
  134. #define DN_SK_HASH_MASK (DN_SK_HASH_SIZE - 1)
  135. static const struct proto_ops dn_proto_ops;
  136. static DEFINE_RWLOCK(dn_hash_lock);
  137. static struct hlist_head dn_sk_hash[DN_SK_HASH_SIZE];
  138. static struct hlist_head dn_wild_sk;
  139. static atomic_t decnet_memory_allocated;
  140. static int __dn_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen, int flags);
  141. static int __dn_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen, int flags);
  142. static struct hlist_head *dn_find_list(struct sock *sk)
  143. {
  144. struct dn_scp *scp = DN_SK(sk);
  145. if (scp->addr.sdn_flags & SDF_WILD)
  146. return hlist_empty(&dn_wild_sk) ? &dn_wild_sk : NULL;
  147. return &dn_sk_hash[dn_ntohs(scp->addrloc) & DN_SK_HASH_MASK];
  148. }
  149. /*
  150. * Valid ports are those greater than zero and not already in use.
  151. */
  152. static int check_port(__le16 port)
  153. {
  154. struct sock *sk;
  155. struct hlist_node *node;
  156. if (port == 0)
  157. return -1;
  158. sk_for_each(sk, node, &dn_sk_hash[dn_ntohs(port) & DN_SK_HASH_MASK]) {
  159. struct dn_scp *scp = DN_SK(sk);
  160. if (scp->addrloc == port)
  161. return -1;
  162. }
  163. return 0;
  164. }
  165. static unsigned short port_alloc(struct sock *sk)
  166. {
  167. struct dn_scp *scp = DN_SK(sk);
  168. static unsigned short port = 0x2000;
  169. unsigned short i_port = port;
  170. while(check_port(dn_htons(++port)) != 0) {
  171. if (port == i_port)
  172. return 0;
  173. }
  174. scp->addrloc = dn_htons(port);
  175. return 1;
  176. }
  177. /*
  178. * Since this is only ever called from user
  179. * level, we don't need a write_lock() version
  180. * of this.
  181. */
  182. static int dn_hash_sock(struct sock *sk)
  183. {
  184. struct dn_scp *scp = DN_SK(sk);
  185. struct hlist_head *list;
  186. int rv = -EUSERS;
  187. BUG_ON(sk_hashed(sk));
  188. write_lock_bh(&dn_hash_lock);
  189. if (!scp->addrloc && !port_alloc(sk))
  190. goto out;
  191. rv = -EADDRINUSE;
  192. if ((list = dn_find_list(sk)) == NULL)
  193. goto out;
  194. sk_add_node(sk, list);
  195. rv = 0;
  196. out:
  197. write_unlock_bh(&dn_hash_lock);
  198. return rv;
  199. }
  200. static void dn_unhash_sock(struct sock *sk)
  201. {
  202. write_lock(&dn_hash_lock);
  203. sk_del_node_init(sk);
  204. write_unlock(&dn_hash_lock);
  205. }
  206. static void dn_unhash_sock_bh(struct sock *sk)
  207. {
  208. write_lock_bh(&dn_hash_lock);
  209. sk_del_node_init(sk);
  210. write_unlock_bh(&dn_hash_lock);
  211. }
  212. static struct hlist_head *listen_hash(struct sockaddr_dn *addr)
  213. {
  214. int i;
  215. unsigned hash = addr->sdn_objnum;
  216. if (hash == 0) {
  217. hash = addr->sdn_objnamel;
  218. for(i = 0; i < dn_ntohs(addr->sdn_objnamel); i++) {
  219. hash ^= addr->sdn_objname[i];
  220. hash ^= (hash << 3);
  221. }
  222. }
  223. return &dn_sk_hash[hash & DN_SK_HASH_MASK];
  224. }
  225. /*
  226. * Called to transform a socket from bound (i.e. with a local address)
  227. * into a listening socket (doesn't need a local port number) and rehashes
  228. * based upon the object name/number.
  229. */
  230. static void dn_rehash_sock(struct sock *sk)
  231. {
  232. struct hlist_head *list;
  233. struct dn_scp *scp = DN_SK(sk);
  234. if (scp->addr.sdn_flags & SDF_WILD)
  235. return;
  236. write_lock_bh(&dn_hash_lock);
  237. sk_del_node_init(sk);
  238. DN_SK(sk)->addrloc = 0;
  239. list = listen_hash(&DN_SK(sk)->addr);
  240. sk_add_node(sk, list);
  241. write_unlock_bh(&dn_hash_lock);
  242. }
  243. int dn_sockaddr2username(struct sockaddr_dn *sdn, unsigned char *buf, unsigned char type)
  244. {
  245. int len = 2;
  246. *buf++ = type;
  247. switch(type) {
  248. case 0:
  249. *buf++ = sdn->sdn_objnum;
  250. break;
  251. case 1:
  252. *buf++ = 0;
  253. *buf++ = dn_ntohs(sdn->sdn_objnamel);
  254. memcpy(buf, sdn->sdn_objname, dn_ntohs(sdn->sdn_objnamel));
  255. len = 3 + dn_ntohs(sdn->sdn_objnamel);
  256. break;
  257. case 2:
  258. memset(buf, 0, 5);
  259. buf += 5;
  260. *buf++ = dn_ntohs(sdn->sdn_objnamel);
  261. memcpy(buf, sdn->sdn_objname, dn_ntohs(sdn->sdn_objnamel));
  262. len = 7 + dn_ntohs(sdn->sdn_objnamel);
  263. break;
  264. }
  265. return len;
  266. }
  267. /*
  268. * On reception of usernames, we handle types 1 and 0 for destination
  269. * addresses only. Types 2 and 4 are used for source addresses, but the
  270. * UIC, GIC are ignored and they are both treated the same way. Type 3
  271. * is never used as I've no idea what its purpose might be or what its
  272. * format is.
  273. */
  274. int dn_username2sockaddr(unsigned char *data, int len, struct sockaddr_dn *sdn, unsigned char *fmt)
  275. {
  276. unsigned char type;
  277. int size = len;
  278. int namel = 12;
  279. sdn->sdn_objnum = 0;
  280. sdn->sdn_objnamel = dn_htons(0);
  281. memset(sdn->sdn_objname, 0, DN_MAXOBJL);
  282. if (len < 2)
  283. return -1;
  284. len -= 2;
  285. *fmt = *data++;
  286. type = *data++;
  287. switch(*fmt) {
  288. case 0:
  289. sdn->sdn_objnum = type;
  290. return 2;
  291. case 1:
  292. namel = 16;
  293. break;
  294. case 2:
  295. len -= 4;
  296. data += 4;
  297. break;
  298. case 4:
  299. len -= 8;
  300. data += 8;
  301. break;
  302. default:
  303. return -1;
  304. }
  305. len -= 1;
  306. if (len < 0)
  307. return -1;
  308. sdn->sdn_objnamel = dn_htons(*data++);
  309. len -= dn_ntohs(sdn->sdn_objnamel);
  310. if ((len < 0) || (dn_ntohs(sdn->sdn_objnamel) > namel))
  311. return -1;
  312. memcpy(sdn->sdn_objname, data, dn_ntohs(sdn->sdn_objnamel));
  313. return size - len;
  314. }
  315. struct sock *dn_sklist_find_listener(struct sockaddr_dn *addr)
  316. {
  317. struct hlist_head *list = listen_hash(addr);
  318. struct hlist_node *node;
  319. struct sock *sk;
  320. read_lock(&dn_hash_lock);
  321. sk_for_each(sk, node, list) {
  322. struct dn_scp *scp = DN_SK(sk);
  323. if (sk->sk_state != TCP_LISTEN)
  324. continue;
  325. if (scp->addr.sdn_objnum) {
  326. if (scp->addr.sdn_objnum != addr->sdn_objnum)
  327. continue;
  328. } else {
  329. if (addr->sdn_objnum)
  330. continue;
  331. if (scp->addr.sdn_objnamel != addr->sdn_objnamel)
  332. continue;
  333. if (memcmp(scp->addr.sdn_objname, addr->sdn_objname, dn_ntohs(addr->sdn_objnamel)) != 0)
  334. continue;
  335. }
  336. sock_hold(sk);
  337. read_unlock(&dn_hash_lock);
  338. return sk;
  339. }
  340. sk = sk_head(&dn_wild_sk);
  341. if (sk) {
  342. if (sk->sk_state == TCP_LISTEN)
  343. sock_hold(sk);
  344. else
  345. sk = NULL;
  346. }
  347. read_unlock(&dn_hash_lock);
  348. return sk;
  349. }
  350. struct sock *dn_find_by_skb(struct sk_buff *skb)
  351. {
  352. struct dn_skb_cb *cb = DN_SKB_CB(skb);
  353. struct sock *sk;
  354. struct hlist_node *node;
  355. struct dn_scp *scp;
  356. read_lock(&dn_hash_lock);
  357. sk_for_each(sk, node, &dn_sk_hash[dn_ntohs(cb->dst_port) & DN_SK_HASH_MASK]) {
  358. scp = DN_SK(sk);
  359. if (cb->src != dn_saddr2dn(&scp->peer))
  360. continue;
  361. if (cb->dst_port != scp->addrloc)
  362. continue;
  363. if (scp->addrrem && (cb->src_port != scp->addrrem))
  364. continue;
  365. sock_hold(sk);
  366. goto found;
  367. }
  368. sk = NULL;
  369. found:
  370. read_unlock(&dn_hash_lock);
  371. return sk;
  372. }
  373. static void dn_destruct(struct sock *sk)
  374. {
  375. struct dn_scp *scp = DN_SK(sk);
  376. skb_queue_purge(&scp->data_xmit_queue);
  377. skb_queue_purge(&scp->other_xmit_queue);
  378. skb_queue_purge(&scp->other_receive_queue);
  379. dst_release(xchg(&sk->sk_dst_cache, NULL));
  380. }
  381. static int dn_memory_pressure;
  382. static void dn_enter_memory_pressure(void)
  383. {
  384. if (!dn_memory_pressure) {
  385. dn_memory_pressure = 1;
  386. }
  387. }
  388. static struct proto dn_proto = {
  389. .name = "NSP",
  390. .owner = THIS_MODULE,
  391. .enter_memory_pressure = dn_enter_memory_pressure,
  392. .memory_pressure = &dn_memory_pressure,
  393. .memory_allocated = &decnet_memory_allocated,
  394. .sysctl_mem = sysctl_decnet_mem,
  395. .sysctl_wmem = sysctl_decnet_wmem,
  396. .sysctl_rmem = sysctl_decnet_rmem,
  397. .max_header = DN_MAX_NSP_DATA_HEADER + 64,
  398. .obj_size = sizeof(struct dn_sock),
  399. };
  400. static struct sock *dn_alloc_sock(struct socket *sock, gfp_t gfp)
  401. {
  402. struct dn_scp *scp;
  403. struct sock *sk = sk_alloc(PF_DECnet, gfp, &dn_proto, 1);
  404. if (!sk)
  405. goto out;
  406. if (sock)
  407. sock->ops = &dn_proto_ops;
  408. sock_init_data(sock, sk);
  409. sk->sk_backlog_rcv = dn_nsp_backlog_rcv;
  410. sk->sk_destruct = dn_destruct;
  411. sk->sk_no_check = 1;
  412. sk->sk_family = PF_DECnet;
  413. sk->sk_protocol = 0;
  414. sk->sk_allocation = gfp;
  415. sk->sk_sndbuf = sysctl_decnet_wmem[1];
  416. sk->sk_rcvbuf = sysctl_decnet_rmem[1];
  417. /* Initialization of DECnet Session Control Port */
  418. scp = DN_SK(sk);
  419. scp->state = DN_O; /* Open */
  420. scp->numdat = 1; /* Next data seg to tx */
  421. scp->numoth = 1; /* Next oth data to tx */
  422. scp->ackxmt_dat = 0; /* Last data seg ack'ed */
  423. scp->ackxmt_oth = 0; /* Last oth data ack'ed */
  424. scp->ackrcv_dat = 0; /* Highest data ack recv*/
  425. scp->ackrcv_oth = 0; /* Last oth data ack rec*/
  426. scp->flowrem_sw = DN_SEND;
  427. scp->flowloc_sw = DN_SEND;
  428. scp->flowrem_dat = 0;
  429. scp->flowrem_oth = 1;
  430. scp->flowloc_dat = 0;
  431. scp->flowloc_oth = 1;
  432. scp->services_rem = 0;
  433. scp->services_loc = 1 | NSP_FC_NONE;
  434. scp->info_rem = 0;
  435. scp->info_loc = 0x03; /* NSP version 4.1 */
  436. scp->segsize_rem = 230 - DN_MAX_NSP_DATA_HEADER; /* Default: Updated by remote segsize */
  437. scp->nonagle = 0;
  438. scp->multi_ireq = 1;
  439. scp->accept_mode = ACC_IMMED;
  440. scp->addr.sdn_family = AF_DECnet;
  441. scp->peer.sdn_family = AF_DECnet;
  442. scp->accessdata.acc_accl = 5;
  443. memcpy(scp->accessdata.acc_acc, "LINUX", 5);
  444. scp->max_window = NSP_MAX_WINDOW;
  445. scp->snd_window = NSP_MIN_WINDOW;
  446. scp->nsp_srtt = NSP_INITIAL_SRTT;
  447. scp->nsp_rttvar = NSP_INITIAL_RTTVAR;
  448. scp->nsp_rxtshift = 0;
  449. skb_queue_head_init(&scp->data_xmit_queue);
  450. skb_queue_head_init(&scp->other_xmit_queue);
  451. skb_queue_head_init(&scp->other_receive_queue);
  452. scp->persist = 0;
  453. scp->persist_fxn = NULL;
  454. scp->keepalive = 10 * HZ;
  455. scp->keepalive_fxn = dn_keepalive;
  456. init_timer(&scp->delack_timer);
  457. scp->delack_pending = 0;
  458. scp->delack_fxn = dn_nsp_delayed_ack;
  459. dn_start_slow_timer(sk);
  460. out:
  461. return sk;
  462. }
  463. /*
  464. * Keepalive timer.
  465. * FIXME: Should respond to SO_KEEPALIVE etc.
  466. */
  467. static void dn_keepalive(struct sock *sk)
  468. {
  469. struct dn_scp *scp = DN_SK(sk);
  470. /*
  471. * By checking the other_data transmit queue is empty
  472. * we are double checking that we are not sending too
  473. * many of these keepalive frames.
  474. */
  475. if (skb_queue_empty(&scp->other_xmit_queue))
  476. dn_nsp_send_link(sk, DN_NOCHANGE, 0);
  477. }
  478. /*
  479. * Timer for shutdown/destroyed sockets.
  480. * When socket is dead & no packets have been sent for a
  481. * certain amount of time, they are removed by this
  482. * routine. Also takes care of sending out DI & DC
  483. * frames at correct times.
  484. */
  485. int dn_destroy_timer(struct sock *sk)
  486. {
  487. struct dn_scp *scp = DN_SK(sk);
  488. scp->persist = dn_nsp_persist(sk);
  489. switch(scp->state) {
  490. case DN_DI:
  491. dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC);
  492. if (scp->nsp_rxtshift >= decnet_di_count)
  493. scp->state = DN_CN;
  494. return 0;
  495. case DN_DR:
  496. dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC);
  497. if (scp->nsp_rxtshift >= decnet_dr_count)
  498. scp->state = DN_DRC;
  499. return 0;
  500. case DN_DN:
  501. if (scp->nsp_rxtshift < decnet_dn_count) {
  502. /* printk(KERN_DEBUG "dn_destroy_timer: DN\n"); */
  503. dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, GFP_ATOMIC);
  504. return 0;
  505. }
  506. }
  507. scp->persist = (HZ * decnet_time_wait);
  508. if (sk->sk_socket)
  509. return 0;
  510. if ((jiffies - scp->stamp) >= (HZ * decnet_time_wait)) {
  511. dn_unhash_sock(sk);
  512. sock_put(sk);
  513. return 1;
  514. }
  515. return 0;
  516. }
  517. static void dn_destroy_sock(struct sock *sk)
  518. {
  519. struct dn_scp *scp = DN_SK(sk);
  520. scp->nsp_rxtshift = 0; /* reset back off */
  521. if (sk->sk_socket) {
  522. if (sk->sk_socket->state != SS_UNCONNECTED)
  523. sk->sk_socket->state = SS_DISCONNECTING;
  524. }
  525. sk->sk_state = TCP_CLOSE;
  526. switch(scp->state) {
  527. case DN_DN:
  528. dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC,
  529. sk->sk_allocation);
  530. scp->persist_fxn = dn_destroy_timer;
  531. scp->persist = dn_nsp_persist(sk);
  532. break;
  533. case DN_CR:
  534. scp->state = DN_DR;
  535. goto disc_reject;
  536. case DN_RUN:
  537. scp->state = DN_DI;
  538. case DN_DI:
  539. case DN_DR:
  540. disc_reject:
  541. dn_nsp_send_disc(sk, NSP_DISCINIT, 0, sk->sk_allocation);
  542. case DN_NC:
  543. case DN_NR:
  544. case DN_RJ:
  545. case DN_DIC:
  546. case DN_CN:
  547. case DN_DRC:
  548. case DN_CI:
  549. case DN_CD:
  550. scp->persist_fxn = dn_destroy_timer;
  551. scp->persist = dn_nsp_persist(sk);
  552. break;
  553. default:
  554. printk(KERN_DEBUG "DECnet: dn_destroy_sock passed socket in invalid state\n");
  555. case DN_O:
  556. dn_stop_slow_timer(sk);
  557. dn_unhash_sock_bh(sk);
  558. sock_put(sk);
  559. break;
  560. }
  561. }
  562. char *dn_addr2asc(__u16 addr, char *buf)
  563. {
  564. unsigned short node, area;
  565. node = addr & 0x03ff;
  566. area = addr >> 10;
  567. sprintf(buf, "%hd.%hd", area, node);
  568. return buf;
  569. }
  570. static int dn_create(struct socket *sock, int protocol)
  571. {
  572. struct sock *sk;
  573. switch(sock->type) {
  574. case SOCK_SEQPACKET:
  575. if (protocol != DNPROTO_NSP)
  576. return -EPROTONOSUPPORT;
  577. break;
  578. case SOCK_STREAM:
  579. break;
  580. default:
  581. return -ESOCKTNOSUPPORT;
  582. }
  583. if ((sk = dn_alloc_sock(sock, GFP_KERNEL)) == NULL)
  584. return -ENOBUFS;
  585. sk->sk_protocol = protocol;
  586. return 0;
  587. }
  588. static int
  589. dn_release(struct socket *sock)
  590. {
  591. struct sock *sk = sock->sk;
  592. if (sk) {
  593. sock_orphan(sk);
  594. sock_hold(sk);
  595. lock_sock(sk);
  596. dn_destroy_sock(sk);
  597. release_sock(sk);
  598. sock_put(sk);
  599. }
  600. return 0;
  601. }
  602. static int dn_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
  603. {
  604. struct sock *sk = sock->sk;
  605. struct dn_scp *scp = DN_SK(sk);
  606. struct sockaddr_dn *saddr = (struct sockaddr_dn *)uaddr;
  607. struct net_device *dev;
  608. int rv;
  609. if (addr_len != sizeof(struct sockaddr_dn))
  610. return -EINVAL;
  611. if (saddr->sdn_family != AF_DECnet)
  612. return -EINVAL;
  613. if (dn_ntohs(saddr->sdn_nodeaddrl) && (dn_ntohs(saddr->sdn_nodeaddrl) != 2))
  614. return -EINVAL;
  615. if (dn_ntohs(saddr->sdn_objnamel) > DN_MAXOBJL)
  616. return -EINVAL;
  617. if (saddr->sdn_flags & ~SDF_WILD)
  618. return -EINVAL;
  619. if (!capable(CAP_NET_BIND_SERVICE) && (saddr->sdn_objnum ||
  620. (saddr->sdn_flags & SDF_WILD)))
  621. return -EACCES;
  622. if (!(saddr->sdn_flags & SDF_WILD)) {
  623. if (dn_ntohs(saddr->sdn_nodeaddrl)) {
  624. read_lock(&dev_base_lock);
  625. for(dev = dev_base; dev; dev = dev->next) {
  626. if (!dev->dn_ptr)
  627. continue;
  628. if (dn_dev_islocal(dev, dn_saddr2dn(saddr)))
  629. break;
  630. }
  631. read_unlock(&dev_base_lock);
  632. if (dev == NULL)
  633. return -EADDRNOTAVAIL;
  634. }
  635. }
  636. rv = -EINVAL;
  637. lock_sock(sk);
  638. if (sock_flag(sk, SOCK_ZAPPED)) {
  639. memcpy(&scp->addr, saddr, addr_len);
  640. sock_reset_flag(sk, SOCK_ZAPPED);
  641. rv = dn_hash_sock(sk);
  642. if (rv)
  643. sock_set_flag(sk, SOCK_ZAPPED);
  644. }
  645. release_sock(sk);
  646. return rv;
  647. }
  648. static int dn_auto_bind(struct socket *sock)
  649. {
  650. struct sock *sk = sock->sk;
  651. struct dn_scp *scp = DN_SK(sk);
  652. int rv;
  653. sock_reset_flag(sk, SOCK_ZAPPED);
  654. scp->addr.sdn_flags = 0;
  655. scp->addr.sdn_objnum = 0;
  656. /*
  657. * This stuff is to keep compatibility with Eduardo's
  658. * patch. I hope I can dispense with it shortly...
  659. */
  660. if ((scp->accessdata.acc_accl != 0) &&
  661. (scp->accessdata.acc_accl <= 12)) {
  662. scp->addr.sdn_objnamel = dn_htons(scp->accessdata.acc_accl);
  663. memcpy(scp->addr.sdn_objname, scp->accessdata.acc_acc, dn_ntohs(scp->addr.sdn_objnamel));
  664. scp->accessdata.acc_accl = 0;
  665. memset(scp->accessdata.acc_acc, 0, 40);
  666. }
  667. /* End of compatibility stuff */
  668. scp->addr.sdn_add.a_len = dn_htons(2);
  669. rv = dn_dev_bind_default((__le16 *)scp->addr.sdn_add.a_addr);
  670. if (rv == 0) {
  671. rv = dn_hash_sock(sk);
  672. if (rv)
  673. sock_set_flag(sk, SOCK_ZAPPED);
  674. }
  675. return rv;
  676. }
  677. static int dn_confirm_accept(struct sock *sk, long *timeo, gfp_t allocation)
  678. {
  679. struct dn_scp *scp = DN_SK(sk);
  680. DEFINE_WAIT(wait);
  681. int err;
  682. if (scp->state != DN_CR)
  683. return -EINVAL;
  684. scp->state = DN_CC;
  685. scp->segsize_loc = dst_metric(__sk_dst_get(sk), RTAX_ADVMSS);
  686. dn_send_conn_conf(sk, allocation);
  687. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  688. for(;;) {
  689. release_sock(sk);
  690. if (scp->state == DN_CC)
  691. *timeo = schedule_timeout(*timeo);
  692. lock_sock(sk);
  693. err = 0;
  694. if (scp->state == DN_RUN)
  695. break;
  696. err = sock_error(sk);
  697. if (err)
  698. break;
  699. err = sock_intr_errno(*timeo);
  700. if (signal_pending(current))
  701. break;
  702. err = -EAGAIN;
  703. if (!*timeo)
  704. break;
  705. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  706. }
  707. finish_wait(sk->sk_sleep, &wait);
  708. if (err == 0) {
  709. sk->sk_socket->state = SS_CONNECTED;
  710. } else if (scp->state != DN_CC) {
  711. sk->sk_socket->state = SS_UNCONNECTED;
  712. }
  713. return err;
  714. }
  715. static int dn_wait_run(struct sock *sk, long *timeo)
  716. {
  717. struct dn_scp *scp = DN_SK(sk);
  718. DEFINE_WAIT(wait);
  719. int err = 0;
  720. if (scp->state == DN_RUN)
  721. goto out;
  722. if (!*timeo)
  723. return -EALREADY;
  724. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  725. for(;;) {
  726. release_sock(sk);
  727. if (scp->state == DN_CI || scp->state == DN_CC)
  728. *timeo = schedule_timeout(*timeo);
  729. lock_sock(sk);
  730. err = 0;
  731. if (scp->state == DN_RUN)
  732. break;
  733. err = sock_error(sk);
  734. if (err)
  735. break;
  736. err = sock_intr_errno(*timeo);
  737. if (signal_pending(current))
  738. break;
  739. err = -ETIMEDOUT;
  740. if (!*timeo)
  741. break;
  742. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  743. }
  744. finish_wait(sk->sk_sleep, &wait);
  745. out:
  746. if (err == 0) {
  747. sk->sk_socket->state = SS_CONNECTED;
  748. } else if (scp->state != DN_CI && scp->state != DN_CC) {
  749. sk->sk_socket->state = SS_UNCONNECTED;
  750. }
  751. return err;
  752. }
  753. static int __dn_connect(struct sock *sk, struct sockaddr_dn *addr, int addrlen, long *timeo, int flags)
  754. {
  755. struct socket *sock = sk->sk_socket;
  756. struct dn_scp *scp = DN_SK(sk);
  757. int err = -EISCONN;
  758. struct flowi fl;
  759. if (sock->state == SS_CONNECTED)
  760. goto out;
  761. if (sock->state == SS_CONNECTING) {
  762. err = 0;
  763. if (scp->state == DN_RUN) {
  764. sock->state = SS_CONNECTED;
  765. goto out;
  766. }
  767. err = -ECONNREFUSED;
  768. if (scp->state != DN_CI && scp->state != DN_CC) {
  769. sock->state = SS_UNCONNECTED;
  770. goto out;
  771. }
  772. return dn_wait_run(sk, timeo);
  773. }
  774. err = -EINVAL;
  775. if (scp->state != DN_O)
  776. goto out;
  777. if (addr == NULL || addrlen != sizeof(struct sockaddr_dn))
  778. goto out;
  779. if (addr->sdn_family != AF_DECnet)
  780. goto out;
  781. if (addr->sdn_flags & SDF_WILD)
  782. goto out;
  783. if (sock_flag(sk, SOCK_ZAPPED)) {
  784. err = dn_auto_bind(sk->sk_socket);
  785. if (err)
  786. goto out;
  787. }
  788. memcpy(&scp->peer, addr, sizeof(struct sockaddr_dn));
  789. err = -EHOSTUNREACH;
  790. memset(&fl, 0, sizeof(fl));
  791. fl.oif = sk->sk_bound_dev_if;
  792. fl.fld_dst = dn_saddr2dn(&scp->peer);
  793. fl.fld_src = dn_saddr2dn(&scp->addr);
  794. dn_sk_ports_copy(&fl, scp);
  795. fl.proto = DNPROTO_NSP;
  796. if (dn_route_output_sock(&sk->sk_dst_cache, &fl, sk, flags) < 0)
  797. goto out;
  798. sk->sk_route_caps = sk->sk_dst_cache->dev->features;
  799. sock->state = SS_CONNECTING;
  800. scp->state = DN_CI;
  801. scp->segsize_loc = dst_metric(sk->sk_dst_cache, RTAX_ADVMSS);
  802. dn_nsp_send_conninit(sk, NSP_CI);
  803. err = -EINPROGRESS;
  804. if (*timeo) {
  805. err = dn_wait_run(sk, timeo);
  806. }
  807. out:
  808. return err;
  809. }
  810. static int dn_connect(struct socket *sock, struct sockaddr *uaddr, int addrlen, int flags)
  811. {
  812. struct sockaddr_dn *addr = (struct sockaddr_dn *)uaddr;
  813. struct sock *sk = sock->sk;
  814. int err;
  815. long timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
  816. lock_sock(sk);
  817. err = __dn_connect(sk, addr, addrlen, &timeo, 0);
  818. release_sock(sk);
  819. return err;
  820. }
  821. static inline int dn_check_state(struct sock *sk, struct sockaddr_dn *addr, int addrlen, long *timeo, int flags)
  822. {
  823. struct dn_scp *scp = DN_SK(sk);
  824. switch(scp->state) {
  825. case DN_RUN:
  826. return 0;
  827. case DN_CR:
  828. return dn_confirm_accept(sk, timeo, sk->sk_allocation);
  829. case DN_CI:
  830. case DN_CC:
  831. return dn_wait_run(sk, timeo);
  832. case DN_O:
  833. return __dn_connect(sk, addr, addrlen, timeo, flags);
  834. }
  835. return -EINVAL;
  836. }
  837. static void dn_access_copy(struct sk_buff *skb, struct accessdata_dn *acc)
  838. {
  839. unsigned char *ptr = skb->data;
  840. acc->acc_userl = *ptr++;
  841. memcpy(&acc->acc_user, ptr, acc->acc_userl);
  842. ptr += acc->acc_userl;
  843. acc->acc_passl = *ptr++;
  844. memcpy(&acc->acc_pass, ptr, acc->acc_passl);
  845. ptr += acc->acc_passl;
  846. acc->acc_accl = *ptr++;
  847. memcpy(&acc->acc_acc, ptr, acc->acc_accl);
  848. skb_pull(skb, acc->acc_accl + acc->acc_passl + acc->acc_userl + 3);
  849. }
  850. static void dn_user_copy(struct sk_buff *skb, struct optdata_dn *opt)
  851. {
  852. unsigned char *ptr = skb->data;
  853. u16 len = *ptr++; /* yes, it's 8bit on the wire */
  854. BUG_ON(len > 16); /* we've checked the contents earlier */
  855. opt->opt_optl = dn_htons(len);
  856. opt->opt_status = 0;
  857. memcpy(opt->opt_data, ptr, len);
  858. skb_pull(skb, len + 1);
  859. }
  860. static struct sk_buff *dn_wait_for_connect(struct sock *sk, long *timeo)
  861. {
  862. DEFINE_WAIT(wait);
  863. struct sk_buff *skb = NULL;
  864. int err = 0;
  865. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  866. for(;;) {
  867. release_sock(sk);
  868. skb = skb_dequeue(&sk->sk_receive_queue);
  869. if (skb == NULL) {
  870. *timeo = schedule_timeout(*timeo);
  871. skb = skb_dequeue(&sk->sk_receive_queue);
  872. }
  873. lock_sock(sk);
  874. if (skb != NULL)
  875. break;
  876. err = -EINVAL;
  877. if (sk->sk_state != TCP_LISTEN)
  878. break;
  879. err = sock_intr_errno(*timeo);
  880. if (signal_pending(current))
  881. break;
  882. err = -EAGAIN;
  883. if (!*timeo)
  884. break;
  885. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  886. }
  887. finish_wait(sk->sk_sleep, &wait);
  888. return skb == NULL ? ERR_PTR(err) : skb;
  889. }
  890. static int dn_accept(struct socket *sock, struct socket *newsock, int flags)
  891. {
  892. struct sock *sk = sock->sk, *newsk;
  893. struct sk_buff *skb = NULL;
  894. struct dn_skb_cb *cb;
  895. unsigned char menuver;
  896. int err = 0;
  897. unsigned char type;
  898. long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
  899. lock_sock(sk);
  900. if (sk->sk_state != TCP_LISTEN || DN_SK(sk)->state != DN_O) {
  901. release_sock(sk);
  902. return -EINVAL;
  903. }
  904. skb = skb_dequeue(&sk->sk_receive_queue);
  905. if (skb == NULL) {
  906. skb = dn_wait_for_connect(sk, &timeo);
  907. if (IS_ERR(skb)) {
  908. release_sock(sk);
  909. return PTR_ERR(skb);
  910. }
  911. }
  912. cb = DN_SKB_CB(skb);
  913. sk->sk_ack_backlog--;
  914. newsk = dn_alloc_sock(newsock, sk->sk_allocation);
  915. if (newsk == NULL) {
  916. release_sock(sk);
  917. kfree_skb(skb);
  918. return -ENOBUFS;
  919. }
  920. release_sock(sk);
  921. dst_release(xchg(&newsk->sk_dst_cache, skb->dst));
  922. skb->dst = NULL;
  923. DN_SK(newsk)->state = DN_CR;
  924. DN_SK(newsk)->addrrem = cb->src_port;
  925. DN_SK(newsk)->services_rem = cb->services;
  926. DN_SK(newsk)->info_rem = cb->info;
  927. DN_SK(newsk)->segsize_rem = cb->segsize;
  928. DN_SK(newsk)->accept_mode = DN_SK(sk)->accept_mode;
  929. if (DN_SK(newsk)->segsize_rem < 230)
  930. DN_SK(newsk)->segsize_rem = 230;
  931. if ((DN_SK(newsk)->services_rem & NSP_FC_MASK) == NSP_FC_NONE)
  932. DN_SK(newsk)->max_window = decnet_no_fc_max_cwnd;
  933. newsk->sk_state = TCP_LISTEN;
  934. memcpy(&(DN_SK(newsk)->addr), &(DN_SK(sk)->addr), sizeof(struct sockaddr_dn));
  935. /*
  936. * If we are listening on a wild socket, we don't want
  937. * the newly created socket on the wrong hash queue.
  938. */
  939. DN_SK(newsk)->addr.sdn_flags &= ~SDF_WILD;
  940. skb_pull(skb, dn_username2sockaddr(skb->data, skb->len, &(DN_SK(newsk)->addr), &type));
  941. skb_pull(skb, dn_username2sockaddr(skb->data, skb->len, &(DN_SK(newsk)->peer), &type));
  942. *(__le16 *)(DN_SK(newsk)->peer.sdn_add.a_addr) = cb->src;
  943. *(__le16 *)(DN_SK(newsk)->addr.sdn_add.a_addr) = cb->dst;
  944. menuver = *skb->data;
  945. skb_pull(skb, 1);
  946. if (menuver & DN_MENUVER_ACC)
  947. dn_access_copy(skb, &(DN_SK(newsk)->accessdata));
  948. if (menuver & DN_MENUVER_USR)
  949. dn_user_copy(skb, &(DN_SK(newsk)->conndata_in));
  950. if (menuver & DN_MENUVER_PRX)
  951. DN_SK(newsk)->peer.sdn_flags |= SDF_PROXY;
  952. if (menuver & DN_MENUVER_UIC)
  953. DN_SK(newsk)->peer.sdn_flags |= SDF_UICPROXY;
  954. kfree_skb(skb);
  955. memcpy(&(DN_SK(newsk)->conndata_out), &(DN_SK(sk)->conndata_out),
  956. sizeof(struct optdata_dn));
  957. memcpy(&(DN_SK(newsk)->discdata_out), &(DN_SK(sk)->discdata_out),
  958. sizeof(struct optdata_dn));
  959. lock_sock(newsk);
  960. err = dn_hash_sock(newsk);
  961. if (err == 0) {
  962. sock_reset_flag(newsk, SOCK_ZAPPED);
  963. dn_send_conn_ack(newsk);
  964. /*
  965. * Here we use sk->sk_allocation since although the conn conf is
  966. * for the newsk, the context is the old socket.
  967. */
  968. if (DN_SK(newsk)->accept_mode == ACC_IMMED)
  969. err = dn_confirm_accept(newsk, &timeo,
  970. sk->sk_allocation);
  971. }
  972. release_sock(newsk);
  973. return err;
  974. }
  975. static int dn_getname(struct socket *sock, struct sockaddr *uaddr,int *uaddr_len,int peer)
  976. {
  977. struct sockaddr_dn *sa = (struct sockaddr_dn *)uaddr;
  978. struct sock *sk = sock->sk;
  979. struct dn_scp *scp = DN_SK(sk);
  980. *uaddr_len = sizeof(struct sockaddr_dn);
  981. lock_sock(sk);
  982. if (peer) {
  983. if ((sock->state != SS_CONNECTED &&
  984. sock->state != SS_CONNECTING) &&
  985. scp->accept_mode == ACC_IMMED) {
  986. release_sock(sk);
  987. return -ENOTCONN;
  988. }
  989. memcpy(sa, &scp->peer, sizeof(struct sockaddr_dn));
  990. } else {
  991. memcpy(sa, &scp->addr, sizeof(struct sockaddr_dn));
  992. }
  993. release_sock(sk);
  994. return 0;
  995. }
  996. static unsigned int dn_poll(struct file *file, struct socket *sock, poll_table *wait)
  997. {
  998. struct sock *sk = sock->sk;
  999. struct dn_scp *scp = DN_SK(sk);
  1000. int mask = datagram_poll(file, sock, wait);
  1001. if (!skb_queue_empty(&scp->other_receive_queue))
  1002. mask |= POLLRDBAND;
  1003. return mask;
  1004. }
  1005. static int dn_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  1006. {
  1007. struct sock *sk = sock->sk;
  1008. struct dn_scp *scp = DN_SK(sk);
  1009. int err = -EOPNOTSUPP;
  1010. long amount = 0;
  1011. struct sk_buff *skb;
  1012. int val;
  1013. switch(cmd)
  1014. {
  1015. case SIOCGIFADDR:
  1016. case SIOCSIFADDR:
  1017. return dn_dev_ioctl(cmd, (void __user *)arg);
  1018. case SIOCATMARK:
  1019. lock_sock(sk);
  1020. val = !skb_queue_empty(&scp->other_receive_queue);
  1021. if (scp->state != DN_RUN)
  1022. val = -ENOTCONN;
  1023. release_sock(sk);
  1024. return val;
  1025. case TIOCOUTQ:
  1026. amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
  1027. if (amount < 0)
  1028. amount = 0;
  1029. err = put_user(amount, (int __user *)arg);
  1030. break;
  1031. case TIOCINQ:
  1032. lock_sock(sk);
  1033. if ((skb = skb_peek(&scp->other_receive_queue)) != NULL) {
  1034. amount = skb->len;
  1035. } else {
  1036. struct sk_buff *skb = sk->sk_receive_queue.next;
  1037. for(;;) {
  1038. if (skb ==
  1039. (struct sk_buff *)&sk->sk_receive_queue)
  1040. break;
  1041. amount += skb->len;
  1042. skb = skb->next;
  1043. }
  1044. }
  1045. release_sock(sk);
  1046. err = put_user(amount, (int __user *)arg);
  1047. break;
  1048. default:
  1049. err = -ENOIOCTLCMD;
  1050. break;
  1051. }
  1052. return err;
  1053. }
  1054. static int dn_listen(struct socket *sock, int backlog)
  1055. {
  1056. struct sock *sk = sock->sk;
  1057. int err = -EINVAL;
  1058. lock_sock(sk);
  1059. if (sock_flag(sk, SOCK_ZAPPED))
  1060. goto out;
  1061. if ((DN_SK(sk)->state != DN_O) || (sk->sk_state == TCP_LISTEN))
  1062. goto out;
  1063. sk->sk_max_ack_backlog = backlog;
  1064. sk->sk_ack_backlog = 0;
  1065. sk->sk_state = TCP_LISTEN;
  1066. err = 0;
  1067. dn_rehash_sock(sk);
  1068. out:
  1069. release_sock(sk);
  1070. return err;
  1071. }
  1072. static int dn_shutdown(struct socket *sock, int how)
  1073. {
  1074. struct sock *sk = sock->sk;
  1075. struct dn_scp *scp = DN_SK(sk);
  1076. int err = -ENOTCONN;
  1077. lock_sock(sk);
  1078. if (sock->state == SS_UNCONNECTED)
  1079. goto out;
  1080. err = 0;
  1081. if (sock->state == SS_DISCONNECTING)
  1082. goto out;
  1083. err = -EINVAL;
  1084. if (scp->state == DN_O)
  1085. goto out;
  1086. if (how != SHUTDOWN_MASK)
  1087. goto out;
  1088. sk->sk_shutdown = how;
  1089. dn_destroy_sock(sk);
  1090. err = 0;
  1091. out:
  1092. release_sock(sk);
  1093. return err;
  1094. }
  1095. static int dn_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
  1096. {
  1097. struct sock *sk = sock->sk;
  1098. int err;
  1099. lock_sock(sk);
  1100. err = __dn_setsockopt(sock, level, optname, optval, optlen, 0);
  1101. release_sock(sk);
  1102. return err;
  1103. }
  1104. static int __dn_setsockopt(struct socket *sock, int level,int optname, char __user *optval, int optlen, int flags)
  1105. {
  1106. struct sock *sk = sock->sk;
  1107. struct dn_scp *scp = DN_SK(sk);
  1108. long timeo;
  1109. union {
  1110. struct optdata_dn opt;
  1111. struct accessdata_dn acc;
  1112. int mode;
  1113. unsigned long win;
  1114. int val;
  1115. unsigned char services;
  1116. unsigned char info;
  1117. } u;
  1118. int err;
  1119. if (optlen && !optval)
  1120. return -EINVAL;
  1121. if (optlen > sizeof(u))
  1122. return -EINVAL;
  1123. if (copy_from_user(&u, optval, optlen))
  1124. return -EFAULT;
  1125. switch(optname) {
  1126. case DSO_CONDATA:
  1127. if (sock->state == SS_CONNECTED)
  1128. return -EISCONN;
  1129. if ((scp->state != DN_O) && (scp->state != DN_CR))
  1130. return -EINVAL;
  1131. if (optlen != sizeof(struct optdata_dn))
  1132. return -EINVAL;
  1133. if (dn_ntohs(u.opt.opt_optl) > 16)
  1134. return -EINVAL;
  1135. memcpy(&scp->conndata_out, &u.opt, optlen);
  1136. break;
  1137. case DSO_DISDATA:
  1138. if (sock->state != SS_CONNECTED && scp->accept_mode == ACC_IMMED)
  1139. return -ENOTCONN;
  1140. if (optlen != sizeof(struct optdata_dn))
  1141. return -EINVAL;
  1142. if (dn_ntohs(u.opt.opt_optl) > 16)
  1143. return -EINVAL;
  1144. memcpy(&scp->discdata_out, &u.opt, optlen);
  1145. break;
  1146. case DSO_CONACCESS:
  1147. if (sock->state == SS_CONNECTED)
  1148. return -EISCONN;
  1149. if (scp->state != DN_O)
  1150. return -EINVAL;
  1151. if (optlen != sizeof(struct accessdata_dn))
  1152. return -EINVAL;
  1153. if ((u.acc.acc_accl > DN_MAXACCL) ||
  1154. (u.acc.acc_passl > DN_MAXACCL) ||
  1155. (u.acc.acc_userl > DN_MAXACCL))
  1156. return -EINVAL;
  1157. memcpy(&scp->accessdata, &u.acc, optlen);
  1158. break;
  1159. case DSO_ACCEPTMODE:
  1160. if (sock->state == SS_CONNECTED)
  1161. return -EISCONN;
  1162. if (scp->state != DN_O)
  1163. return -EINVAL;
  1164. if (optlen != sizeof(int))
  1165. return -EINVAL;
  1166. if ((u.mode != ACC_IMMED) && (u.mode != ACC_DEFER))
  1167. return -EINVAL;
  1168. scp->accept_mode = (unsigned char)u.mode;
  1169. break;
  1170. case DSO_CONACCEPT:
  1171. if (scp->state != DN_CR)
  1172. return -EINVAL;
  1173. timeo = sock_rcvtimeo(sk, 0);
  1174. err = dn_confirm_accept(sk, &timeo, sk->sk_allocation);
  1175. return err;
  1176. case DSO_CONREJECT:
  1177. if (scp->state != DN_CR)
  1178. return -EINVAL;
  1179. scp->state = DN_DR;
  1180. sk->sk_shutdown = SHUTDOWN_MASK;
  1181. dn_nsp_send_disc(sk, 0x38, 0, sk->sk_allocation);
  1182. break;
  1183. default:
  1184. #ifdef CONFIG_NETFILTER
  1185. return nf_setsockopt(sk, PF_DECnet, optname, optval, optlen);
  1186. #endif
  1187. case DSO_LINKINFO:
  1188. case DSO_STREAM:
  1189. case DSO_SEQPACKET:
  1190. return -ENOPROTOOPT;
  1191. case DSO_MAXWINDOW:
  1192. if (optlen != sizeof(unsigned long))
  1193. return -EINVAL;
  1194. if (u.win > NSP_MAX_WINDOW)
  1195. u.win = NSP_MAX_WINDOW;
  1196. if (u.win == 0)
  1197. return -EINVAL;
  1198. scp->max_window = u.win;
  1199. if (scp->snd_window > u.win)
  1200. scp->snd_window = u.win;
  1201. break;
  1202. case DSO_NODELAY:
  1203. if (optlen != sizeof(int))
  1204. return -EINVAL;
  1205. if (scp->nonagle == 2)
  1206. return -EINVAL;
  1207. scp->nonagle = (u.val == 0) ? 0 : 1;
  1208. /* if (scp->nonagle == 1) { Push pending frames } */
  1209. break;
  1210. case DSO_CORK:
  1211. if (optlen != sizeof(int))
  1212. return -EINVAL;
  1213. if (scp->nonagle == 1)
  1214. return -EINVAL;
  1215. scp->nonagle = (u.val == 0) ? 0 : 2;
  1216. /* if (scp->nonagle == 0) { Push pending frames } */
  1217. break;
  1218. case DSO_SERVICES:
  1219. if (optlen != sizeof(unsigned char))
  1220. return -EINVAL;
  1221. if ((u.services & ~NSP_FC_MASK) != 0x01)
  1222. return -EINVAL;
  1223. if ((u.services & NSP_FC_MASK) == NSP_FC_MASK)
  1224. return -EINVAL;
  1225. scp->services_loc = u.services;
  1226. break;
  1227. case DSO_INFO:
  1228. if (optlen != sizeof(unsigned char))
  1229. return -EINVAL;
  1230. if (u.info & 0xfc)
  1231. return -EINVAL;
  1232. scp->info_loc = u.info;
  1233. break;
  1234. }
  1235. return 0;
  1236. }
  1237. static int dn_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
  1238. {
  1239. struct sock *sk = sock->sk;
  1240. int err;
  1241. lock_sock(sk);
  1242. err = __dn_getsockopt(sock, level, optname, optval, optlen, 0);
  1243. release_sock(sk);
  1244. return err;
  1245. }
  1246. static int __dn_getsockopt(struct socket *sock, int level,int optname, char __user *optval,int __user *optlen, int flags)
  1247. {
  1248. struct sock *sk = sock->sk;
  1249. struct dn_scp *scp = DN_SK(sk);
  1250. struct linkinfo_dn link;
  1251. unsigned int r_len;
  1252. void *r_data = NULL;
  1253. unsigned int val;
  1254. if(get_user(r_len , optlen))
  1255. return -EFAULT;
  1256. switch(optname) {
  1257. case DSO_CONDATA:
  1258. if (r_len > sizeof(struct optdata_dn))
  1259. r_len = sizeof(struct optdata_dn);
  1260. r_data = &scp->conndata_in;
  1261. break;
  1262. case DSO_DISDATA:
  1263. if (r_len > sizeof(struct optdata_dn))
  1264. r_len = sizeof(struct optdata_dn);
  1265. r_data = &scp->discdata_in;
  1266. break;
  1267. case DSO_CONACCESS:
  1268. if (r_len > sizeof(struct accessdata_dn))
  1269. r_len = sizeof(struct accessdata_dn);
  1270. r_data = &scp->accessdata;
  1271. break;
  1272. case DSO_ACCEPTMODE:
  1273. if (r_len > sizeof(unsigned char))
  1274. r_len = sizeof(unsigned char);
  1275. r_data = &scp->accept_mode;
  1276. break;
  1277. case DSO_LINKINFO:
  1278. if (r_len > sizeof(struct linkinfo_dn))
  1279. r_len = sizeof(struct linkinfo_dn);
  1280. switch(sock->state) {
  1281. case SS_CONNECTING:
  1282. link.idn_linkstate = LL_CONNECTING;
  1283. break;
  1284. case SS_DISCONNECTING:
  1285. link.idn_linkstate = LL_DISCONNECTING;
  1286. break;
  1287. case SS_CONNECTED:
  1288. link.idn_linkstate = LL_RUNNING;
  1289. break;
  1290. default:
  1291. link.idn_linkstate = LL_INACTIVE;
  1292. }
  1293. link.idn_segsize = scp->segsize_rem;
  1294. r_data = &link;
  1295. break;
  1296. default:
  1297. #ifdef CONFIG_NETFILTER
  1298. {
  1299. int val, len;
  1300. if(get_user(len, optlen))
  1301. return -EFAULT;
  1302. val = nf_getsockopt(sk, PF_DECnet, optname,
  1303. optval, &len);
  1304. if (val >= 0)
  1305. val = put_user(len, optlen);
  1306. return val;
  1307. }
  1308. #endif
  1309. case DSO_STREAM:
  1310. case DSO_SEQPACKET:
  1311. case DSO_CONACCEPT:
  1312. case DSO_CONREJECT:
  1313. return -ENOPROTOOPT;
  1314. case DSO_MAXWINDOW:
  1315. if (r_len > sizeof(unsigned long))
  1316. r_len = sizeof(unsigned long);
  1317. r_data = &scp->max_window;
  1318. break;
  1319. case DSO_NODELAY:
  1320. if (r_len > sizeof(int))
  1321. r_len = sizeof(int);
  1322. val = (scp->nonagle == 1);
  1323. r_data = &val;
  1324. break;
  1325. case DSO_CORK:
  1326. if (r_len > sizeof(int))
  1327. r_len = sizeof(int);
  1328. val = (scp->nonagle == 2);
  1329. r_data = &val;
  1330. break;
  1331. case DSO_SERVICES:
  1332. if (r_len > sizeof(unsigned char))
  1333. r_len = sizeof(unsigned char);
  1334. r_data = &scp->services_rem;
  1335. break;
  1336. case DSO_INFO:
  1337. if (r_len > sizeof(unsigned char))
  1338. r_len = sizeof(unsigned char);
  1339. r_data = &scp->info_rem;
  1340. break;
  1341. }
  1342. if (r_data) {
  1343. if (copy_to_user(optval, r_data, r_len))
  1344. return -EFAULT;
  1345. if (put_user(r_len, optlen))
  1346. return -EFAULT;
  1347. }
  1348. return 0;
  1349. }
  1350. static int dn_data_ready(struct sock *sk, struct sk_buff_head *q, int flags, int target)
  1351. {
  1352. struct sk_buff *skb = q->next;
  1353. int len = 0;
  1354. if (flags & MSG_OOB)
  1355. return !skb_queue_empty(q) ? 1 : 0;
  1356. while(skb != (struct sk_buff *)q) {
  1357. struct dn_skb_cb *cb = DN_SKB_CB(skb);
  1358. len += skb->len;
  1359. if (cb->nsp_flags & 0x40) {
  1360. /* SOCK_SEQPACKET reads to EOM */
  1361. if (sk->sk_type == SOCK_SEQPACKET)
  1362. return 1;
  1363. /* so does SOCK_STREAM unless WAITALL is specified */
  1364. if (!(flags & MSG_WAITALL))
  1365. return 1;
  1366. }
  1367. /* minimum data length for read exceeded */
  1368. if (len >= target)
  1369. return 1;
  1370. skb = skb->next;
  1371. }
  1372. return 0;
  1373. }
  1374. static int dn_recvmsg(struct kiocb *iocb, struct socket *sock,
  1375. struct msghdr *msg, size_t size, int flags)
  1376. {
  1377. struct sock *sk = sock->sk;
  1378. struct dn_scp *scp = DN_SK(sk);
  1379. struct sk_buff_head *queue = &sk->sk_receive_queue;
  1380. size_t target = size > 1 ? 1 : 0;
  1381. size_t copied = 0;
  1382. int rv = 0;
  1383. struct sk_buff *skb, *nskb;
  1384. struct dn_skb_cb *cb = NULL;
  1385. unsigned char eor = 0;
  1386. long timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
  1387. lock_sock(sk);
  1388. if (sock_flag(sk, SOCK_ZAPPED)) {
  1389. rv = -EADDRNOTAVAIL;
  1390. goto out;
  1391. }
  1392. if (sk->sk_shutdown & RCV_SHUTDOWN) {
  1393. rv = 0;
  1394. goto out;
  1395. }
  1396. rv = dn_check_state(sk, NULL, 0, &timeo, flags);
  1397. if (rv)
  1398. goto out;
  1399. if (flags & ~(MSG_CMSG_COMPAT|MSG_PEEK|MSG_OOB|MSG_WAITALL|MSG_DONTWAIT|MSG_NOSIGNAL)) {
  1400. rv = -EOPNOTSUPP;
  1401. goto out;
  1402. }
  1403. if (flags & MSG_OOB)
  1404. queue = &scp->other_receive_queue;
  1405. if (flags & MSG_WAITALL)
  1406. target = size;
  1407. /*
  1408. * See if there is data ready to read, sleep if there isn't
  1409. */
  1410. for(;;) {
  1411. if (sk->sk_err)
  1412. goto out;
  1413. if (!skb_queue_empty(&scp->other_receive_queue)) {
  1414. if (!(flags & MSG_OOB)) {
  1415. msg->msg_flags |= MSG_OOB;
  1416. if (!scp->other_report) {
  1417. scp->other_report = 1;
  1418. goto out;
  1419. }
  1420. }
  1421. }
  1422. if (scp->state != DN_RUN)
  1423. goto out;
  1424. if (signal_pending(current)) {
  1425. rv = sock_intr_errno(timeo);
  1426. goto out;
  1427. }
  1428. if (dn_data_ready(sk, queue, flags, target))
  1429. break;
  1430. if (flags & MSG_DONTWAIT) {
  1431. rv = -EWOULDBLOCK;
  1432. goto out;
  1433. }
  1434. set_bit(SOCK_ASYNC_WAITDATA, &sock->flags);
  1435. SOCK_SLEEP_PRE(sk)
  1436. if (!dn_data_ready(sk, queue, flags, target))
  1437. schedule();
  1438. SOCK_SLEEP_POST(sk)
  1439. clear_bit(SOCK_ASYNC_WAITDATA, &sock->flags);
  1440. }
  1441. for(skb = queue->next; skb != (struct sk_buff *)queue; skb = nskb) {
  1442. unsigned int chunk = skb->len;
  1443. cb = DN_SKB_CB(skb);
  1444. if ((chunk + copied) > size)
  1445. chunk = size - copied;
  1446. if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
  1447. rv = -EFAULT;
  1448. break;
  1449. }
  1450. copied += chunk;
  1451. if (!(flags & MSG_PEEK))
  1452. skb_pull(skb, chunk);
  1453. eor = cb->nsp_flags & 0x40;
  1454. nskb = skb->next;
  1455. if (skb->len == 0) {
  1456. skb_unlink(skb, queue);
  1457. kfree_skb(skb);
  1458. /*
  1459. * N.B. Don't refer to skb or cb after this point
  1460. * in loop.
  1461. */
  1462. if ((scp->flowloc_sw == DN_DONTSEND) && !dn_congested(sk)) {
  1463. scp->flowloc_sw = DN_SEND;
  1464. dn_nsp_send_link(sk, DN_SEND, 0);
  1465. }
  1466. }
  1467. if (eor) {
  1468. if (sk->sk_type == SOCK_SEQPACKET)
  1469. break;
  1470. if (!(flags & MSG_WAITALL))
  1471. break;
  1472. }
  1473. if (flags & MSG_OOB)
  1474. break;
  1475. if (copied >= target)
  1476. break;
  1477. }
  1478. rv = copied;
  1479. if (eor && (sk->sk_type == SOCK_SEQPACKET))
  1480. msg->msg_flags |= MSG_EOR;
  1481. out:
  1482. if (rv == 0)
  1483. rv = (flags & MSG_PEEK) ? -sk->sk_err : sock_error(sk);
  1484. if ((rv >= 0) && msg->msg_name) {
  1485. memcpy(msg->msg_name, &scp->peer, sizeof(struct sockaddr_dn));
  1486. msg->msg_namelen = sizeof(struct sockaddr_dn);
  1487. }
  1488. release_sock(sk);
  1489. return rv;
  1490. }
  1491. static inline int dn_queue_too_long(struct dn_scp *scp, struct sk_buff_head *queue, int flags)
  1492. {
  1493. unsigned char fctype = scp->services_rem & NSP_FC_MASK;
  1494. if (skb_queue_len(queue) >= scp->snd_window)
  1495. return 1;
  1496. if (fctype != NSP_FC_NONE) {
  1497. if (flags & MSG_OOB) {
  1498. if (scp->flowrem_oth == 0)
  1499. return 1;
  1500. } else {
  1501. if (scp->flowrem_dat == 0)
  1502. return 1;
  1503. }
  1504. }
  1505. return 0;
  1506. }
  1507. /*
  1508. * The DECnet spec requires the the "routing layer" accepts packets which
  1509. * are at least 230 bytes in size. This excludes any headers which the NSP
  1510. * layer might add, so we always assume that we'll be using the maximal
  1511. * length header on data packets. The variation in length is due to the
  1512. * inclusion (or not) of the two 16 bit acknowledgement fields so it doesn't
  1513. * make much practical difference.
  1514. */
  1515. unsigned dn_mss_from_pmtu(struct net_device *dev, int mtu)
  1516. {
  1517. unsigned mss = 230 - DN_MAX_NSP_DATA_HEADER;
  1518. if (dev) {
  1519. struct dn_dev *dn_db = dev->dn_ptr;
  1520. mtu -= LL_RESERVED_SPACE(dev);
  1521. if (dn_db->use_long)
  1522. mtu -= 21;
  1523. else
  1524. mtu -= 6;
  1525. mtu -= DN_MAX_NSP_DATA_HEADER;
  1526. } else {
  1527. /*
  1528. * 21 = long header, 16 = guess at MAC header length
  1529. */
  1530. mtu -= (21 + DN_MAX_NSP_DATA_HEADER + 16);
  1531. }
  1532. if (mtu > mss)
  1533. mss = mtu;
  1534. return mss;
  1535. }
  1536. static inline unsigned int dn_current_mss(struct sock *sk, int flags)
  1537. {
  1538. struct dst_entry *dst = __sk_dst_get(sk);
  1539. struct dn_scp *scp = DN_SK(sk);
  1540. int mss_now = min_t(int, scp->segsize_loc, scp->segsize_rem);
  1541. /* Other data messages are limited to 16 bytes per packet */
  1542. if (flags & MSG_OOB)
  1543. return 16;
  1544. /* This works out the maximum size of segment we can send out */
  1545. if (dst) {
  1546. u32 mtu = dst_mtu(dst);
  1547. mss_now = min_t(int, dn_mss_from_pmtu(dst->dev, mtu), mss_now);
  1548. }
  1549. return mss_now;
  1550. }
  1551. /*
  1552. * N.B. We get the timeout wrong here, but then we always did get it
  1553. * wrong before and this is another step along the road to correcting
  1554. * it. It ought to get updated each time we pass through the routine,
  1555. * but in practise it probably doesn't matter too much for now.
  1556. */
  1557. static inline struct sk_buff *dn_alloc_send_pskb(struct sock *sk,
  1558. unsigned long datalen, int noblock,
  1559. int *errcode)
  1560. {
  1561. struct sk_buff *skb = sock_alloc_send_skb(sk, datalen,
  1562. noblock, errcode);
  1563. if (skb) {
  1564. skb->protocol = __constant_htons(ETH_P_DNA_RT);
  1565. skb->pkt_type = PACKET_OUTGOING;
  1566. }
  1567. return skb;
  1568. }
  1569. static int dn_sendmsg(struct kiocb *iocb, struct socket *sock,
  1570. struct msghdr *msg, size_t size)
  1571. {
  1572. struct sock *sk = sock->sk;
  1573. struct dn_scp *scp = DN_SK(sk);
  1574. size_t mss;
  1575. struct sk_buff_head *queue = &scp->data_xmit_queue;
  1576. int flags = msg->msg_flags;
  1577. int err = 0;
  1578. size_t sent = 0;
  1579. int addr_len = msg->msg_namelen;
  1580. struct sockaddr_dn *addr = (struct sockaddr_dn *)msg->msg_name;
  1581. struct sk_buff *skb = NULL;
  1582. struct dn_skb_cb *cb;
  1583. size_t len;
  1584. unsigned char fctype;
  1585. long timeo;
  1586. if (flags & ~(MSG_TRYHARD|MSG_OOB|MSG_DONTWAIT|MSG_EOR|MSG_NOSIGNAL|MSG_MORE|MSG_CMSG_COMPAT))
  1587. return -EOPNOTSUPP;
  1588. if (addr_len && (addr_len != sizeof(struct sockaddr_dn)))
  1589. return -EINVAL;
  1590. lock_sock(sk);
  1591. timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
  1592. /*
  1593. * The only difference between stream sockets and sequenced packet
  1594. * sockets is that the stream sockets always behave as if MSG_EOR
  1595. * has been set.
  1596. */
  1597. if (sock->type == SOCK_STREAM) {
  1598. if (flags & MSG_EOR) {
  1599. err = -EINVAL;
  1600. goto out;
  1601. }
  1602. flags |= MSG_EOR;
  1603. }
  1604. err = dn_check_state(sk, addr, addr_len, &timeo, flags);
  1605. if (err)
  1606. goto out_err;
  1607. if (sk->sk_shutdown & SEND_SHUTDOWN) {
  1608. err = -EPIPE;
  1609. if (!(flags & MSG_NOSIGNAL))
  1610. send_sig(SIGPIPE, current, 0);
  1611. goto out_err;
  1612. }
  1613. if ((flags & MSG_TRYHARD) && sk->sk_dst_cache)
  1614. dst_negative_advice(&sk->sk_dst_cache);
  1615. mss = scp->segsize_rem;
  1616. fctype = scp->services_rem & NSP_FC_MASK;
  1617. mss = dn_current_mss(sk, flags);
  1618. if (flags & MSG_OOB) {
  1619. queue = &scp->other_xmit_queue;
  1620. if (size > mss) {
  1621. err = -EMSGSIZE;
  1622. goto out;
  1623. }
  1624. }
  1625. scp->persist_fxn = dn_nsp_xmit_timeout;
  1626. while(sent < size) {
  1627. err = sock_error(sk);
  1628. if (err)
  1629. goto out;
  1630. if (signal_pending(current)) {
  1631. err = sock_intr_errno(timeo);
  1632. goto out;
  1633. }
  1634. /*
  1635. * Calculate size that we wish to send.
  1636. */
  1637. len = size - sent;
  1638. if (len > mss)
  1639. len = mss;
  1640. /*
  1641. * Wait for queue size to go down below the window
  1642. * size.
  1643. */
  1644. if (dn_queue_too_long(scp, queue, flags)) {
  1645. if (flags & MSG_DONTWAIT) {
  1646. err = -EWOULDBLOCK;
  1647. goto out;
  1648. }
  1649. SOCK_SLEEP_PRE(sk)
  1650. if (dn_queue_too_long(scp, queue, flags))
  1651. schedule();
  1652. SOCK_SLEEP_POST(sk)
  1653. continue;
  1654. }
  1655. /*
  1656. * Get a suitably sized skb.
  1657. * 64 is a bit of a hack really, but its larger than any
  1658. * link-layer headers and has served us well as a good
  1659. * guess as to their real length.
  1660. */
  1661. skb = dn_alloc_send_pskb(sk, len + 64 + DN_MAX_NSP_DATA_HEADER,
  1662. flags & MSG_DONTWAIT, &err);
  1663. if (err)
  1664. break;
  1665. if (!skb)
  1666. continue;
  1667. cb = DN_SKB_CB(skb);
  1668. skb_reserve(skb, 64 + DN_MAX_NSP_DATA_HEADER);
  1669. if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
  1670. err = -EFAULT;
  1671. goto out;
  1672. }
  1673. if (flags & MSG_OOB) {
  1674. cb->nsp_flags = 0x30;
  1675. if (fctype != NSP_FC_NONE)
  1676. scp->flowrem_oth--;
  1677. } else {
  1678. cb->nsp_flags = 0x00;
  1679. if (scp->seg_total == 0)
  1680. cb->nsp_flags |= 0x20;
  1681. scp->seg_total += len;
  1682. if (((sent + len) == size) && (flags & MSG_EOR)) {
  1683. cb->nsp_flags |= 0x40;
  1684. scp->seg_total = 0;
  1685. if (fctype == NSP_FC_SCMC)
  1686. scp->flowrem_dat--;
  1687. }
  1688. if (fctype == NSP_FC_SRC)
  1689. scp->flowrem_dat--;
  1690. }
  1691. sent += len;
  1692. dn_nsp_queue_xmit(sk, skb, sk->sk_allocation, flags & MSG_OOB);
  1693. skb = NULL;
  1694. scp->persist = dn_nsp_persist(sk);
  1695. }
  1696. out:
  1697. if (skb)
  1698. kfree_skb(skb);
  1699. release_sock(sk);
  1700. return sent ? sent : err;
  1701. out_err:
  1702. err = sk_stream_error(sk, flags, err);
  1703. release_sock(sk);
  1704. return err;
  1705. }
  1706. static int dn_device_event(struct notifier_block *this, unsigned long event,
  1707. void *ptr)
  1708. {
  1709. struct net_device *dev = (struct net_device *)ptr;
  1710. switch(event) {
  1711. case NETDEV_UP:
  1712. dn_dev_up(dev);
  1713. break;
  1714. case NETDEV_DOWN:
  1715. dn_dev_down(dev);
  1716. break;
  1717. default:
  1718. break;
  1719. }
  1720. return NOTIFY_DONE;
  1721. }
  1722. static struct notifier_block dn_dev_notifier = {
  1723. .notifier_call = dn_device_event,
  1724. };
  1725. extern int dn_route_rcv(struct sk_buff *, struct net_device *, struct packet_type *, struct net_device *);
  1726. static struct packet_type dn_dix_packet_type = {
  1727. .type = __constant_htons(ETH_P_DNA_RT),
  1728. .dev = NULL, /* All devices */
  1729. .func = dn_route_rcv,
  1730. };
  1731. #ifdef CONFIG_PROC_FS
  1732. struct dn_iter_state {
  1733. int bucket;
  1734. };
  1735. static struct sock *dn_socket_get_first(struct seq_file *seq)
  1736. {
  1737. struct dn_iter_state *state = seq->private;
  1738. struct sock *n = NULL;
  1739. for(state->bucket = 0;
  1740. state->bucket < DN_SK_HASH_SIZE;
  1741. ++state->bucket) {
  1742. n = sk_head(&dn_sk_hash[state->bucket]);
  1743. if (n)
  1744. break;
  1745. }
  1746. return n;
  1747. }
  1748. static struct sock *dn_socket_get_next(struct seq_file *seq,
  1749. struct sock *n)
  1750. {
  1751. struct dn_iter_state *state = seq->private;
  1752. n = sk_next(n);
  1753. try_again:
  1754. if (n)
  1755. goto out;
  1756. if (++state->bucket >= DN_SK_HASH_SIZE)
  1757. goto out;
  1758. n = sk_head(&dn_sk_hash[state->bucket]);
  1759. goto try_again;
  1760. out:
  1761. return n;
  1762. }
  1763. static struct sock *socket_get_idx(struct seq_file *seq, loff_t *pos)
  1764. {
  1765. struct sock *sk = dn_socket_get_first(seq);
  1766. if (sk) {
  1767. while(*pos && (sk = dn_socket_get_next(seq, sk)))
  1768. --*pos;
  1769. }
  1770. return *pos ? NULL : sk;
  1771. }
  1772. static void *dn_socket_get_idx(struct seq_file *seq, loff_t pos)
  1773. {
  1774. void *rc;
  1775. read_lock_bh(&dn_hash_lock);
  1776. rc = socket_get_idx(seq, &pos);
  1777. if (!rc) {
  1778. read_unlock_bh(&dn_hash_lock);
  1779. }
  1780. return rc;
  1781. }
  1782. static void *dn_socket_seq_start(struct seq_file *seq, loff_t *pos)
  1783. {
  1784. return *pos ? dn_socket_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
  1785. }
  1786. static void *dn_socket_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  1787. {
  1788. void *rc;
  1789. if (v == SEQ_START_TOKEN) {
  1790. rc = dn_socket_get_idx(seq, 0);
  1791. goto out;
  1792. }
  1793. rc = dn_socket_get_next(seq, v);
  1794. if (rc)
  1795. goto out;
  1796. read_unlock_bh(&dn_hash_lock);
  1797. out:
  1798. ++*pos;
  1799. return rc;
  1800. }
  1801. static void dn_socket_seq_stop(struct seq_file *seq, void *v)
  1802. {
  1803. if (v && v != SEQ_START_TOKEN)
  1804. read_unlock_bh(&dn_hash_lock);
  1805. }
  1806. #define IS_NOT_PRINTABLE(x) ((x) < 32 || (x) > 126)
  1807. static void dn_printable_object(struct sockaddr_dn *dn, unsigned char *buf)
  1808. {
  1809. int i;
  1810. switch (dn_ntohs(dn->sdn_objnamel)) {
  1811. case 0:
  1812. sprintf(buf, "%d", dn->sdn_objnum);
  1813. break;
  1814. default:
  1815. for (i = 0; i < dn_ntohs(dn->sdn_objnamel); i++) {
  1816. buf[i] = dn->sdn_objname[i];
  1817. if (IS_NOT_PRINTABLE(buf[i]))
  1818. buf[i] = '.';
  1819. }
  1820. buf[i] = 0;
  1821. }
  1822. }
  1823. static char *dn_state2asc(unsigned char state)
  1824. {
  1825. switch(state) {
  1826. case DN_O:
  1827. return "OPEN";
  1828. case DN_CR:
  1829. return " CR";
  1830. case DN_DR:
  1831. return " DR";
  1832. case DN_DRC:
  1833. return " DRC";
  1834. case DN_CC:
  1835. return " CC";
  1836. case DN_CI:
  1837. return " CI";
  1838. case DN_NR:
  1839. return " NR";
  1840. case DN_NC:
  1841. return " NC";
  1842. case DN_CD:
  1843. return " CD";
  1844. case DN_RJ:
  1845. return " RJ";
  1846. case DN_RUN:
  1847. return " RUN";
  1848. case DN_DI:
  1849. return " DI";
  1850. case DN_DIC:
  1851. return " DIC";
  1852. case DN_DN:
  1853. return " DN";
  1854. case DN_CL:
  1855. return " CL";
  1856. case DN_CN:
  1857. return " CN";
  1858. }
  1859. return "????";
  1860. }
  1861. static inline void dn_socket_format_entry(struct seq_file *seq, struct sock *sk)
  1862. {
  1863. struct dn_scp *scp = DN_SK(sk);
  1864. char buf1[DN_ASCBUF_LEN];
  1865. char buf2[DN_ASCBUF_LEN];
  1866. char local_object[DN_MAXOBJL+3];
  1867. char remote_object[DN_MAXOBJL+3];
  1868. dn_printable_object(&scp->addr, local_object);
  1869. dn_printable_object(&scp->peer, remote_object);
  1870. seq_printf(seq,
  1871. "%6s/%04X %04d:%04d %04d:%04d %01d %-16s "
  1872. "%6s/%04X %04d:%04d %04d:%04d %01d %-16s %4s %s\n",
  1873. dn_addr2asc(dn_ntohs(dn_saddr2dn(&scp->addr)), buf1),
  1874. scp->addrloc,
  1875. scp->numdat,
  1876. scp->numoth,
  1877. scp->ackxmt_dat,
  1878. scp->ackxmt_oth,
  1879. scp->flowloc_sw,
  1880. local_object,
  1881. dn_addr2asc(dn_ntohs(dn_saddr2dn(&scp->peer)), buf2),
  1882. scp->addrrem,
  1883. scp->numdat_rcv,
  1884. scp->numoth_rcv,
  1885. scp->ackrcv_dat,
  1886. scp->ackrcv_oth,
  1887. scp->flowrem_sw,
  1888. remote_object,
  1889. dn_state2asc(scp->state),
  1890. ((scp->accept_mode == ACC_IMMED) ? "IMMED" : "DEFER"));
  1891. }
  1892. static int dn_socket_seq_show(struct seq_file *seq, void *v)
  1893. {
  1894. if (v == SEQ_START_TOKEN) {
  1895. seq_puts(seq, "Local Remote\n");
  1896. } else {
  1897. dn_socket_format_entry(seq, v);
  1898. }
  1899. return 0;
  1900. }
  1901. static struct seq_operations dn_socket_seq_ops = {
  1902. .start = dn_socket_seq_start,
  1903. .next = dn_socket_seq_next,
  1904. .stop = dn_socket_seq_stop,
  1905. .show = dn_socket_seq_show,
  1906. };
  1907. static int dn_socket_seq_open(struct inode *inode, struct file *file)
  1908. {
  1909. struct seq_file *seq;
  1910. int rc = -ENOMEM;
  1911. struct dn_iter_state *s = kmalloc(sizeof(*s), GFP_KERNEL);
  1912. if (!s)
  1913. goto out;
  1914. rc = seq_open(file, &dn_socket_seq_ops);
  1915. if (rc)
  1916. goto out_kfree;
  1917. seq = file->private_data;
  1918. seq->private = s;
  1919. memset(s, 0, sizeof(*s));
  1920. out:
  1921. return rc;
  1922. out_kfree:
  1923. kfree(s);
  1924. goto out;
  1925. }
  1926. static const struct file_operations dn_socket_seq_fops = {
  1927. .owner = THIS_MODULE,
  1928. .open = dn_socket_seq_open,
  1929. .read = seq_read,
  1930. .llseek = seq_lseek,
  1931. .release = seq_release_private,
  1932. };
  1933. #endif
  1934. static struct net_proto_family dn_family_ops = {
  1935. .family = AF_DECnet,
  1936. .create = dn_create,
  1937. .owner = THIS_MODULE,
  1938. };
  1939. static const struct proto_ops dn_proto_ops = {
  1940. .family = AF_DECnet,
  1941. .owner = THIS_MODULE,
  1942. .release = dn_release,
  1943. .bind = dn_bind,
  1944. .connect = dn_connect,
  1945. .socketpair = sock_no_socketpair,
  1946. .accept = dn_accept,
  1947. .getname = dn_getname,
  1948. .poll = dn_poll,
  1949. .ioctl = dn_ioctl,
  1950. .listen = dn_listen,
  1951. .shutdown = dn_shutdown,
  1952. .setsockopt = dn_setsockopt,
  1953. .getsockopt = dn_getsockopt,
  1954. .sendmsg = dn_sendmsg,
  1955. .recvmsg = dn_recvmsg,
  1956. .mmap = sock_no_mmap,
  1957. .sendpage = sock_no_sendpage,
  1958. };
  1959. void dn_register_sysctl(void);
  1960. void dn_unregister_sysctl(void);
  1961. MODULE_DESCRIPTION("The Linux DECnet Network Protocol");
  1962. MODULE_AUTHOR("Linux DECnet Project Team");
  1963. MODULE_LICENSE("GPL");
  1964. MODULE_ALIAS_NETPROTO(PF_DECnet);
  1965. static char banner[] __initdata = KERN_INFO "NET4: DECnet for Linux: V.2.5.68s (C) 1995-2003 Linux DECnet Project Team\n";
  1966. static int __init decnet_init(void)
  1967. {
  1968. int rc;
  1969. printk(banner);
  1970. rc = proto_register(&dn_proto, 1);
  1971. if (rc != 0)
  1972. goto out;
  1973. dn_neigh_init();
  1974. dn_dev_init();
  1975. dn_route_init();
  1976. dn_fib_init();
  1977. sock_register(&dn_family_ops);
  1978. dev_add_pack(&dn_dix_packet_type);
  1979. register_netdevice_notifier(&dn_dev_notifier);
  1980. proc_net_fops_create("decnet", S_IRUGO, &dn_socket_seq_fops);
  1981. dn_register_sysctl();
  1982. out:
  1983. return rc;
  1984. }
  1985. module_init(decnet_init);
  1986. /*
  1987. * Prevent DECnet module unloading until its fixed properly.
  1988. * Requires an audit of the code to check for memory leaks and
  1989. * initialisation problems etc.
  1990. */
  1991. #if 0
  1992. static void __exit decnet_exit(void)
  1993. {
  1994. sock_unregister(AF_DECnet);
  1995. dev_remove_pack(&dn_dix_packet_type);
  1996. dn_unregister_sysctl();
  1997. unregister_netdevice_notifier(&dn_dev_notifier);
  1998. dn_route_cleanup();
  1999. dn_dev_cleanup();
  2000. dn_neigh_cleanup();
  2001. dn_fib_cleanup();
  2002. proc_net_remove("decnet");
  2003. proto_unregister(&dn_proto);
  2004. }
  2005. module_exit(decnet_exit);
  2006. #endif