Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit fe3c094abc2365a226184554501fe0df87fe8271

Authored by Samuel Ortiz
Committed by John W. Linville
1 parent 01d719a228
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

NFC: Check for llcp_sock and its device from llcp_sock_getname 

They both can potentially be NULL.

Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

Showing 1 changed file with 3 additions and 0 deletions Inline Diff

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