af_llc.c 32 KB

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