af_llc.c 29 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180
  1. /*
  2. * af_llc.c - LLC User Interface SAPs
  3. * Description:
  4. * Functions in this module are implementation of socket based llc
  5. * communications for the Linux operating system. Support of llc class
  6. * one and class two is provided via SOCK_DGRAM and SOCK_STREAM
  7. * respectively.
  8. *
  9. * An llc2 connection is (mac + sap), only one llc2 sap connection
  10. * is allowed per mac. Though one sap may have multiple mac + sap
  11. * connections.
  12. *
  13. * Copyright (c) 2001 by Jay Schulist <jschlst@samba.org>
  14. * 2002-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  15. *
  16. * This program can be redistributed or modified under the terms of the
  17. * GNU General Public License as published by the Free Software Foundation.
  18. * This program is distributed without any warranty or implied warranty
  19. * of merchantability or fitness for a particular purpose.
  20. *
  21. * See the GNU General Public License for more details.
  22. */
  23. #include <linux/compiler.h>
  24. #include <linux/kernel.h>
  25. #include <linux/module.h>
  26. #include <linux/rtnetlink.h>
  27. #include <linux/init.h>
  28. #include <net/llc.h>
  29. #include <net/llc_sap.h>
  30. #include <net/llc_pdu.h>
  31. #include <net/llc_conn.h>
  32. #include <net/tcp_states.h>
  33. /* remember: uninitialized global data is zeroed because its in .bss */
  34. static u16 llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
  35. static u16 llc_ui_sap_link_no_max[256];
  36. static struct sockaddr_llc llc_ui_addrnull;
  37. static const struct proto_ops llc_ui_ops;
  38. static int llc_ui_wait_for_conn(struct sock *sk, long timeout);
  39. static int llc_ui_wait_for_disc(struct sock *sk, long timeout);
  40. static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout);
  41. #if 0
  42. #define dprintk(args...) printk(KERN_DEBUG args)
  43. #else
  44. #define dprintk(args...)
  45. #endif
  46. /**
  47. * llc_ui_next_link_no - return the next unused link number for a sap
  48. * @sap: Address of sap to get link number from.
  49. *
  50. * Return the next unused link number for a given sap.
  51. */
  52. static inline u16 llc_ui_next_link_no(int sap)
  53. {
  54. return llc_ui_sap_link_no_max[sap]++;
  55. }
  56. /**
  57. * llc_proto_type - return eth protocol for ARP header type
  58. * @arphrd: ARP header type.
  59. *
  60. * Given an ARP header type return the corresponding ethernet protocol.
  61. */
  62. static inline __be16 llc_proto_type(u16 arphrd)
  63. {
  64. return arphrd == ARPHRD_IEEE802_TR ?
  65. htons(ETH_P_TR_802_2) : htons(ETH_P_802_2);
  66. }
  67. /**
  68. * llc_ui_addr_null - determines if a address structure is null
  69. * @addr: Address to test if null.
  70. */
  71. static inline u8 llc_ui_addr_null(struct sockaddr_llc *addr)
  72. {
  73. return !memcmp(addr, &llc_ui_addrnull, sizeof(*addr));
  74. }
  75. /**
  76. * llc_ui_header_len - return length of llc header based on operation
  77. * @sk: Socket which contains a valid llc socket type.
  78. * @addr: Complete sockaddr_llc structure received from the user.
  79. *
  80. * Provide the length of the llc header depending on what kind of
  81. * operation the user would like to perform and the type of socket.
  82. * Returns the correct llc header length.
  83. */
  84. static inline u8 llc_ui_header_len(struct sock *sk, struct sockaddr_llc *addr)
  85. {
  86. u8 rc = LLC_PDU_LEN_U;
  87. if (addr->sllc_test || addr->sllc_xid)
  88. rc = LLC_PDU_LEN_U;
  89. else if (sk->sk_type == SOCK_STREAM)
  90. rc = LLC_PDU_LEN_I;
  91. return rc;
  92. }
  93. /**
  94. * llc_ui_send_data - send data via reliable llc2 connection
  95. * @sk: Connection the socket is using.
  96. * @skb: Data the user wishes to send.
  97. * @addr: Source and destination fields provided by the user.
  98. * @noblock: can we block waiting for data?
  99. *
  100. * Send data via reliable llc2 connection.
  101. * Returns 0 upon success, non-zero if action did not succeed.
  102. */
  103. static int llc_ui_send_data(struct sock* sk, struct sk_buff *skb, int noblock)
  104. {
  105. struct llc_sock* llc = llc_sk(sk);
  106. int rc = 0;
  107. if (unlikely(llc_data_accept_state(llc->state) ||
  108. llc->remote_busy_flag ||
  109. llc->p_flag)) {
  110. long timeout = sock_sndtimeo(sk, noblock);
  111. rc = llc_ui_wait_for_busy_core(sk, timeout);
  112. }
  113. if (unlikely(!rc))
  114. rc = llc_build_and_send_pkt(sk, skb);
  115. return rc;
  116. }
  117. static void llc_ui_sk_init(struct socket *sock, struct sock *sk)
  118. {
  119. sk->sk_type = sock->type;
  120. sk->sk_sleep = &sock->wait;
  121. sk->sk_socket = sock;
  122. sock->sk = sk;
  123. sock->ops = &llc_ui_ops;
  124. }
  125. static struct proto llc_proto = {
  126. .name = "LLC",
  127. .owner = THIS_MODULE,
  128. .obj_size = sizeof(struct llc_sock),
  129. };
  130. /**
  131. * llc_ui_create - alloc and init a new llc_ui socket
  132. * @sock: Socket to initialize and attach allocated sk to.
  133. * @protocol: Unused.
  134. *
  135. * Allocate and initialize a new llc_ui socket, validate the user wants a
  136. * socket type we have available.
  137. * Returns 0 upon success, negative upon failure.
  138. */
  139. static int llc_ui_create(struct socket *sock, int protocol)
  140. {
  141. struct sock *sk;
  142. int rc = -ESOCKTNOSUPPORT;
  143. if (likely(sock->type == SOCK_DGRAM || sock->type == SOCK_STREAM)) {
  144. rc = -ENOMEM;
  145. sk = llc_sk_alloc(PF_LLC, GFP_KERNEL, &llc_proto);
  146. if (sk) {
  147. rc = 0;
  148. llc_ui_sk_init(sock, sk);
  149. }
  150. }
  151. return rc;
  152. }
  153. /**
  154. * llc_ui_release - shutdown socket
  155. * @sock: Socket to release.
  156. *
  157. * Shutdown and deallocate an existing socket.
  158. */
  159. static int llc_ui_release(struct socket *sock)
  160. {
  161. struct sock *sk = sock->sk;
  162. struct llc_sock *llc;
  163. if (unlikely(sk == NULL))
  164. goto out;
  165. sock_hold(sk);
  166. lock_sock(sk);
  167. llc = llc_sk(sk);
  168. dprintk("%s: closing local(%02X) remote(%02X)\n", __FUNCTION__,
  169. llc->laddr.lsap, llc->daddr.lsap);
  170. if (!llc_send_disc(sk))
  171. llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo);
  172. if (!sock_flag(sk, SOCK_ZAPPED)) {
  173. llc_sap_put(llc->sap);
  174. llc_sap_remove_socket(llc->sap, sk);
  175. }
  176. release_sock(sk);
  177. if (llc->dev)
  178. dev_put(llc->dev);
  179. sock_put(sk);
  180. llc_sk_free(sk);
  181. out:
  182. return 0;
  183. }
  184. /**
  185. * llc_ui_autoport - provide dynamically allocate SAP number
  186. *
  187. * Provide the caller with a dynamically allocated SAP number according
  188. * to the rules that are set in this function. Returns: 0, upon failure,
  189. * SAP number otherwise.
  190. */
  191. static int llc_ui_autoport(void)
  192. {
  193. struct llc_sap *sap;
  194. int i, tries = 0;
  195. while (tries < LLC_SAP_DYN_TRIES) {
  196. for (i = llc_ui_sap_last_autoport;
  197. i < LLC_SAP_DYN_STOP; i += 2) {
  198. sap = llc_sap_find(i);
  199. if (!sap) {
  200. llc_ui_sap_last_autoport = i + 2;
  201. goto out;
  202. }
  203. llc_sap_put(sap);
  204. }
  205. llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
  206. tries++;
  207. }
  208. i = 0;
  209. out:
  210. return i;
  211. }
  212. /**
  213. * llc_ui_autobind - automatically bind a socket to a sap
  214. * @sock: socket to bind
  215. * @addr: address to connect to
  216. *
  217. * Used by llc_ui_connect and llc_ui_sendmsg when the user hasn't
  218. * specifically used llc_ui_bind to bind to an specific address/sap
  219. *
  220. * Returns: 0 upon success, negative otherwise.
  221. */
  222. static int llc_ui_autobind(struct socket *sock, struct sockaddr_llc *addr)
  223. {
  224. struct sock *sk = sock->sk;
  225. struct llc_sock *llc = llc_sk(sk);
  226. struct llc_sap *sap;
  227. int rc = -EINVAL;
  228. if (!sock_flag(sk, SOCK_ZAPPED))
  229. goto out;
  230. rc = -ENODEV;
  231. llc->dev = dev_getfirstbyhwtype(addr->sllc_arphrd);
  232. if (!llc->dev)
  233. goto out;
  234. rc = -EUSERS;
  235. llc->laddr.lsap = llc_ui_autoport();
  236. if (!llc->laddr.lsap)
  237. goto out;
  238. rc = -EBUSY; /* some other network layer is using the sap */
  239. sap = llc_sap_open(llc->laddr.lsap, NULL);
  240. if (!sap)
  241. goto out;
  242. memcpy(llc->laddr.mac, llc->dev->dev_addr, IFHWADDRLEN);
  243. memcpy(&llc->addr, addr, sizeof(llc->addr));
  244. /* assign new connection to its SAP */
  245. llc_sap_add_socket(sap, sk);
  246. sock_reset_flag(sk, SOCK_ZAPPED);
  247. rc = 0;
  248. out:
  249. return rc;
  250. }
  251. /**
  252. * llc_ui_bind - bind a socket to a specific address.
  253. * @sock: Socket to bind an address to.
  254. * @uaddr: Address the user wants the socket bound to.
  255. * @addrlen: Length of the uaddr structure.
  256. *
  257. * Bind a socket to a specific address. For llc a user is able to bind to
  258. * a specific sap only or mac + sap.
  259. * If the user desires to bind to a specific mac + sap, it is possible to
  260. * have multiple sap connections via multiple macs.
  261. * Bind and autobind for that matter must enforce the correct sap usage
  262. * otherwise all hell will break loose.
  263. * Returns: 0 upon success, negative otherwise.
  264. */
  265. static int llc_ui_bind(struct socket *sock, struct sockaddr *uaddr, int addrlen)
  266. {
  267. struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr;
  268. struct sock *sk = sock->sk;
  269. struct llc_sock *llc = llc_sk(sk);
  270. struct llc_sap *sap;
  271. int rc = -EINVAL;
  272. dprintk("%s: binding %02X\n", __FUNCTION__, addr->sllc_sap);
  273. if (unlikely(!sock_flag(sk, SOCK_ZAPPED) || addrlen != sizeof(*addr)))
  274. goto out;
  275. rc = -EAFNOSUPPORT;
  276. if (unlikely(addr->sllc_family != AF_LLC))
  277. goto out;
  278. rc = -ENODEV;
  279. rtnl_lock();
  280. llc->dev = dev_getbyhwaddr(addr->sllc_arphrd, addr->sllc_mac);
  281. rtnl_unlock();
  282. if (!llc->dev)
  283. goto out;
  284. if (!addr->sllc_sap) {
  285. rc = -EUSERS;
  286. addr->sllc_sap = llc_ui_autoport();
  287. if (!addr->sllc_sap)
  288. goto out;
  289. }
  290. sap = llc_sap_find(addr->sllc_sap);
  291. if (!sap) {
  292. sap = llc_sap_open(addr->sllc_sap, NULL);
  293. rc = -EBUSY; /* some other network layer is using the sap */
  294. if (!sap)
  295. goto out;
  296. llc_sap_hold(sap);
  297. } else {
  298. struct llc_addr laddr, daddr;
  299. struct sock *ask;
  300. memset(&laddr, 0, sizeof(laddr));
  301. memset(&daddr, 0, sizeof(daddr));
  302. /*
  303. * FIXME: check if the the address is multicast,
  304. * only SOCK_DGRAM can do this.
  305. */
  306. memcpy(laddr.mac, addr->sllc_mac, IFHWADDRLEN);
  307. laddr.lsap = addr->sllc_sap;
  308. rc = -EADDRINUSE; /* mac + sap clash. */
  309. ask = llc_lookup_established(sap, &daddr, &laddr);
  310. if (ask) {
  311. sock_put(ask);
  312. goto out_put;
  313. }
  314. }
  315. llc->laddr.lsap = addr->sllc_sap;
  316. memcpy(llc->laddr.mac, addr->sllc_mac, IFHWADDRLEN);
  317. memcpy(&llc->addr, addr, sizeof(llc->addr));
  318. /* assign new connection to its SAP */
  319. llc_sap_add_socket(sap, sk);
  320. sock_reset_flag(sk, SOCK_ZAPPED);
  321. rc = 0;
  322. out_put:
  323. llc_sap_put(sap);
  324. out:
  325. return rc;
  326. }
  327. /**
  328. * llc_ui_shutdown - shutdown a connect llc2 socket.
  329. * @sock: Socket to shutdown.
  330. * @how: What part of the socket to shutdown.
  331. *
  332. * Shutdown a connected llc2 socket. Currently this function only supports
  333. * shutting down both sends and receives (2), we could probably make this
  334. * function such that a user can shutdown only half the connection but not
  335. * right now.
  336. * Returns: 0 upon success, negative otherwise.
  337. */
  338. static int llc_ui_shutdown(struct socket *sock, int how)
  339. {
  340. struct sock *sk = sock->sk;
  341. int rc = -ENOTCONN;
  342. lock_sock(sk);
  343. if (unlikely(sk->sk_state != TCP_ESTABLISHED))
  344. goto out;
  345. rc = -EINVAL;
  346. if (how != 2)
  347. goto out;
  348. rc = llc_send_disc(sk);
  349. if (!rc)
  350. rc = llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo);
  351. /* Wake up anyone sleeping in poll */
  352. sk->sk_state_change(sk);
  353. out:
  354. release_sock(sk);
  355. return rc;
  356. }
  357. /**
  358. * llc_ui_connect - Connect to a remote llc2 mac + sap.
  359. * @sock: Socket which will be connected to the remote destination.
  360. * @uaddr: Remote and possibly the local address of the new connection.
  361. * @addrlen: Size of uaddr structure.
  362. * @flags: Operational flags specified by the user.
  363. *
  364. * Connect to a remote llc2 mac + sap. The caller must specify the
  365. * destination mac and address to connect to. If the user hasn't previously
  366. * called bind(2) with a smac the address of the first interface of the
  367. * specified arp type will be used.
  368. * This function will autobind if user did not previously call bind.
  369. * Returns: 0 upon success, negative otherwise.
  370. */
  371. static int llc_ui_connect(struct socket *sock, struct sockaddr *uaddr,
  372. int addrlen, int flags)
  373. {
  374. struct sock *sk = sock->sk;
  375. struct llc_sock *llc = llc_sk(sk);
  376. struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr;
  377. int rc = -EINVAL;
  378. lock_sock(sk);
  379. if (unlikely(addrlen != sizeof(*addr)))
  380. goto out;
  381. rc = -EAFNOSUPPORT;
  382. if (unlikely(addr->sllc_family != AF_LLC))
  383. goto out;
  384. if (unlikely(sk->sk_type != SOCK_STREAM))
  385. goto out;
  386. rc = -EALREADY;
  387. if (unlikely(sock->state == SS_CONNECTING))
  388. goto out;
  389. /* bind connection to sap if user hasn't done it. */
  390. if (sock_flag(sk, SOCK_ZAPPED)) {
  391. /* bind to sap with null dev, exclusive */
  392. rc = llc_ui_autobind(sock, addr);
  393. if (rc)
  394. goto out;
  395. }
  396. llc->daddr.lsap = addr->sllc_sap;
  397. memcpy(llc->daddr.mac, addr->sllc_mac, IFHWADDRLEN);
  398. sock->state = SS_CONNECTING;
  399. sk->sk_state = TCP_SYN_SENT;
  400. llc->link = llc_ui_next_link_no(llc->sap->laddr.lsap);
  401. rc = llc_establish_connection(sk, llc->dev->dev_addr,
  402. addr->sllc_mac, addr->sllc_sap);
  403. if (rc) {
  404. dprintk("%s: llc_ui_send_conn failed :-(\n", __FUNCTION__);
  405. sock->state = SS_UNCONNECTED;
  406. sk->sk_state = TCP_CLOSE;
  407. goto out;
  408. }
  409. if (sk->sk_state == TCP_SYN_SENT) {
  410. const long timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
  411. if (!timeo || !llc_ui_wait_for_conn(sk, timeo))
  412. goto out;
  413. rc = sock_intr_errno(timeo);
  414. if (signal_pending(current))
  415. goto out;
  416. }
  417. if (sk->sk_state == TCP_CLOSE)
  418. goto sock_error;
  419. sock->state = SS_CONNECTED;
  420. rc = 0;
  421. out:
  422. release_sock(sk);
  423. return rc;
  424. sock_error:
  425. rc = sock_error(sk) ? : -ECONNABORTED;
  426. sock->state = SS_UNCONNECTED;
  427. goto out;
  428. }
  429. /**
  430. * llc_ui_listen - allow a normal socket to accept incoming connections
  431. * @sock: Socket to allow incoming connections on.
  432. * @backlog: Number of connections to queue.
  433. *
  434. * Allow a normal socket to accept incoming connections.
  435. * Returns 0 upon success, negative otherwise.
  436. */
  437. static int llc_ui_listen(struct socket *sock, int backlog)
  438. {
  439. struct sock *sk = sock->sk;
  440. int rc = -EINVAL;
  441. lock_sock(sk);
  442. if (unlikely(sock->state != SS_UNCONNECTED))
  443. goto out;
  444. rc = -EOPNOTSUPP;
  445. if (unlikely(sk->sk_type != SOCK_STREAM))
  446. goto out;
  447. rc = -EAGAIN;
  448. if (sock_flag(sk, SOCK_ZAPPED))
  449. goto out;
  450. rc = 0;
  451. if (!(unsigned)backlog) /* BSDism */
  452. backlog = 1;
  453. sk->sk_max_ack_backlog = backlog;
  454. if (sk->sk_state != TCP_LISTEN) {
  455. sk->sk_ack_backlog = 0;
  456. sk->sk_state = TCP_LISTEN;
  457. }
  458. sk->sk_socket->flags |= __SO_ACCEPTCON;
  459. out:
  460. release_sock(sk);
  461. return rc;
  462. }
  463. static int llc_ui_wait_for_disc(struct sock *sk, long timeout)
  464. {
  465. DEFINE_WAIT(wait);
  466. int rc = 0;
  467. while (1) {
  468. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  469. if (sk_wait_event(sk, &timeout, sk->sk_state == TCP_CLOSE))
  470. break;
  471. rc = -ERESTARTSYS;
  472. if (signal_pending(current))
  473. break;
  474. rc = -EAGAIN;
  475. if (!timeout)
  476. break;
  477. rc = 0;
  478. }
  479. finish_wait(sk->sk_sleep, &wait);
  480. return rc;
  481. }
  482. static int llc_ui_wait_for_conn(struct sock *sk, long timeout)
  483. {
  484. DEFINE_WAIT(wait);
  485. while (1) {
  486. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  487. if (sk_wait_event(sk, &timeout, sk->sk_state != TCP_SYN_SENT))
  488. break;
  489. if (signal_pending(current) || !timeout)
  490. break;
  491. }
  492. finish_wait(sk->sk_sleep, &wait);
  493. return timeout;
  494. }
  495. static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout)
  496. {
  497. DEFINE_WAIT(wait);
  498. struct llc_sock *llc = llc_sk(sk);
  499. int rc;
  500. while (1) {
  501. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  502. rc = 0;
  503. if (sk_wait_event(sk, &timeout,
  504. (sk->sk_shutdown & RCV_SHUTDOWN) ||
  505. (!llc_data_accept_state(llc->state) &&
  506. !llc->remote_busy_flag &&
  507. !llc->p_flag)))
  508. break;
  509. rc = -ERESTARTSYS;
  510. if (signal_pending(current))
  511. break;
  512. rc = -EAGAIN;
  513. if (!timeout)
  514. break;
  515. }
  516. finish_wait(sk->sk_sleep, &wait);
  517. return rc;
  518. }
  519. static int llc_wait_data(struct sock *sk, long timeo)
  520. {
  521. int rc;
  522. while (1) {
  523. /*
  524. * POSIX 1003.1g mandates this order.
  525. */
  526. rc = sock_error(sk);
  527. if (rc)
  528. break;
  529. rc = 0;
  530. if (sk->sk_shutdown & RCV_SHUTDOWN)
  531. break;
  532. rc = -EAGAIN;
  533. if (!timeo)
  534. break;
  535. rc = sock_intr_errno(timeo);
  536. if (signal_pending(current))
  537. break;
  538. rc = 0;
  539. if (sk_wait_data(sk, &timeo))
  540. break;
  541. }
  542. return rc;
  543. }
  544. /**
  545. * llc_ui_accept - accept a new incoming connection.
  546. * @sock: Socket which connections arrive on.
  547. * @newsock: Socket to move incoming connection to.
  548. * @flags: User specified operational flags.
  549. *
  550. * Accept a new incoming connection.
  551. * Returns 0 upon success, negative otherwise.
  552. */
  553. static int llc_ui_accept(struct socket *sock, struct socket *newsock, int flags)
  554. {
  555. struct sock *sk = sock->sk, *newsk;
  556. struct llc_sock *llc, *newllc;
  557. struct sk_buff *skb;
  558. int rc = -EOPNOTSUPP;
  559. dprintk("%s: accepting on %02X\n", __FUNCTION__,
  560. llc_sk(sk)->laddr.lsap);
  561. lock_sock(sk);
  562. if (unlikely(sk->sk_type != SOCK_STREAM))
  563. goto out;
  564. rc = -EINVAL;
  565. if (unlikely(sock->state != SS_UNCONNECTED ||
  566. sk->sk_state != TCP_LISTEN))
  567. goto out;
  568. /* wait for a connection to arrive. */
  569. if (skb_queue_empty(&sk->sk_receive_queue)) {
  570. rc = llc_wait_data(sk, sk->sk_rcvtimeo);
  571. if (rc)
  572. goto out;
  573. }
  574. dprintk("%s: got a new connection on %02X\n", __FUNCTION__,
  575. llc_sk(sk)->laddr.lsap);
  576. skb = skb_dequeue(&sk->sk_receive_queue);
  577. rc = -EINVAL;
  578. if (!skb->sk)
  579. goto frees;
  580. rc = 0;
  581. newsk = skb->sk;
  582. /* attach connection to a new socket. */
  583. llc_ui_sk_init(newsock, newsk);
  584. sock_reset_flag(newsk, SOCK_ZAPPED);
  585. newsk->sk_state = TCP_ESTABLISHED;
  586. newsock->state = SS_CONNECTED;
  587. llc = llc_sk(sk);
  588. newllc = llc_sk(newsk);
  589. memcpy(&newllc->addr, &llc->addr, sizeof(newllc->addr));
  590. newllc->link = llc_ui_next_link_no(newllc->laddr.lsap);
  591. /* put original socket back into a clean listen state. */
  592. sk->sk_state = TCP_LISTEN;
  593. sk->sk_ack_backlog--;
  594. dprintk("%s: ok success on %02X, client on %02X\n", __FUNCTION__,
  595. llc_sk(sk)->addr.sllc_sap, newllc->daddr.lsap);
  596. frees:
  597. kfree_skb(skb);
  598. out:
  599. release_sock(sk);
  600. return rc;
  601. }
  602. /**
  603. * llc_ui_recvmsg - copy received data to the socket user.
  604. * @sock: Socket to copy data from.
  605. * @msg: Various user space related information.
  606. * @len: Size of user buffer.
  607. * @flags: User specified flags.
  608. *
  609. * Copy received data to the socket user.
  610. * Returns non-negative upon success, negative otherwise.
  611. */
  612. static int llc_ui_recvmsg(struct kiocb *iocb, struct socket *sock,
  613. struct msghdr *msg, size_t len, int flags)
  614. {
  615. struct sockaddr_llc *uaddr = (struct sockaddr_llc *)msg->msg_name;
  616. const int nonblock = flags & MSG_DONTWAIT;
  617. struct sk_buff *skb = NULL;
  618. struct sock *sk = sock->sk;
  619. struct llc_sock *llc = llc_sk(sk);
  620. size_t copied = 0;
  621. u32 peek_seq = 0;
  622. u32 *seq;
  623. unsigned long used;
  624. int target; /* Read at least this many bytes */
  625. long timeo;
  626. lock_sock(sk);
  627. copied = -ENOTCONN;
  628. if (unlikely(sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_LISTEN))
  629. goto out;
  630. timeo = sock_rcvtimeo(sk, nonblock);
  631. seq = &llc->copied_seq;
  632. if (flags & MSG_PEEK) {
  633. peek_seq = llc->copied_seq;
  634. seq = &peek_seq;
  635. }
  636. target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
  637. copied = 0;
  638. do {
  639. u32 offset;
  640. /*
  641. * We need to check signals first, to get correct SIGURG
  642. * handling. FIXME: Need to check this doesn't impact 1003.1g
  643. * and move it down to the bottom of the loop
  644. */
  645. if (signal_pending(current)) {
  646. if (copied)
  647. break;
  648. copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;
  649. break;
  650. }
  651. /* Next get a buffer. */
  652. skb = skb_peek(&sk->sk_receive_queue);
  653. if (skb) {
  654. offset = *seq;
  655. goto found_ok_skb;
  656. }
  657. /* Well, if we have backlog, try to process it now yet. */
  658. if (copied >= target && !sk->sk_backlog.tail)
  659. break;
  660. if (copied) {
  661. if (sk->sk_err ||
  662. sk->sk_state == TCP_CLOSE ||
  663. (sk->sk_shutdown & RCV_SHUTDOWN) ||
  664. !timeo ||
  665. (flags & MSG_PEEK))
  666. break;
  667. } else {
  668. if (sock_flag(sk, SOCK_DONE))
  669. break;
  670. if (sk->sk_err) {
  671. copied = sock_error(sk);
  672. break;
  673. }
  674. if (sk->sk_shutdown & RCV_SHUTDOWN)
  675. break;
  676. if (sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_CLOSE) {
  677. if (!sock_flag(sk, SOCK_DONE)) {
  678. /*
  679. * This occurs when user tries to read
  680. * from never connected socket.
  681. */
  682. copied = -ENOTCONN;
  683. break;
  684. }
  685. break;
  686. }
  687. if (!timeo) {
  688. copied = -EAGAIN;
  689. break;
  690. }
  691. }
  692. if (copied >= target) { /* Do not sleep, just process backlog. */
  693. release_sock(sk);
  694. lock_sock(sk);
  695. } else
  696. sk_wait_data(sk, &timeo);
  697. if ((flags & MSG_PEEK) && peek_seq != llc->copied_seq) {
  698. if (net_ratelimit())
  699. printk(KERN_DEBUG "LLC(%s:%d): Application "
  700. "bug, race in MSG_PEEK.\n",
  701. current->comm, current->pid);
  702. peek_seq = llc->copied_seq;
  703. }
  704. continue;
  705. found_ok_skb:
  706. /* Ok so how much can we use? */
  707. used = skb->len - offset;
  708. if (len < used)
  709. used = len;
  710. if (!(flags & MSG_TRUNC)) {
  711. int rc = skb_copy_datagram_iovec(skb, offset,
  712. msg->msg_iov, used);
  713. if (rc) {
  714. /* Exception. Bailout! */
  715. if (!copied)
  716. copied = -EFAULT;
  717. break;
  718. }
  719. }
  720. *seq += used;
  721. copied += used;
  722. len -= used;
  723. if (!(flags & MSG_PEEK)) {
  724. sk_eat_skb(sk, skb, 0);
  725. *seq = 0;
  726. }
  727. /* For non stream protcols we get one packet per recvmsg call */
  728. if (sk->sk_type != SOCK_STREAM)
  729. goto copy_uaddr;
  730. /* Partial read */
  731. if (used + offset < skb->len)
  732. continue;
  733. } while (len > 0);
  734. out:
  735. release_sock(sk);
  736. return copied;
  737. copy_uaddr:
  738. if (uaddr != NULL && skb != NULL) {
  739. memcpy(uaddr, llc_ui_skb_cb(skb), sizeof(*uaddr));
  740. msg->msg_namelen = sizeof(*uaddr);
  741. }
  742. goto out;
  743. }
  744. /**
  745. * llc_ui_sendmsg - Transmit data provided by the socket user.
  746. * @sock: Socket to transmit data from.
  747. * @msg: Various user related information.
  748. * @len: Length of data to transmit.
  749. *
  750. * Transmit data provided by the socket user.
  751. * Returns non-negative upon success, negative otherwise.
  752. */
  753. static int llc_ui_sendmsg(struct kiocb *iocb, struct socket *sock,
  754. struct msghdr *msg, size_t len)
  755. {
  756. struct sock *sk = sock->sk;
  757. struct llc_sock *llc = llc_sk(sk);
  758. struct sockaddr_llc *addr = (struct sockaddr_llc *)msg->msg_name;
  759. int flags = msg->msg_flags;
  760. int noblock = flags & MSG_DONTWAIT;
  761. struct sk_buff *skb;
  762. size_t size = 0;
  763. int rc = -EINVAL, copied = 0, hdrlen;
  764. dprintk("%s: sending from %02X to %02X\n", __FUNCTION__,
  765. llc->laddr.lsap, llc->daddr.lsap);
  766. lock_sock(sk);
  767. if (addr) {
  768. if (msg->msg_namelen < sizeof(*addr))
  769. goto release;
  770. } else {
  771. if (llc_ui_addr_null(&llc->addr))
  772. goto release;
  773. addr = &llc->addr;
  774. }
  775. /* must bind connection to sap if user hasn't done it. */
  776. if (sock_flag(sk, SOCK_ZAPPED)) {
  777. /* bind to sap with null dev, exclusive. */
  778. rc = llc_ui_autobind(sock, addr);
  779. if (rc)
  780. goto release;
  781. }
  782. hdrlen = llc->dev->hard_header_len + llc_ui_header_len(sk, addr);
  783. size = hdrlen + len;
  784. if (size > llc->dev->mtu)
  785. size = llc->dev->mtu;
  786. copied = size - hdrlen;
  787. release_sock(sk);
  788. skb = sock_alloc_send_skb(sk, size, noblock, &rc);
  789. lock_sock(sk);
  790. if (!skb)
  791. goto release;
  792. skb->dev = llc->dev;
  793. skb->protocol = llc_proto_type(addr->sllc_arphrd);
  794. skb_reserve(skb, hdrlen);
  795. rc = memcpy_fromiovec(skb_put(skb, copied), msg->msg_iov, copied);
  796. if (rc)
  797. goto out;
  798. if (sk->sk_type == SOCK_DGRAM || addr->sllc_ua) {
  799. llc_build_and_send_ui_pkt(llc->sap, skb, addr->sllc_mac,
  800. addr->sllc_sap);
  801. goto out;
  802. }
  803. if (addr->sllc_test) {
  804. llc_build_and_send_test_pkt(llc->sap, skb, addr->sllc_mac,
  805. addr->sllc_sap);
  806. goto out;
  807. }
  808. if (addr->sllc_xid) {
  809. llc_build_and_send_xid_pkt(llc->sap, skb, addr->sllc_mac,
  810. addr->sllc_sap);
  811. goto out;
  812. }
  813. rc = -ENOPROTOOPT;
  814. if (!(sk->sk_type == SOCK_STREAM && !addr->sllc_ua))
  815. goto out;
  816. rc = llc_ui_send_data(sk, skb, noblock);
  817. out:
  818. if (rc) {
  819. kfree_skb(skb);
  820. release:
  821. dprintk("%s: failed sending from %02X to %02X: %d\n",
  822. __FUNCTION__, llc->laddr.lsap, llc->daddr.lsap, rc);
  823. }
  824. release_sock(sk);
  825. return rc ? : copied;
  826. }
  827. /**
  828. * llc_ui_getname - return the address info of a socket
  829. * @sock: Socket to get address of.
  830. * @uaddr: Address structure to return information.
  831. * @uaddrlen: Length of address structure.
  832. * @peer: Does user want local or remote address information.
  833. *
  834. * Return the address information of a socket.
  835. */
  836. static int llc_ui_getname(struct socket *sock, struct sockaddr *uaddr,
  837. int *uaddrlen, int peer)
  838. {
  839. struct sockaddr_llc sllc;
  840. struct sock *sk = sock->sk;
  841. struct llc_sock *llc = llc_sk(sk);
  842. int rc = 0;
  843. lock_sock(sk);
  844. if (sock_flag(sk, SOCK_ZAPPED))
  845. goto out;
  846. *uaddrlen = sizeof(sllc);
  847. memset(uaddr, 0, *uaddrlen);
  848. if (peer) {
  849. rc = -ENOTCONN;
  850. if (sk->sk_state != TCP_ESTABLISHED)
  851. goto out;
  852. if(llc->dev)
  853. sllc.sllc_arphrd = llc->dev->type;
  854. sllc.sllc_sap = llc->daddr.lsap;
  855. memcpy(&sllc.sllc_mac, &llc->daddr.mac, IFHWADDRLEN);
  856. } else {
  857. rc = -EINVAL;
  858. if (!llc->sap)
  859. goto out;
  860. sllc.sllc_sap = llc->sap->laddr.lsap;
  861. if (llc->dev) {
  862. sllc.sllc_arphrd = llc->dev->type;
  863. memcpy(&sllc.sllc_mac, &llc->dev->dev_addr,
  864. IFHWADDRLEN);
  865. }
  866. }
  867. rc = 0;
  868. sllc.sllc_family = AF_LLC;
  869. memcpy(uaddr, &sllc, sizeof(sllc));
  870. out:
  871. release_sock(sk);
  872. return rc;
  873. }
  874. /**
  875. * llc_ui_ioctl - io controls for PF_LLC
  876. * @sock: Socket to get/set info
  877. * @cmd: command
  878. * @arg: optional argument for cmd
  879. *
  880. * get/set info on llc sockets
  881. */
  882. static int llc_ui_ioctl(struct socket *sock, unsigned int cmd,
  883. unsigned long arg)
  884. {
  885. return -ENOIOCTLCMD;
  886. }
  887. /**
  888. * llc_ui_setsockopt - set various connection specific parameters.
  889. * @sock: Socket to set options on.
  890. * @level: Socket level user is requesting operations on.
  891. * @optname: Operation name.
  892. * @optval User provided operation data.
  893. * @optlen: Length of optval.
  894. *
  895. * Set various connection specific parameters.
  896. */
  897. static int llc_ui_setsockopt(struct socket *sock, int level, int optname,
  898. char __user *optval, int optlen)
  899. {
  900. struct sock *sk = sock->sk;
  901. struct llc_sock *llc = llc_sk(sk);
  902. int rc = -EINVAL, opt;
  903. lock_sock(sk);
  904. if (unlikely(level != SOL_LLC || optlen != sizeof(int)))
  905. goto out;
  906. rc = get_user(opt, (int __user *)optval);
  907. if (rc)
  908. goto out;
  909. rc = -EINVAL;
  910. switch (optname) {
  911. case LLC_OPT_RETRY:
  912. if (opt > LLC_OPT_MAX_RETRY)
  913. goto out;
  914. llc->n2 = opt;
  915. break;
  916. case LLC_OPT_SIZE:
  917. if (opt > LLC_OPT_MAX_SIZE)
  918. goto out;
  919. llc->n1 = opt;
  920. break;
  921. case LLC_OPT_ACK_TMR_EXP:
  922. if (opt > LLC_OPT_MAX_ACK_TMR_EXP)
  923. goto out;
  924. llc->ack_timer.expire = opt * HZ;
  925. break;
  926. case LLC_OPT_P_TMR_EXP:
  927. if (opt > LLC_OPT_MAX_P_TMR_EXP)
  928. goto out;
  929. llc->pf_cycle_timer.expire = opt * HZ;
  930. break;
  931. case LLC_OPT_REJ_TMR_EXP:
  932. if (opt > LLC_OPT_MAX_REJ_TMR_EXP)
  933. goto out;
  934. llc->rej_sent_timer.expire = opt * HZ;
  935. break;
  936. case LLC_OPT_BUSY_TMR_EXP:
  937. if (opt > LLC_OPT_MAX_BUSY_TMR_EXP)
  938. goto out;
  939. llc->busy_state_timer.expire = opt * HZ;
  940. break;
  941. case LLC_OPT_TX_WIN:
  942. if (opt > LLC_OPT_MAX_WIN)
  943. goto out;
  944. llc->k = opt;
  945. break;
  946. case LLC_OPT_RX_WIN:
  947. if (opt > LLC_OPT_MAX_WIN)
  948. goto out;
  949. llc->rw = opt;
  950. break;
  951. default:
  952. rc = -ENOPROTOOPT;
  953. goto out;
  954. }
  955. rc = 0;
  956. out:
  957. release_sock(sk);
  958. return rc;
  959. }
  960. /**
  961. * llc_ui_getsockopt - get connection specific socket info
  962. * @sock: Socket to get information from.
  963. * @level: Socket level user is requesting operations on.
  964. * @optname: Operation name.
  965. * @optval: Variable to return operation data in.
  966. * @optlen: Length of optval.
  967. *
  968. * Get connection specific socket information.
  969. */
  970. static int llc_ui_getsockopt(struct socket *sock, int level, int optname,
  971. char __user *optval, int __user *optlen)
  972. {
  973. struct sock *sk = sock->sk;
  974. struct llc_sock *llc = llc_sk(sk);
  975. int val = 0, len = 0, rc = -EINVAL;
  976. lock_sock(sk);
  977. if (unlikely(level != SOL_LLC))
  978. goto out;
  979. rc = get_user(len, optlen);
  980. if (rc)
  981. goto out;
  982. rc = -EINVAL;
  983. if (len != sizeof(int))
  984. goto out;
  985. switch (optname) {
  986. case LLC_OPT_RETRY:
  987. val = llc->n2; break;
  988. case LLC_OPT_SIZE:
  989. val = llc->n1; break;
  990. case LLC_OPT_ACK_TMR_EXP:
  991. val = llc->ack_timer.expire / HZ; break;
  992. case LLC_OPT_P_TMR_EXP:
  993. val = llc->pf_cycle_timer.expire / HZ; break;
  994. case LLC_OPT_REJ_TMR_EXP:
  995. val = llc->rej_sent_timer.expire / HZ; break;
  996. case LLC_OPT_BUSY_TMR_EXP:
  997. val = llc->busy_state_timer.expire / HZ; break;
  998. case LLC_OPT_TX_WIN:
  999. val = llc->k; break;
  1000. case LLC_OPT_RX_WIN:
  1001. val = llc->rw; break;
  1002. default:
  1003. rc = -ENOPROTOOPT;
  1004. goto out;
  1005. }
  1006. rc = 0;
  1007. if (put_user(len, optlen) || copy_to_user(optval, &val, len))
  1008. rc = -EFAULT;
  1009. out:
  1010. release_sock(sk);
  1011. return rc;
  1012. }
  1013. static struct net_proto_family llc_ui_family_ops = {
  1014. .family = PF_LLC,
  1015. .create = llc_ui_create,
  1016. .owner = THIS_MODULE,
  1017. };
  1018. static const struct proto_ops llc_ui_ops = {
  1019. .family = PF_LLC,
  1020. .owner = THIS_MODULE,
  1021. .release = llc_ui_release,
  1022. .bind = llc_ui_bind,
  1023. .connect = llc_ui_connect,
  1024. .socketpair = sock_no_socketpair,
  1025. .accept = llc_ui_accept,
  1026. .getname = llc_ui_getname,
  1027. .poll = datagram_poll,
  1028. .ioctl = llc_ui_ioctl,
  1029. .listen = llc_ui_listen,
  1030. .shutdown = llc_ui_shutdown,
  1031. .setsockopt = llc_ui_setsockopt,
  1032. .getsockopt = llc_ui_getsockopt,
  1033. .sendmsg = llc_ui_sendmsg,
  1034. .recvmsg = llc_ui_recvmsg,
  1035. .mmap = sock_no_mmap,
  1036. .sendpage = sock_no_sendpage,
  1037. };
  1038. static char llc_proc_err_msg[] __initdata =
  1039. KERN_CRIT "LLC: Unable to register the proc_fs entries\n";
  1040. static char llc_sysctl_err_msg[] __initdata =
  1041. KERN_CRIT "LLC: Unable to register the sysctl entries\n";
  1042. static char llc_sock_err_msg[] __initdata =
  1043. KERN_CRIT "LLC: Unable to register the network family\n";
  1044. static int __init llc2_init(void)
  1045. {
  1046. int rc = proto_register(&llc_proto, 0);
  1047. if (rc != 0)
  1048. goto out;
  1049. llc_build_offset_table();
  1050. llc_station_init();
  1051. llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
  1052. rc = llc_proc_init();
  1053. if (rc != 0) {
  1054. printk(llc_proc_err_msg);
  1055. goto out_unregister_llc_proto;
  1056. }
  1057. rc = llc_sysctl_init();
  1058. if (rc) {
  1059. printk(llc_sysctl_err_msg);
  1060. goto out_proc;
  1061. }
  1062. rc = sock_register(&llc_ui_family_ops);
  1063. if (rc) {
  1064. printk(llc_sock_err_msg);
  1065. goto out_sysctl;
  1066. }
  1067. llc_add_pack(LLC_DEST_SAP, llc_sap_handler);
  1068. llc_add_pack(LLC_DEST_CONN, llc_conn_handler);
  1069. out:
  1070. return rc;
  1071. out_sysctl:
  1072. llc_sysctl_exit();
  1073. out_proc:
  1074. llc_proc_exit();
  1075. out_unregister_llc_proto:
  1076. proto_unregister(&llc_proto);
  1077. goto out;
  1078. }
  1079. static void __exit llc2_exit(void)
  1080. {
  1081. llc_station_exit();
  1082. llc_remove_pack(LLC_DEST_SAP);
  1083. llc_remove_pack(LLC_DEST_CONN);
  1084. sock_unregister(PF_LLC);
  1085. llc_proc_exit();
  1086. llc_sysctl_exit();
  1087. proto_unregister(&llc_proto);
  1088. }
  1089. module_init(llc2_init);
  1090. module_exit(llc2_exit);
  1091. MODULE_LICENSE("GPL");
  1092. MODULE_AUTHOR("Procom 1997, Jay Schullist 2001, Arnaldo C. Melo 2001-2003");
  1093. MODULE_DESCRIPTION("IEEE 802.2 PF_LLC support");
  1094. MODULE_ALIAS_NETPROTO(PF_LLC);