sock.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759
  1. /*
  2. * Copyright (C) 2011 Intel Corporation. All rights reserved.
  3. *
  4. * This program is free software; you can redistribute it and/or modify
  5. * it under the terms of the GNU General Public License as published by
  6. * the Free Software Foundation; either version 2 of the License, or
  7. * (at your option) any later version.
  8. *
  9. * This program is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write to the
  16. * Free Software Foundation, Inc.,
  17. * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. */
  19. #define pr_fmt(fmt) "llcp: %s: " fmt, __func__
  20. #include <linux/init.h>
  21. #include <linux/kernel.h>
  22. #include <linux/module.h>
  23. #include <linux/nfc.h>
  24. #include "../nfc.h"
  25. #include "llcp.h"
  26. static int sock_wait_state(struct sock *sk, int state, unsigned long timeo)
  27. {
  28. DECLARE_WAITQUEUE(wait, current);
  29. int err = 0;
  30. pr_debug("sk %p", sk);
  31. add_wait_queue(sk_sleep(sk), &wait);
  32. set_current_state(TASK_INTERRUPTIBLE);
  33. while (sk->sk_state != state) {
  34. if (!timeo) {
  35. err = -EINPROGRESS;
  36. break;
  37. }
  38. if (signal_pending(current)) {
  39. err = sock_intr_errno(timeo);
  40. break;
  41. }
  42. release_sock(sk);
  43. timeo = schedule_timeout(timeo);
  44. lock_sock(sk);
  45. set_current_state(TASK_INTERRUPTIBLE);
  46. err = sock_error(sk);
  47. if (err)
  48. break;
  49. }
  50. __set_current_state(TASK_RUNNING);
  51. remove_wait_queue(sk_sleep(sk), &wait);
  52. return err;
  53. }
  54. static struct proto llcp_sock_proto = {
  55. .name = "NFC_LLCP",
  56. .owner = THIS_MODULE,
  57. .obj_size = sizeof(struct nfc_llcp_sock),
  58. };
  59. static int llcp_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
  60. {
  61. struct sock *sk = sock->sk;
  62. struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
  63. struct nfc_llcp_local *local;
  64. struct nfc_dev *dev;
  65. struct sockaddr_nfc_llcp llcp_addr;
  66. int len, ret = 0;
  67. pr_debug("sk %p addr %p family %d\n", sk, addr, addr->sa_family);
  68. if (!addr || addr->sa_family != AF_NFC)
  69. return -EINVAL;
  70. memset(&llcp_addr, 0, sizeof(llcp_addr));
  71. len = min_t(unsigned int, sizeof(llcp_addr), alen);
  72. memcpy(&llcp_addr, addr, len);
  73. /* This is going to be a listening socket, dsap must be 0 */
  74. if (llcp_addr.dsap != 0)
  75. return -EINVAL;
  76. lock_sock(sk);
  77. if (sk->sk_state != LLCP_CLOSED) {
  78. ret = -EBADFD;
  79. goto error;
  80. }
  81. dev = nfc_get_device(llcp_addr.dev_idx);
  82. if (dev == NULL) {
  83. ret = -ENODEV;
  84. goto error;
  85. }
  86. local = nfc_llcp_find_local(dev);
  87. if (local == NULL) {
  88. ret = -ENODEV;
  89. goto put_dev;
  90. }
  91. llcp_sock->dev = dev;
  92. llcp_sock->local = local;
  93. llcp_sock->nfc_protocol = llcp_addr.nfc_protocol;
  94. llcp_sock->service_name_len = min_t(unsigned int,
  95. llcp_addr.service_name_len,
  96. NFC_LLCP_MAX_SERVICE_NAME);
  97. llcp_sock->service_name = kmemdup(llcp_addr.service_name,
  98. llcp_sock->service_name_len,
  99. GFP_KERNEL);
  100. llcp_sock->ssap = nfc_llcp_get_sdp_ssap(local, llcp_sock);
  101. if (llcp_sock->ssap == LLCP_MAX_SAP)
  102. goto put_dev;
  103. local->sockets[llcp_sock->ssap] = llcp_sock;
  104. pr_debug("Socket bound to SAP %d\n", llcp_sock->ssap);
  105. sk->sk_state = LLCP_BOUND;
  106. put_dev:
  107. nfc_put_device(dev);
  108. error:
  109. release_sock(sk);
  110. return ret;
  111. }
  112. static int llcp_sock_listen(struct socket *sock, int backlog)
  113. {
  114. struct sock *sk = sock->sk;
  115. int ret = 0;
  116. pr_debug("sk %p backlog %d\n", sk, backlog);
  117. lock_sock(sk);
  118. if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
  119. || sk->sk_state != LLCP_BOUND) {
  120. ret = -EBADFD;
  121. goto error;
  122. }
  123. sk->sk_max_ack_backlog = backlog;
  124. sk->sk_ack_backlog = 0;
  125. pr_debug("Socket listening\n");
  126. sk->sk_state = LLCP_LISTEN;
  127. error:
  128. release_sock(sk);
  129. return ret;
  130. }
  131. void nfc_llcp_accept_unlink(struct sock *sk)
  132. {
  133. struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
  134. pr_debug("state %d\n", sk->sk_state);
  135. list_del_init(&llcp_sock->accept_queue);
  136. sk_acceptq_removed(llcp_sock->parent);
  137. llcp_sock->parent = NULL;
  138. sock_put(sk);
  139. }
  140. void nfc_llcp_accept_enqueue(struct sock *parent, struct sock *sk)
  141. {
  142. struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
  143. struct nfc_llcp_sock *llcp_sock_parent = nfc_llcp_sock(parent);
  144. /* Lock will be free from unlink */
  145. sock_hold(sk);
  146. list_add_tail(&llcp_sock->accept_queue,
  147. &llcp_sock_parent->accept_queue);
  148. llcp_sock->parent = parent;
  149. sk_acceptq_added(parent);
  150. }
  151. struct sock *nfc_llcp_accept_dequeue(struct sock *parent,
  152. struct socket *newsock)
  153. {
  154. struct nfc_llcp_sock *lsk, *n, *llcp_parent;
  155. struct sock *sk;
  156. llcp_parent = nfc_llcp_sock(parent);
  157. list_for_each_entry_safe(lsk, n, &llcp_parent->accept_queue,
  158. accept_queue) {
  159. sk = &lsk->sk;
  160. lock_sock(sk);
  161. if (sk->sk_state == LLCP_CLOSED) {
  162. release_sock(sk);
  163. nfc_llcp_accept_unlink(sk);
  164. continue;
  165. }
  166. if (sk->sk_state == LLCP_CONNECTED || !newsock) {
  167. nfc_llcp_accept_unlink(sk);
  168. if (newsock)
  169. sock_graft(sk, newsock);
  170. release_sock(sk);
  171. pr_debug("Returning sk state %d\n", sk->sk_state);
  172. return sk;
  173. }
  174. release_sock(sk);
  175. }
  176. return NULL;
  177. }
  178. static int llcp_sock_accept(struct socket *sock, struct socket *newsock,
  179. int flags)
  180. {
  181. DECLARE_WAITQUEUE(wait, current);
  182. struct sock *sk = sock->sk, *new_sk;
  183. long timeo;
  184. int ret = 0;
  185. pr_debug("parent %p\n", sk);
  186. lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
  187. if (sk->sk_state != LLCP_LISTEN) {
  188. ret = -EBADFD;
  189. goto error;
  190. }
  191. timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
  192. /* Wait for an incoming connection. */
  193. add_wait_queue_exclusive(sk_sleep(sk), &wait);
  194. while (!(new_sk = nfc_llcp_accept_dequeue(sk, newsock))) {
  195. set_current_state(TASK_INTERRUPTIBLE);
  196. if (!timeo) {
  197. ret = -EAGAIN;
  198. break;
  199. }
  200. if (signal_pending(current)) {
  201. ret = sock_intr_errno(timeo);
  202. break;
  203. }
  204. release_sock(sk);
  205. timeo = schedule_timeout(timeo);
  206. lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
  207. }
  208. __set_current_state(TASK_RUNNING);
  209. remove_wait_queue(sk_sleep(sk), &wait);
  210. if (ret)
  211. goto error;
  212. newsock->state = SS_CONNECTED;
  213. pr_debug("new socket %p\n", new_sk);
  214. error:
  215. release_sock(sk);
  216. return ret;
  217. }
  218. static int llcp_sock_getname(struct socket *sock, struct sockaddr *addr,
  219. int *len, int peer)
  220. {
  221. struct sockaddr_nfc_llcp *llcp_addr = (struct sockaddr_nfc_llcp *)addr;
  222. struct sock *sk = sock->sk;
  223. struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
  224. pr_debug("%p\n", sk);
  225. if (llcp_sock == NULL || llcp_sock->dev == NULL)
  226. return -EBADFD;
  227. addr->sa_family = AF_NFC;
  228. *len = sizeof(struct sockaddr_nfc_llcp);
  229. llcp_addr->dev_idx = llcp_sock->dev->idx;
  230. llcp_addr->dsap = llcp_sock->dsap;
  231. llcp_addr->ssap = llcp_sock->ssap;
  232. llcp_addr->service_name_len = llcp_sock->service_name_len;
  233. memcpy(llcp_addr->service_name, llcp_sock->service_name,
  234. llcp_addr->service_name_len);
  235. return 0;
  236. }
  237. static inline unsigned int llcp_accept_poll(struct sock *parent)
  238. {
  239. struct nfc_llcp_sock *llcp_sock, *n, *parent_sock;
  240. struct sock *sk;
  241. parent_sock = nfc_llcp_sock(parent);
  242. list_for_each_entry_safe(llcp_sock, n, &parent_sock->accept_queue,
  243. accept_queue) {
  244. sk = &llcp_sock->sk;
  245. if (sk->sk_state == LLCP_CONNECTED)
  246. return POLLIN | POLLRDNORM;
  247. }
  248. return 0;
  249. }
  250. static unsigned int llcp_sock_poll(struct file *file, struct socket *sock,
  251. poll_table *wait)
  252. {
  253. struct sock *sk = sock->sk;
  254. unsigned int mask = 0;
  255. pr_debug("%p\n", sk);
  256. sock_poll_wait(file, sk_sleep(sk), wait);
  257. if (sk->sk_state == LLCP_LISTEN)
  258. return llcp_accept_poll(sk);
  259. if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
  260. mask |= POLLERR;
  261. if (!skb_queue_empty(&sk->sk_receive_queue))
  262. mask |= POLLIN | POLLRDNORM;
  263. if (sk->sk_state == LLCP_CLOSED)
  264. mask |= POLLHUP;
  265. if (sk->sk_shutdown & RCV_SHUTDOWN)
  266. mask |= POLLRDHUP | POLLIN | POLLRDNORM;
  267. if (sk->sk_shutdown == SHUTDOWN_MASK)
  268. mask |= POLLHUP;
  269. if (sock_writeable(sk))
  270. mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
  271. else
  272. set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
  273. pr_debug("mask 0x%x\n", mask);
  274. return mask;
  275. }
  276. static int llcp_sock_release(struct socket *sock)
  277. {
  278. struct sock *sk = sock->sk;
  279. struct nfc_llcp_local *local;
  280. struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
  281. int err = 0;
  282. if (!sk)
  283. return 0;
  284. pr_debug("%p\n", sk);
  285. local = llcp_sock->local;
  286. if (local == NULL) {
  287. err = -ENODEV;
  288. goto out;
  289. }
  290. mutex_lock(&local->socket_lock);
  291. if (llcp_sock == local->sockets[llcp_sock->ssap])
  292. local->sockets[llcp_sock->ssap] = NULL;
  293. else
  294. list_del_init(&llcp_sock->list);
  295. mutex_unlock(&local->socket_lock);
  296. lock_sock(sk);
  297. /* Send a DISC */
  298. if (sk->sk_state == LLCP_CONNECTED)
  299. nfc_llcp_disconnect(llcp_sock);
  300. if (sk->sk_state == LLCP_LISTEN) {
  301. struct nfc_llcp_sock *lsk, *n;
  302. struct sock *accept_sk;
  303. list_for_each_entry_safe(lsk, n, &llcp_sock->accept_queue,
  304. accept_queue) {
  305. accept_sk = &lsk->sk;
  306. lock_sock(accept_sk);
  307. nfc_llcp_disconnect(lsk);
  308. nfc_llcp_accept_unlink(accept_sk);
  309. release_sock(accept_sk);
  310. sock_orphan(accept_sk);
  311. }
  312. }
  313. /* Freeing the SAP */
  314. if ((sk->sk_state == LLCP_CONNECTED
  315. && llcp_sock->ssap > LLCP_LOCAL_SAP_OFFSET) ||
  316. sk->sk_state == LLCP_BOUND || sk->sk_state == LLCP_LISTEN)
  317. nfc_llcp_put_ssap(llcp_sock->local, llcp_sock->ssap);
  318. release_sock(sk);
  319. out:
  320. sock_orphan(sk);
  321. sock_put(sk);
  322. return err;
  323. }
  324. static int llcp_sock_connect(struct socket *sock, struct sockaddr *_addr,
  325. int len, int flags)
  326. {
  327. struct sock *sk = sock->sk;
  328. struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
  329. struct sockaddr_nfc_llcp *addr = (struct sockaddr_nfc_llcp *)_addr;
  330. struct nfc_dev *dev;
  331. struct nfc_llcp_local *local;
  332. int ret = 0;
  333. pr_debug("sock %p sk %p flags 0x%x\n", sock, sk, flags);
  334. if (!addr || len < sizeof(struct sockaddr_nfc) ||
  335. addr->sa_family != AF_NFC) {
  336. pr_err("Invalid socket\n");
  337. return -EINVAL;
  338. }
  339. if (addr->service_name_len == 0 && addr->dsap == 0) {
  340. pr_err("Missing service name or dsap\n");
  341. return -EINVAL;
  342. }
  343. pr_debug("addr dev_idx=%u target_idx=%u protocol=%u\n", addr->dev_idx,
  344. addr->target_idx, addr->nfc_protocol);
  345. lock_sock(sk);
  346. if (sk->sk_state == LLCP_CONNECTED) {
  347. ret = -EISCONN;
  348. goto error;
  349. }
  350. dev = nfc_get_device(addr->dev_idx);
  351. if (dev == NULL) {
  352. ret = -ENODEV;
  353. goto error;
  354. }
  355. local = nfc_llcp_find_local(dev);
  356. if (local == NULL) {
  357. ret = -ENODEV;
  358. goto put_dev;
  359. }
  360. device_lock(&dev->dev);
  361. if (dev->dep_link_up == false) {
  362. ret = -ENOLINK;
  363. device_unlock(&dev->dev);
  364. goto put_dev;
  365. }
  366. device_unlock(&dev->dev);
  367. if (local->rf_mode == NFC_RF_INITIATOR &&
  368. addr->target_idx != local->target_idx) {
  369. ret = -ENOLINK;
  370. goto put_dev;
  371. }
  372. llcp_sock->dev = dev;
  373. llcp_sock->local = local;
  374. llcp_sock->ssap = nfc_llcp_get_local_ssap(local);
  375. if (llcp_sock->ssap == LLCP_SAP_MAX) {
  376. ret = -ENOMEM;
  377. goto put_dev;
  378. }
  379. if (addr->service_name_len == 0)
  380. llcp_sock->dsap = addr->dsap;
  381. else
  382. llcp_sock->dsap = LLCP_SAP_SDP;
  383. llcp_sock->nfc_protocol = addr->nfc_protocol;
  384. llcp_sock->service_name_len = min_t(unsigned int,
  385. addr->service_name_len,
  386. NFC_LLCP_MAX_SERVICE_NAME);
  387. llcp_sock->service_name = kmemdup(addr->service_name,
  388. llcp_sock->service_name_len,
  389. GFP_KERNEL);
  390. local->sockets[llcp_sock->ssap] = llcp_sock;
  391. ret = nfc_llcp_send_connect(llcp_sock);
  392. if (ret)
  393. goto put_dev;
  394. ret = sock_wait_state(sk, LLCP_CONNECTED,
  395. sock_sndtimeo(sk, flags & O_NONBLOCK));
  396. if (ret)
  397. goto put_dev;
  398. release_sock(sk);
  399. return 0;
  400. put_dev:
  401. nfc_put_device(dev);
  402. error:
  403. release_sock(sk);
  404. return ret;
  405. }
  406. static int llcp_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
  407. struct msghdr *msg, size_t len)
  408. {
  409. struct sock *sk = sock->sk;
  410. struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
  411. int ret;
  412. pr_debug("sock %p sk %p", sock, sk);
  413. ret = sock_error(sk);
  414. if (ret)
  415. return ret;
  416. if (msg->msg_flags & MSG_OOB)
  417. return -EOPNOTSUPP;
  418. lock_sock(sk);
  419. if (sk->sk_state != LLCP_CONNECTED) {
  420. release_sock(sk);
  421. return -ENOTCONN;
  422. }
  423. release_sock(sk);
  424. return nfc_llcp_send_i_frame(llcp_sock, msg, len);
  425. }
  426. static int llcp_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
  427. struct msghdr *msg, size_t len, int flags)
  428. {
  429. int noblock = flags & MSG_DONTWAIT;
  430. struct sock *sk = sock->sk;
  431. unsigned int copied, rlen;
  432. struct sk_buff *skb, *cskb;
  433. int err = 0;
  434. pr_debug("%p %zu\n", sk, len);
  435. lock_sock(sk);
  436. if (sk->sk_state == LLCP_CLOSED &&
  437. skb_queue_empty(&sk->sk_receive_queue)) {
  438. release_sock(sk);
  439. return 0;
  440. }
  441. release_sock(sk);
  442. if (flags & (MSG_OOB))
  443. return -EOPNOTSUPP;
  444. skb = skb_recv_datagram(sk, flags, noblock, &err);
  445. if (!skb) {
  446. pr_err("Recv datagram failed state %d %d %d",
  447. sk->sk_state, err, sock_error(sk));
  448. if (sk->sk_shutdown & RCV_SHUTDOWN)
  449. return 0;
  450. return err;
  451. }
  452. rlen = skb->len; /* real length of skb */
  453. copied = min_t(unsigned int, rlen, len);
  454. cskb = skb;
  455. if (memcpy_toiovec(msg->msg_iov, cskb->data, copied)) {
  456. if (!(flags & MSG_PEEK))
  457. skb_queue_head(&sk->sk_receive_queue, skb);
  458. return -EFAULT;
  459. }
  460. /* Mark read part of skb as used */
  461. if (!(flags & MSG_PEEK)) {
  462. /* SOCK_STREAM: re-queue skb if it contains unreceived data */
  463. if (sk->sk_type == SOCK_STREAM) {
  464. skb_pull(skb, copied);
  465. if (skb->len) {
  466. skb_queue_head(&sk->sk_receive_queue, skb);
  467. goto done;
  468. }
  469. }
  470. kfree_skb(skb);
  471. }
  472. /* XXX Queue backlogged skbs */
  473. done:
  474. /* SOCK_SEQPACKET: return real length if MSG_TRUNC is set */
  475. if (sk->sk_type == SOCK_SEQPACKET && (flags & MSG_TRUNC))
  476. copied = rlen;
  477. return copied;
  478. }
  479. static const struct proto_ops llcp_sock_ops = {
  480. .family = PF_NFC,
  481. .owner = THIS_MODULE,
  482. .bind = llcp_sock_bind,
  483. .connect = llcp_sock_connect,
  484. .release = llcp_sock_release,
  485. .socketpair = sock_no_socketpair,
  486. .accept = llcp_sock_accept,
  487. .getname = llcp_sock_getname,
  488. .poll = llcp_sock_poll,
  489. .ioctl = sock_no_ioctl,
  490. .listen = llcp_sock_listen,
  491. .shutdown = sock_no_shutdown,
  492. .setsockopt = sock_no_setsockopt,
  493. .getsockopt = sock_no_getsockopt,
  494. .sendmsg = llcp_sock_sendmsg,
  495. .recvmsg = llcp_sock_recvmsg,
  496. .mmap = sock_no_mmap,
  497. };
  498. static void llcp_sock_destruct(struct sock *sk)
  499. {
  500. struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
  501. pr_debug("%p\n", sk);
  502. if (sk->sk_state == LLCP_CONNECTED)
  503. nfc_put_device(llcp_sock->dev);
  504. skb_queue_purge(&sk->sk_receive_queue);
  505. nfc_llcp_sock_free(llcp_sock);
  506. if (!sock_flag(sk, SOCK_DEAD)) {
  507. pr_err("Freeing alive NFC LLCP socket %p\n", sk);
  508. return;
  509. }
  510. }
  511. struct sock *nfc_llcp_sock_alloc(struct socket *sock, int type, gfp_t gfp)
  512. {
  513. struct sock *sk;
  514. struct nfc_llcp_sock *llcp_sock;
  515. sk = sk_alloc(&init_net, PF_NFC, gfp, &llcp_sock_proto);
  516. if (!sk)
  517. return NULL;
  518. llcp_sock = nfc_llcp_sock(sk);
  519. sock_init_data(sock, sk);
  520. sk->sk_state = LLCP_CLOSED;
  521. sk->sk_protocol = NFC_SOCKPROTO_LLCP;
  522. sk->sk_type = type;
  523. sk->sk_destruct = llcp_sock_destruct;
  524. llcp_sock->ssap = 0;
  525. llcp_sock->dsap = LLCP_SAP_SDP;
  526. llcp_sock->send_n = llcp_sock->send_ack_n = 0;
  527. llcp_sock->recv_n = llcp_sock->recv_ack_n = 0;
  528. llcp_sock->remote_ready = 1;
  529. skb_queue_head_init(&llcp_sock->tx_queue);
  530. skb_queue_head_init(&llcp_sock->tx_pending_queue);
  531. skb_queue_head_init(&llcp_sock->tx_backlog_queue);
  532. INIT_LIST_HEAD(&llcp_sock->list);
  533. INIT_LIST_HEAD(&llcp_sock->accept_queue);
  534. if (sock != NULL)
  535. sock->state = SS_UNCONNECTED;
  536. return sk;
  537. }
  538. void nfc_llcp_sock_free(struct nfc_llcp_sock *sock)
  539. {
  540. struct nfc_llcp_local *local = sock->local;
  541. kfree(sock->service_name);
  542. skb_queue_purge(&sock->tx_queue);
  543. skb_queue_purge(&sock->tx_pending_queue);
  544. skb_queue_purge(&sock->tx_backlog_queue);
  545. list_del_init(&sock->accept_queue);
  546. if (local != NULL && sock == local->sockets[sock->ssap])
  547. local->sockets[sock->ssap] = NULL;
  548. else
  549. list_del_init(&sock->list);
  550. sock->parent = NULL;
  551. }
  552. static int llcp_sock_create(struct net *net, struct socket *sock,
  553. const struct nfc_protocol *nfc_proto)
  554. {
  555. struct sock *sk;
  556. pr_debug("%p\n", sock);
  557. if (sock->type != SOCK_STREAM && sock->type != SOCK_DGRAM)
  558. return -ESOCKTNOSUPPORT;
  559. sock->ops = &llcp_sock_ops;
  560. sk = nfc_llcp_sock_alloc(sock, sock->type, GFP_ATOMIC);
  561. if (sk == NULL)
  562. return -ENOMEM;
  563. return 0;
  564. }
  565. static const struct nfc_protocol llcp_nfc_proto = {
  566. .id = NFC_SOCKPROTO_LLCP,
  567. .proto = &llcp_sock_proto,
  568. .owner = THIS_MODULE,
  569. .create = llcp_sock_create
  570. };
  571. int __init nfc_llcp_sock_init(void)
  572. {
  573. return nfc_proto_register(&llcp_nfc_proto);
  574. }
  575. void nfc_llcp_sock_exit(void)
  576. {
  577. nfc_proto_unregister(&llcp_nfc_proto);
  578. }