Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * NET4: Implementation of BSD Unix domain sockets.
4 : : *
5 : : * Authors: Alan Cox, <alan@lxorguk.ukuu.org.uk>
6 : : *
7 : : * Fixes:
8 : : * Linus Torvalds : Assorted bug cures.
9 : : * Niibe Yutaka : async I/O support.
10 : : * Carsten Paeth : PF_UNIX check, address fixes.
11 : : * Alan Cox : Limit size of allocated blocks.
12 : : * Alan Cox : Fixed the stupid socketpair bug.
13 : : * Alan Cox : BSD compatibility fine tuning.
14 : : * Alan Cox : Fixed a bug in connect when interrupted.
15 : : * Alan Cox : Sorted out a proper draft version of
16 : : * file descriptor passing hacked up from
17 : : * Mike Shaver's work.
18 : : * Marty Leisner : Fixes to fd passing
19 : : * Nick Nevin : recvmsg bugfix.
20 : : * Alan Cox : Started proper garbage collector
21 : : * Heiko EiBfeldt : Missing verify_area check
22 : : * Alan Cox : Started POSIXisms
23 : : * Andreas Schwab : Replace inode by dentry for proper
24 : : * reference counting
25 : : * Kirk Petersen : Made this a module
26 : : * Christoph Rohland : Elegant non-blocking accept/connect algorithm.
27 : : * Lots of bug fixes.
28 : : * Alexey Kuznetosv : Repaired (I hope) bugs introduces
29 : : * by above two patches.
30 : : * Andrea Arcangeli : If possible we block in connect(2)
31 : : * if the max backlog of the listen socket
32 : : * is been reached. This won't break
33 : : * old apps and it will avoid huge amount
34 : : * of socks hashed (this for unix_gc()
35 : : * performances reasons).
36 : : * Security fix that limits the max
37 : : * number of socks to 2*max_files and
38 : : * the number of skb queueable in the
39 : : * dgram receiver.
40 : : * Artur Skawina : Hash function optimizations
41 : : * Alexey Kuznetsov : Full scale SMP. Lot of bugs are introduced 8)
42 : : * Malcolm Beattie : Set peercred for socketpair
43 : : * Michal Ostrowski : Module initialization cleanup.
44 : : * Arnaldo C. Melo : Remove MOD_{INC,DEC}_USE_COUNT,
45 : : * the core infrastructure is doing that
46 : : * for all net proto families now (2.5.69+)
47 : : *
48 : : * Known differences from reference BSD that was tested:
49 : : *
50 : : * [TO FIX]
51 : : * ECONNREFUSED is not returned from one end of a connected() socket to the
52 : : * other the moment one end closes.
53 : : * fstat() doesn't return st_dev=0, and give the blksize as high water mark
54 : : * and a fake inode identifier (nor the BSD first socket fstat twice bug).
55 : : * [NOT TO FIX]
56 : : * accept() returns a path name even if the connecting socket has closed
57 : : * in the meantime (BSD loses the path and gives up).
58 : : * accept() returns 0 length path for an unbound connector. BSD returns 16
59 : : * and a null first byte in the path (but not for gethost/peername - BSD bug ??)
60 : : * socketpair(...SOCK_RAW..) doesn't panic the kernel.
61 : : * BSD af_unix apparently has connect forgetting to block properly.
62 : : * (need to check this with the POSIX spec in detail)
63 : : *
64 : : * Differences from 2.0.0-11-... (ANK)
65 : : * Bug fixes and improvements.
66 : : * - client shutdown killed server socket.
67 : : * - removed all useless cli/sti pairs.
68 : : *
69 : : * Semantic changes/extensions.
70 : : * - generic control message passing.
71 : : * - SCM_CREDENTIALS control message.
72 : : * - "Abstract" (not FS based) socket bindings.
73 : : * Abstract names are sequences of bytes (not zero terminated)
74 : : * started by 0, so that this name space does not intersect
75 : : * with BSD names.
76 : : */
77 : :
78 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
79 : :
80 : : #include <linux/module.h>
81 : : #include <linux/kernel.h>
82 : : #include <linux/signal.h>
83 : : #include <linux/sched/signal.h>
84 : : #include <linux/errno.h>
85 : : #include <linux/string.h>
86 : : #include <linux/stat.h>
87 : : #include <linux/dcache.h>
88 : : #include <linux/namei.h>
89 : : #include <linux/socket.h>
90 : : #include <linux/un.h>
91 : : #include <linux/fcntl.h>
92 : : #include <linux/termios.h>
93 : : #include <linux/sockios.h>
94 : : #include <linux/net.h>
95 : : #include <linux/in.h>
96 : : #include <linux/fs.h>
97 : : #include <linux/slab.h>
98 : : #include <linux/uaccess.h>
99 : : #include <linux/skbuff.h>
100 : : #include <linux/netdevice.h>
101 : : #include <net/net_namespace.h>
102 : : #include <net/sock.h>
103 : : #include <net/tcp_states.h>
104 : : #include <net/af_unix.h>
105 : : #include <linux/proc_fs.h>
106 : : #include <linux/seq_file.h>
107 : : #include <net/scm.h>
108 : : #include <linux/init.h>
109 : : #include <linux/poll.h>
110 : : #include <linux/rtnetlink.h>
111 : : #include <linux/mount.h>
112 : : #include <net/checksum.h>
113 : : #include <linux/security.h>
114 : : #include <linux/freezer.h>
115 : : #include <linux/file.h>
116 : :
117 : : #include "scm.h"
118 : :
119 : : struct hlist_head unix_socket_table[2 * UNIX_HASH_SIZE];
120 : : EXPORT_SYMBOL_GPL(unix_socket_table);
121 : : DEFINE_SPINLOCK(unix_table_lock);
122 : : EXPORT_SYMBOL_GPL(unix_table_lock);
123 : : static atomic_long_t unix_nr_socks;
124 : :
125 : :
126 : 3179 : static struct hlist_head *unix_sockets_unbound(void *addr)
127 : : {
128 : 3179 : unsigned long hash = (unsigned long)addr;
129 : :
130 : 3179 : hash ^= hash >> 16;
131 : 3179 : hash ^= hash >> 8;
132 : 3179 : hash %= UNIX_HASH_SIZE;
133 : 3179 : return &unix_socket_table[UNIX_HASH_SIZE + hash];
134 : : }
135 : :
136 : : #define UNIX_ABSTRACT(sk) (unix_sk(sk)->addr->hash < UNIX_HASH_SIZE)
137 : :
138 : : #ifdef CONFIG_SECURITY_NETWORK
139 : 9726 : static void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
140 : : {
141 : 9726 : UNIXCB(skb).secid = scm->secid;
142 : : }
143 : :
144 : 9128 : static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
145 : : {
146 : 9128 : scm->secid = UNIXCB(skb).secid;
147 : : }
148 : :
149 : 0 : static inline bool unix_secdata_eq(struct scm_cookie *scm, struct sk_buff *skb)
150 : : {
151 : 0 : return (scm->secid == UNIXCB(skb).secid);
152 : : }
153 : : #else
154 : : static inline void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
155 : : { }
156 : :
157 : : static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
158 : : { }
159 : :
160 : : static inline bool unix_secdata_eq(struct scm_cookie *scm, struct sk_buff *skb)
161 : : {
162 : : return true;
163 : : }
164 : : #endif /* CONFIG_SECURITY_NETWORK */
165 : :
166 : : /*
167 : : * SMP locking strategy:
168 : : * hash table is protected with spinlock unix_table_lock
169 : : * each socket state is protected by separate spin lock.
170 : : */
171 : :
172 : 297 : static inline unsigned int unix_hash_fold(__wsum n)
173 : : {
174 : 297 : unsigned int hash = (__force unsigned int)csum_fold(n);
175 : :
176 : 297 : hash ^= hash>>8;
177 : 297 : return hash&(UNIX_HASH_SIZE-1);
178 : : }
179 : :
180 : : #define unix_peer(sk) (unix_sk(sk)->peer)
181 : :
182 : 6215 : static inline int unix_our_peer(struct sock *sk, struct sock *osk)
183 : : {
184 [ - + - - ]: 6215 : return unix_peer(osk) == sk;
185 : : }
186 : :
187 : 9040 : static inline int unix_may_send(struct sock *sk, struct sock *osk)
188 : : {
189 [ - + - - ]: 6215 : return unix_peer(osk) == NULL || unix_our_peer(sk, osk);
190 : : }
191 : :
192 : 924 : static inline int unix_recvq_full(const struct sock *sk)
193 : : {
194 [ - + - - ]: 605 : return skb_queue_len(&sk->sk_receive_queue) > sk->sk_max_ack_backlog;
195 : : }
196 : :
197 : 2583 : static inline int unix_recvq_full_lockless(const struct sock *sk)
198 : : {
199 [ - + ]: 2583 : return skb_queue_len_lockless(&sk->sk_receive_queue) >
200 : 2583 : READ_ONCE(sk->sk_max_ack_backlog);
201 : : }
202 : :
203 : 7490 : struct sock *unix_peer_get(struct sock *s)
204 : : {
205 : 7490 : struct sock *peer;
206 : :
207 : 7490 : unix_state_lock(s);
208 [ + - ]: 7490 : peer = unix_peer(s);
209 [ + - ]: 7490 : if (peer)
210 : 7490 : sock_hold(peer);
211 : 7490 : unix_state_unlock(s);
212 : 7490 : return peer;
213 : : }
214 : : EXPORT_SYMBOL_GPL(unix_peer_get);
215 : :
216 : 264 : static inline void unix_release_addr(struct unix_address *addr)
217 : : {
218 [ - + ]: 264 : if (refcount_dec_and_test(&addr->refcnt))
219 : 0 : kfree(addr);
220 : 264 : }
221 : :
222 : : /*
223 : : * Check unix socket name:
224 : : * - should be not zero length.
225 : : * - if started by not zero, should be NULL terminated (FS object)
226 : : * - if started by zero, it is abstract name.
227 : : */
228 : :
229 : 2859 : static int unix_mkname(struct sockaddr_un *sunaddr, int len, unsigned int *hashp)
230 : : {
231 : 2859 : *hashp = 0;
232 : :
233 [ + - ]: 2859 : if (len <= sizeof(short) || len > sizeof(*sunaddr))
234 : : return -EINVAL;
235 [ + - + - ]: 2859 : if (!sunaddr || sunaddr->sun_family != AF_UNIX)
236 : : return -EINVAL;
237 [ + + ]: 2859 : if (sunaddr->sun_path[0]) {
238 : : /*
239 : : * This may look like an off by one error but it is a bit more
240 : : * subtle. 108 is the longest valid AF_UNIX path for a binding.
241 : : * sun_path[108] doesn't as such exist. However in kernel space
242 : : * we are guaranteed that it is a valid memory location in our
243 : : * kernel address buffer.
244 : : */
245 : 2562 : ((char *)sunaddr)[len] = 0;
246 : 2562 : len = strlen(sunaddr->sun_path)+1+sizeof(short);
247 : 2562 : return len;
248 : : }
249 : :
250 : 297 : *hashp = unix_hash_fold(csum_partial(sunaddr, len, 0));
251 : 297 : return len;
252 : : }
253 : :
254 : 2915 : static void __unix_remove_socket(struct sock *sk)
255 : : {
256 : 2915 : sk_del_node_init(sk);
257 : : }
258 : :
259 : 3256 : static void __unix_insert_socket(struct hlist_head *list, struct sock *sk)
260 : : {
261 [ - + ]: 3256 : WARN_ON(!sk_unhashed(sk));
262 : 3256 : sk_add_node(sk, list);
263 : 3256 : }
264 : :
265 : 2838 : static inline void unix_remove_socket(struct sock *sk)
266 : : {
267 : 2838 : spin_lock(&unix_table_lock);
268 : 2838 : __unix_remove_socket(sk);
269 : 2838 : spin_unlock(&unix_table_lock);
270 : 2838 : }
271 : :
272 : 3179 : static inline void unix_insert_socket(struct hlist_head *list, struct sock *sk)
273 : : {
274 : 3179 : spin_lock(&unix_table_lock);
275 : 3179 : __unix_insert_socket(list, sk);
276 : 3179 : spin_unlock(&unix_table_lock);
277 : 3179 : }
278 : :
279 : 297 : static struct sock *__unix_find_socket_byname(struct net *net,
280 : : struct sockaddr_un *sunname,
281 : : int len, int type, unsigned int hash)
282 : : {
283 : 297 : struct sock *s;
284 : :
285 [ - + - - : 594 : sk_for_each(s, &unix_socket_table[hash ^ type]) {
- + ]
286 [ # # ]: 0 : struct unix_sock *u = unix_sk(s);
287 : :
288 [ # # ]: 0 : if (!net_eq(sock_net(s), net))
289 : 0 : continue;
290 : :
291 [ # # ]: 0 : if (u->addr->len == len &&
292 [ # # ]: 0 : !memcmp(u->addr->name, sunname, len))
293 : 0 : return s;
294 : : }
295 : : return NULL;
296 : : }
297 : :
298 : 297 : static inline struct sock *unix_find_socket_byname(struct net *net,
299 : : struct sockaddr_un *sunname,
300 : : int len, int type,
301 : : unsigned int hash)
302 : : {
303 : 297 : struct sock *s;
304 : :
305 : 297 : spin_lock(&unix_table_lock);
306 : 297 : s = __unix_find_socket_byname(net, sunname, len, type, hash);
307 [ - + ]: 297 : if (s)
308 : 0 : sock_hold(s);
309 : 297 : spin_unlock(&unix_table_lock);
310 : 297 : return s;
311 : : }
312 : :
313 : 1869 : static struct sock *unix_find_socket_byinode(struct inode *i)
314 : : {
315 : 1869 : struct sock *s;
316 : :
317 : 1869 : spin_lock(&unix_table_lock);
318 [ + - + - : 3766 : sk_for_each(s,
+ - ]
319 : : &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) {
320 [ + - ]: 1897 : struct dentry *dentry = unix_sk(s)->path.dentry;
321 : :
322 [ + - + + ]: 1897 : if (dentry && d_backing_inode(dentry) == i) {
323 : 1869 : sock_hold(s);
324 : 1869 : goto found;
325 : : }
326 : : }
327 : : s = NULL;
328 : 1869 : found:
329 : 1869 : spin_unlock(&unix_table_lock);
330 : 1869 : return s;
331 : : }
332 : :
333 : : /* Support code for asymmetrically connected dgram sockets
334 : : *
335 : : * If a datagram socket is connected to a socket not itself connected
336 : : * to the first socket (eg, /dev/log), clients may only enqueue more
337 : : * messages if the present receive queue of the server socket is not
338 : : * "too large". This means there's a second writeability condition
339 : : * poll and sendmsg need to test. The dgram recv code will do a wake
340 : : * up on the peer_wait wait queue of a socket upon reception of a
341 : : * datagram which needs to be propagated to sleeping would-be writers
342 : : * since these might not have sent anything so far. This can't be
343 : : * accomplished via poll_wait because the lifetime of the server
344 : : * socket might be less than that of its clients if these break their
345 : : * association with it or if the server socket is closed while clients
346 : : * are still connected to it and there's no way to inform "a polling
347 : : * implementation" that it should let go of a certain wait queue
348 : : *
349 : : * In order to propagate a wake up, a wait_queue_entry_t of the client
350 : : * socket is enqueued on the peer_wait queue of the server socket
351 : : * whose wake function does a wake_up on the ordinary client socket
352 : : * wait queue. This connection is established whenever a write (or
353 : : * poll for write) hit the flow control condition and broken when the
354 : : * association to the server socket is dissolved or after a wake up
355 : : * was relayed.
356 : : */
357 : :
358 : 0 : static int unix_dgram_peer_wake_relay(wait_queue_entry_t *q, unsigned mode, int flags,
359 : : void *key)
360 : : {
361 : 0 : struct unix_sock *u;
362 : 0 : wait_queue_head_t *u_sleep;
363 : :
364 : 0 : u = container_of(q, struct unix_sock, peer_wake);
365 : :
366 [ # # ]: 0 : __remove_wait_queue(&unix_sk(u->peer_wake.private)->peer_wait,
367 : : q);
368 : 0 : u->peer_wake.private = NULL;
369 : :
370 : : /* relaying can only happen while the wq still exists */
371 [ # # ]: 0 : u_sleep = sk_sleep(&u->sk);
372 [ # # ]: 0 : if (u_sleep)
373 : 0 : wake_up_interruptible_poll(u_sleep, key_to_poll(key));
374 : :
375 : 0 : return 0;
376 : : }
377 : :
378 : 0 : static int unix_dgram_peer_wake_connect(struct sock *sk, struct sock *other)
379 : : {
380 : 0 : struct unix_sock *u, *u_other;
381 : 0 : int rc;
382 : :
383 : 0 : u = unix_sk(sk);
384 : 0 : u_other = unix_sk(other);
385 : 0 : rc = 0;
386 : 0 : spin_lock(&u_other->peer_wait.lock);
387 : :
388 [ # # ]: 0 : if (!u->peer_wake.private) {
389 : 0 : u->peer_wake.private = other;
390 : 0 : __add_wait_queue(&u_other->peer_wait, &u->peer_wake);
391 : :
392 : 0 : rc = 1;
393 : : }
394 : :
395 : 0 : spin_unlock(&u_other->peer_wait.lock);
396 : 0 : return rc;
397 : : }
398 : :
399 : 704 : static void unix_dgram_peer_wake_disconnect(struct sock *sk,
400 : : struct sock *other)
401 : : {
402 : 704 : struct unix_sock *u, *u_other;
403 : :
404 : 704 : u = unix_sk(sk);
405 : 704 : u_other = unix_sk(other);
406 : 704 : spin_lock(&u_other->peer_wait.lock);
407 : :
408 [ - + ]: 704 : if (u->peer_wake.private == other) {
409 : 0 : __remove_wait_queue(&u_other->peer_wait, &u->peer_wake);
410 : 0 : u->peer_wake.private = NULL;
411 : : }
412 : :
413 : 704 : spin_unlock(&u_other->peer_wait.lock);
414 : 704 : }
415 : :
416 : 0 : static void unix_dgram_peer_wake_disconnect_wakeup(struct sock *sk,
417 : : struct sock *other)
418 : : {
419 : 0 : unix_dgram_peer_wake_disconnect(sk, other);
420 : 0 : wake_up_interruptible_poll(sk_sleep(sk),
421 : : EPOLLOUT |
422 : : EPOLLWRNORM |
423 : : EPOLLWRBAND);
424 : 0 : }
425 : :
426 : : /* preconditions:
427 : : * - unix_peer(sk) == other
428 : : * - association is stable
429 : : */
430 : 0 : static int unix_dgram_peer_wake_me(struct sock *sk, struct sock *other)
431 : : {
432 : 0 : int connected;
433 : :
434 : 0 : connected = unix_dgram_peer_wake_connect(sk, other);
435 : :
436 : : /* If other is SOCK_DEAD, we want to make sure we signal
437 : : * POLLOUT, such that a subsequent write() can get a
438 : : * -ECONNREFUSED. Otherwise, if we haven't queued any skbs
439 : : * to other and its full, we will hang waiting for POLLOUT.
440 : : */
441 [ # # # # ]: 0 : if (unix_recvq_full(other) && !sock_flag(other, SOCK_DEAD))
442 : : return 1;
443 : :
444 [ # # ]: 0 : if (connected)
445 : 0 : unix_dgram_peer_wake_disconnect(sk, other);
446 : :
447 : : return 0;
448 : : }
449 : :
450 : 18252 : static int unix_writable(const struct sock *sk)
451 : : {
452 : 35134 : return sk->sk_state != TCP_LISTEN &&
453 [ - + + - : 16882 : (refcount_read(&sk->sk_wmem_alloc) << 2) <= sk->sk_sndbuf;
+ - ]
454 : : }
455 : :
456 : 12014 : static void unix_write_space(struct sock *sk)
457 : : {
458 : 12014 : struct socket_wq *wq;
459 : :
460 : 12014 : rcu_read_lock();
461 [ + - ]: 12014 : if (unix_writable(sk)) {
462 [ + + ]: 12014 : wq = rcu_dereference(sk->sk_wq);
463 [ + + + + ]: 22642 : if (skwq_has_sleeper(wq))
464 : 1747 : wake_up_interruptible_sync_poll(&wq->wait,
465 : : EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND);
466 : 12014 : sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
467 : : }
468 : 12014 : rcu_read_unlock();
469 : 12014 : }
470 : :
471 : : /* When dgram socket disconnects (or changes its peer), we clear its receive
472 : : * queue of packets arrived from previous peer. First, it allows to do
473 : : * flow control based only on wmem_alloc; second, sk connected to peer
474 : : * may receive messages only from that peer. */
475 : 0 : static void unix_dgram_disconnected(struct sock *sk, struct sock *other)
476 : : {
477 [ # # ]: 0 : if (!skb_queue_empty(&sk->sk_receive_queue)) {
478 : 0 : skb_queue_purge(&sk->sk_receive_queue);
479 : 0 : wake_up_interruptible_all(&unix_sk(sk)->peer_wait);
480 : :
481 : : /* If one link of bidirectional dgram pipe is disconnected,
482 : : * we signal error. Messages are lost. Do not make this,
483 : : * when peer was not connected to us.
484 : : */
485 [ # # # # ]: 0 : if (!sock_flag(other, SOCK_DEAD) && unix_peer(other) == sk) {
486 : 0 : other->sk_err = ECONNRESET;
487 : 0 : other->sk_error_report(other);
488 : : }
489 : : }
490 : 0 : }
491 : :
492 : 2838 : static void unix_sock_destructor(struct sock *sk)
493 : : {
494 : 2838 : struct unix_sock *u = unix_sk(sk);
495 : :
496 : 2838 : skb_queue_purge(&sk->sk_receive_queue);
497 : :
498 [ - + ]: 2838 : WARN_ON(refcount_read(&sk->sk_wmem_alloc));
499 [ - + ]: 2838 : WARN_ON(!sk_unhashed(sk));
500 [ - + ]: 2838 : WARN_ON(sk->sk_socket);
501 [ - + ]: 2838 : if (!sock_flag(sk, SOCK_DEAD)) {
502 : 0 : pr_info("Attempt to release alive unix socket: %p\n", sk);
503 : 0 : return;
504 : : }
505 : :
506 [ + + ]: 2838 : if (u->addr)
507 : 264 : unix_release_addr(u->addr);
508 : :
509 : 2838 : atomic_long_dec(&unix_nr_socks);
510 : 2838 : local_bh_disable();
511 : 2838 : sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
512 : 2838 : local_bh_enable();
513 : : #ifdef UNIX_REFCNT_DEBUG
514 : : pr_debug("UNIX %p is destroyed, %ld are still alive.\n", sk,
515 : : atomic_long_read(&unix_nr_socks));
516 : : #endif
517 : : }
518 : :
519 : 2838 : static void unix_release_sock(struct sock *sk, int embrion)
520 : : {
521 : 2838 : struct unix_sock *u = unix_sk(sk);
522 : 2838 : struct path path;
523 : 2838 : struct sock *skpair;
524 : 2838 : struct sk_buff *skb;
525 : 2838 : int state;
526 : :
527 : 2838 : unix_remove_socket(sk);
528 : :
529 : : /* Clear state */
530 : 2838 : unix_state_lock(sk);
531 : 2838 : sock_orphan(sk);
532 : 2838 : sk->sk_shutdown = SHUTDOWN_MASK;
533 : 2838 : path = u->path;
534 : 2838 : u->path.dentry = NULL;
535 : 2838 : u->path.mnt = NULL;
536 : 2838 : state = sk->sk_state;
537 : 2838 : sk->sk_state = TCP_CLOSE;
538 : 2838 : unix_state_unlock(sk);
539 : :
540 : 2838 : wake_up_interruptible_all(&u->peer_wait);
541 : :
542 [ + + ]: 2838 : skpair = unix_peer(sk);
543 : :
544 [ + + ]: 2838 : if (skpair != NULL) {
545 [ + + ]: 704 : if (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) {
546 : 528 : unix_state_lock(skpair);
547 : : /* No more writes */
548 : 528 : skpair->sk_shutdown = SHUTDOWN_MASK;
549 [ + + - + ]: 528 : if (!skb_queue_empty(&sk->sk_receive_queue) || embrion)
550 : 2 : skpair->sk_err = ECONNRESET;
551 : 528 : unix_state_unlock(skpair);
552 : 528 : skpair->sk_state_change(skpair);
553 : 528 : sk_wake_async(skpair, SOCK_WAKE_WAITD, POLL_HUP);
554 : : }
555 : :
556 : 704 : unix_dgram_peer_wake_disconnect(sk, skpair);
557 : 704 : sock_put(skpair); /* It may now die */
558 : 704 : unix_peer(sk) = NULL;
559 : : }
560 : :
561 : : /* Try to flush out this socket. Throw out buffers at least */
562 : :
563 [ + + ]: 2858 : while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
564 [ - + ]: 20 : if (state == TCP_LISTEN)
565 : 0 : unix_release_sock(skb->sk, 1);
566 : : /* passed fds are erased in the kfree_skb hook */
567 : 20 : UNIXCB(skb).consumed = skb->len;
568 : 20 : kfree_skb(skb);
569 : : }
570 : :
571 [ + + ]: 2838 : if (path.dentry)
572 : 264 : path_put(&path);
573 : :
574 : 2838 : sock_put(sk);
575 : :
576 : : /* ---- Socket is dead now and most probably destroyed ---- */
577 : :
578 : : /*
579 : : * Fixme: BSD difference: In BSD all sockets connected to us get
580 : : * ECONNRESET and we die on the spot. In Linux we behave
581 : : * like files and pipes do and wait for the last
582 : : * dereference.
583 : : *
584 : : * Can't we simply set sock->err?
585 : : *
586 : : * What the above comment does talk about? --ANK(980817)
587 : : */
588 : :
589 [ + + ]: 2838 : if (unix_tot_inflight)
590 : 331 : unix_gc(); /* Garbage collect fds */
591 : 2838 : }
592 : :
593 : 440 : static void init_peercred(struct sock *sk)
594 : : {
595 : 440 : put_pid(sk->sk_peer_pid);
596 [ - + ]: 440 : if (sk->sk_peer_cred)
597 : 0 : put_cred(sk->sk_peer_cred);
598 [ + - ]: 440 : sk->sk_peer_pid = get_pid(task_tgid(current));
599 [ + - ]: 440 : sk->sk_peer_cred = get_current_cred();
600 : 440 : }
601 : :
602 : 319 : static void copy_peercred(struct sock *sk, struct sock *peersk)
603 : : {
604 : 319 : put_pid(sk->sk_peer_pid);
605 [ - + ]: 319 : if (sk->sk_peer_cred)
606 : 0 : put_cred(sk->sk_peer_cred);
607 [ + - ]: 319 : sk->sk_peer_pid = get_pid(peersk->sk_peer_pid);
608 [ + - ]: 319 : sk->sk_peer_cred = get_cred(peersk->sk_peer_cred);
609 : 319 : }
610 : :
611 : 33 : static int unix_listen(struct socket *sock, int backlog)
612 : : {
613 : 33 : int err;
614 : 33 : struct sock *sk = sock->sk;
615 [ - + ]: 33 : struct unix_sock *u = unix_sk(sk);
616 : 33 : struct pid *old_pid = NULL;
617 : :
618 : 33 : err = -EOPNOTSUPP;
619 [ - + ]: 33 : if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
620 : 0 : goto out; /* Only stream/seqpacket sockets accept */
621 : 33 : err = -EINVAL;
622 [ - + ]: 33 : if (!u->addr)
623 : 0 : goto out; /* No listens on an unbound socket */
624 : 33 : unix_state_lock(sk);
625 [ - + - - ]: 33 : if (sk->sk_state != TCP_CLOSE && sk->sk_state != TCP_LISTEN)
626 : 0 : goto out_unlock;
627 [ - + ]: 33 : if (backlog > sk->sk_max_ack_backlog)
628 : 0 : wake_up_interruptible_all(&u->peer_wait);
629 : 33 : sk->sk_max_ack_backlog = backlog;
630 : 33 : sk->sk_state = TCP_LISTEN;
631 : : /* set credentials so connect can copy them */
632 : 33 : init_peercred(sk);
633 : 33 : err = 0;
634 : :
635 : 33 : out_unlock:
636 : 33 : unix_state_unlock(sk);
637 : 33 : put_pid(old_pid);
638 : 33 : out:
639 : 33 : return err;
640 : : }
641 : :
642 : : static int unix_release(struct socket *);
643 : : static int unix_bind(struct socket *, struct sockaddr *, int);
644 : : static int unix_stream_connect(struct socket *, struct sockaddr *,
645 : : int addr_len, int flags);
646 : : static int unix_socketpair(struct socket *, struct socket *);
647 : : static int unix_accept(struct socket *, struct socket *, int, bool);
648 : : static int unix_getname(struct socket *, struct sockaddr *, int);
649 : : static __poll_t unix_poll(struct file *, struct socket *, poll_table *);
650 : : static __poll_t unix_dgram_poll(struct file *, struct socket *,
651 : : poll_table *);
652 : : static int unix_ioctl(struct socket *, unsigned int, unsigned long);
653 : : #ifdef CONFIG_COMPAT
654 : : static int unix_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
655 : : #endif
656 : : static int unix_shutdown(struct socket *, int);
657 : : static int unix_stream_sendmsg(struct socket *, struct msghdr *, size_t);
658 : : static int unix_stream_recvmsg(struct socket *, struct msghdr *, size_t, int);
659 : : static ssize_t unix_stream_sendpage(struct socket *, struct page *, int offset,
660 : : size_t size, int flags);
661 : : static ssize_t unix_stream_splice_read(struct socket *, loff_t *ppos,
662 : : struct pipe_inode_info *, size_t size,
663 : : unsigned int flags);
664 : : static int unix_dgram_sendmsg(struct socket *, struct msghdr *, size_t);
665 : : static int unix_dgram_recvmsg(struct socket *, struct msghdr *, size_t, int);
666 : : static int unix_dgram_connect(struct socket *, struct sockaddr *,
667 : : int, int);
668 : : static int unix_seqpacket_sendmsg(struct socket *, struct msghdr *, size_t);
669 : : static int unix_seqpacket_recvmsg(struct socket *, struct msghdr *, size_t,
670 : : int);
671 : :
672 : 0 : static int unix_set_peek_off(struct sock *sk, int val)
673 : : {
674 : 0 : struct unix_sock *u = unix_sk(sk);
675 : :
676 [ # # ]: 0 : if (mutex_lock_interruptible(&u->iolock))
677 : : return -EINTR;
678 : :
679 : 0 : sk->sk_peek_off = val;
680 : 0 : mutex_unlock(&u->iolock);
681 : :
682 : 0 : return 0;
683 : : }
684 : :
685 : : #ifdef CONFIG_PROC_FS
686 : 0 : static void unix_show_fdinfo(struct seq_file *m, struct socket *sock)
687 : : {
688 : 0 : struct sock *sk = sock->sk;
689 : 0 : struct unix_sock *u;
690 : :
691 [ # # ]: 0 : if (sk) {
692 : 0 : u = unix_sk(sock->sk);
693 : 0 : seq_printf(m, "scm_fds: %u\n", READ_ONCE(u->scm_stat.nr_fds));
694 : : }
695 : 0 : }
696 : : #else
697 : : #define unix_show_fdinfo NULL
698 : : #endif
699 : :
700 : : static const struct proto_ops unix_stream_ops = {
701 : : .family = PF_UNIX,
702 : : .owner = THIS_MODULE,
703 : : .release = unix_release,
704 : : .bind = unix_bind,
705 : : .connect = unix_stream_connect,
706 : : .socketpair = unix_socketpair,
707 : : .accept = unix_accept,
708 : : .getname = unix_getname,
709 : : .poll = unix_poll,
710 : : .ioctl = unix_ioctl,
711 : : #ifdef CONFIG_COMPAT
712 : : .compat_ioctl = unix_compat_ioctl,
713 : : #endif
714 : : .listen = unix_listen,
715 : : .shutdown = unix_shutdown,
716 : : .setsockopt = sock_no_setsockopt,
717 : : .getsockopt = sock_no_getsockopt,
718 : : .sendmsg = unix_stream_sendmsg,
719 : : .recvmsg = unix_stream_recvmsg,
720 : : .mmap = sock_no_mmap,
721 : : .sendpage = unix_stream_sendpage,
722 : : .splice_read = unix_stream_splice_read,
723 : : .set_peek_off = unix_set_peek_off,
724 : : .show_fdinfo = unix_show_fdinfo,
725 : : };
726 : :
727 : : static const struct proto_ops unix_dgram_ops = {
728 : : .family = PF_UNIX,
729 : : .owner = THIS_MODULE,
730 : : .release = unix_release,
731 : : .bind = unix_bind,
732 : : .connect = unix_dgram_connect,
733 : : .socketpair = unix_socketpair,
734 : : .accept = sock_no_accept,
735 : : .getname = unix_getname,
736 : : .poll = unix_dgram_poll,
737 : : .ioctl = unix_ioctl,
738 : : #ifdef CONFIG_COMPAT
739 : : .compat_ioctl = unix_compat_ioctl,
740 : : #endif
741 : : .listen = sock_no_listen,
742 : : .shutdown = unix_shutdown,
743 : : .setsockopt = sock_no_setsockopt,
744 : : .getsockopt = sock_no_getsockopt,
745 : : .sendmsg = unix_dgram_sendmsg,
746 : : .recvmsg = unix_dgram_recvmsg,
747 : : .mmap = sock_no_mmap,
748 : : .sendpage = sock_no_sendpage,
749 : : .set_peek_off = unix_set_peek_off,
750 : : .show_fdinfo = unix_show_fdinfo,
751 : : };
752 : :
753 : : static const struct proto_ops unix_seqpacket_ops = {
754 : : .family = PF_UNIX,
755 : : .owner = THIS_MODULE,
756 : : .release = unix_release,
757 : : .bind = unix_bind,
758 : : .connect = unix_stream_connect,
759 : : .socketpair = unix_socketpair,
760 : : .accept = unix_accept,
761 : : .getname = unix_getname,
762 : : .poll = unix_dgram_poll,
763 : : .ioctl = unix_ioctl,
764 : : #ifdef CONFIG_COMPAT
765 : : .compat_ioctl = unix_compat_ioctl,
766 : : #endif
767 : : .listen = unix_listen,
768 : : .shutdown = unix_shutdown,
769 : : .setsockopt = sock_no_setsockopt,
770 : : .getsockopt = sock_no_getsockopt,
771 : : .sendmsg = unix_seqpacket_sendmsg,
772 : : .recvmsg = unix_seqpacket_recvmsg,
773 : : .mmap = sock_no_mmap,
774 : : .sendpage = sock_no_sendpage,
775 : : .set_peek_off = unix_set_peek_off,
776 : : .show_fdinfo = unix_show_fdinfo,
777 : : };
778 : :
779 : : static struct proto unix_proto = {
780 : : .name = "UNIX",
781 : : .owner = THIS_MODULE,
782 : : .obj_size = sizeof(struct unix_sock),
783 : : };
784 : :
785 : 3179 : static struct sock *unix_create1(struct net *net, struct socket *sock, int kern)
786 : : {
787 : 3179 : struct sock *sk = NULL;
788 : 3179 : struct unix_sock *u;
789 : :
790 : 3179 : atomic_long_inc(&unix_nr_socks);
791 [ - + ]: 3179 : if (atomic_long_read(&unix_nr_socks) > 2 * get_max_files())
792 : 0 : goto out;
793 : :
794 : 3179 : sk = sk_alloc(net, PF_UNIX, GFP_KERNEL, &unix_proto, kern);
795 [ - + ]: 3179 : if (!sk)
796 : 0 : goto out;
797 : :
798 : 3179 : sock_init_data(sock, sk);
799 : :
800 : 3179 : sk->sk_allocation = GFP_KERNEL_ACCOUNT;
801 : 3179 : sk->sk_write_space = unix_write_space;
802 : 3179 : sk->sk_max_ack_backlog = net->unx.sysctl_max_dgram_qlen;
803 : 3179 : sk->sk_destruct = unix_sock_destructor;
804 : 3179 : u = unix_sk(sk);
805 : 3179 : u->path.dentry = NULL;
806 : 3179 : u->path.mnt = NULL;
807 : 3179 : spin_lock_init(&u->lock);
808 : 3179 : atomic_long_set(&u->inflight, 0);
809 : 3179 : INIT_LIST_HEAD(&u->link);
810 : 3179 : mutex_init(&u->iolock); /* single task reading lock */
811 : 3179 : mutex_init(&u->bindlock); /* single task binding lock */
812 : 3179 : init_waitqueue_head(&u->peer_wait);
813 : 3179 : init_waitqueue_func_entry(&u->peer_wake, unix_dgram_peer_wake_relay);
814 : 3179 : memset(&u->scm_stat, 0, sizeof(struct scm_stat));
815 : 3179 : unix_insert_socket(unix_sockets_unbound(sk), sk);
816 : 3179 : out:
817 [ - + ]: 3179 : if (sk == NULL)
818 : 0 : atomic_long_dec(&unix_nr_socks);
819 : : else {
820 : 3179 : local_bh_disable();
821 : 3179 : sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
822 : 3179 : local_bh_enable();
823 : : }
824 : 3179 : return sk;
825 : : }
826 : :
827 : 1947 : static int unix_create(struct net *net, struct socket *sock, int protocol,
828 : : int kern)
829 : : {
830 [ + - ]: 1947 : if (protocol && protocol != PF_UNIX)
831 : : return -EPROTONOSUPPORT;
832 : :
833 : 1947 : sock->state = SS_UNCONNECTED;
834 : :
835 [ + - + + : 1947 : switch (sock->type) {
- ]
836 : 1254 : case SOCK_STREAM:
837 : 1254 : sock->ops = &unix_stream_ops;
838 : 1254 : break;
839 : : /*
840 : : * Believe it or not BSD has AF_UNIX, SOCK_RAW though
841 : : * nothing uses it.
842 : : */
843 : 0 : case SOCK_RAW:
844 : 0 : sock->type = SOCK_DGRAM;
845 : : /* fall through */
846 : 682 : case SOCK_DGRAM:
847 : 682 : sock->ops = &unix_dgram_ops;
848 : 682 : break;
849 : 11 : case SOCK_SEQPACKET:
850 : 11 : sock->ops = &unix_seqpacket_ops;
851 : 11 : break;
852 : : default:
853 : : return -ESOCKTNOSUPPORT;
854 : : }
855 : :
856 [ - + ]: 1947 : return unix_create1(net, sock, kern) ? 0 : -ENOMEM;
857 : : }
858 : :
859 : 1925 : static int unix_release(struct socket *sock)
860 : : {
861 : 1925 : struct sock *sk = sock->sk;
862 : :
863 [ + - ]: 1925 : if (!sk)
864 : : return 0;
865 : :
866 : 1925 : unix_release_sock(sk, 0);
867 : 1925 : sock->sk = NULL;
868 : :
869 : 1925 : return 0;
870 : : }
871 : :
872 : : static int unix_autobind(struct socket *sock)
873 : : {
874 : : struct sock *sk = sock->sk;
875 : : struct net *net = sock_net(sk);
876 : : struct unix_sock *u = unix_sk(sk);
877 : : static u32 ordernum = 1;
878 : : struct unix_address *addr;
879 : : int err;
880 : : unsigned int retries = 0;
881 : :
882 : : err = mutex_lock_interruptible(&u->bindlock);
883 : : if (err)
884 : : return err;
885 : :
886 : : err = 0;
887 : : if (u->addr)
888 : : goto out;
889 : :
890 : : err = -ENOMEM;
891 : : addr = kzalloc(sizeof(*addr) + sizeof(short) + 16, GFP_KERNEL);
892 : : if (!addr)
893 : : goto out;
894 : :
895 : : addr->name->sun_family = AF_UNIX;
896 : : refcount_set(&addr->refcnt, 1);
897 : :
898 : : retry:
899 : : addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short);
900 : : addr->hash = unix_hash_fold(csum_partial(addr->name, addr->len, 0));
901 : :
902 : : spin_lock(&unix_table_lock);
903 : : ordernum = (ordernum+1)&0xFFFFF;
904 : :
905 : : if (__unix_find_socket_byname(net, addr->name, addr->len, sock->type,
906 : : addr->hash)) {
907 : : spin_unlock(&unix_table_lock);
908 : : /*
909 : : * __unix_find_socket_byname() may take long time if many names
910 : : * are already in use.
911 : : */
912 : : cond_resched();
913 : : /* Give up if all names seems to be in use. */
914 : : if (retries++ == 0xFFFFF) {
915 : : err = -ENOSPC;
916 : : kfree(addr);
917 : : goto out;
918 : : }
919 : : goto retry;
920 : : }
921 : : addr->hash ^= sk->sk_type;
922 : :
923 : : __unix_remove_socket(sk);
924 : : smp_store_release(&u->addr, addr);
925 : : __unix_insert_socket(&unix_socket_table[addr->hash], sk);
926 : : spin_unlock(&unix_table_lock);
927 : : err = 0;
928 : :
929 : : out: mutex_unlock(&u->bindlock);
930 : : return err;
931 : : }
932 : :
933 : 2782 : static struct sock *unix_find_other(struct net *net,
934 : : struct sockaddr_un *sunname, int len,
935 : : int type, unsigned int hash, int *error)
936 : : {
937 : 2782 : struct sock *u;
938 : 2782 : struct path path;
939 : 2782 : int err = 0;
940 : :
941 [ + + ]: 2782 : if (sunname->sun_path[0]) {
942 : 2485 : struct inode *inode;
943 : 2485 : err = kern_path(sunname->sun_path, LOOKUP_FOLLOW, &path);
944 [ + + ]: 2485 : if (err)
945 : 616 : goto fail;
946 : 1869 : inode = d_backing_inode(path.dentry);
947 : 1869 : err = inode_permission(inode, MAY_WRITE);
948 [ - + ]: 1869 : if (err)
949 : 0 : goto put_fail;
950 : :
951 : 1869 : err = -ECONNREFUSED;
952 [ - + ]: 1869 : if (!S_ISSOCK(inode->i_mode))
953 : 0 : goto put_fail;
954 : 1869 : u = unix_find_socket_byinode(inode);
955 [ - + ]: 1869 : if (!u)
956 : 0 : goto put_fail;
957 : :
958 [ + - ]: 1869 : if (u->sk_type == type)
959 : 1869 : touch_atime(&path);
960 : :
961 : 1869 : path_put(&path);
962 : :
963 : 1869 : err = -EPROTOTYPE;
964 [ - + ]: 1869 : if (u->sk_type != type) {
965 : 0 : sock_put(u);
966 : 0 : goto fail;
967 : : }
968 : : } else {
969 : 297 : err = -ECONNREFUSED;
970 : 297 : u = unix_find_socket_byname(net, sunname, len, type, hash);
971 [ - + ]: 297 : if (u) {
972 : 0 : struct dentry *dentry;
973 [ # # ]: 0 : dentry = unix_sk(u)->path.dentry;
974 [ # # ]: 0 : if (dentry)
975 : 0 : touch_atime(&unix_sk(u)->path);
976 : : } else
977 : 297 : goto fail;
978 : : }
979 : : return u;
980 : :
981 : 0 : put_fail:
982 : 0 : path_put(&path);
983 : 913 : fail:
984 : 913 : *error = err;
985 : 913 : return NULL;
986 : : }
987 : :
988 : 77 : static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
989 : : {
990 : 77 : struct dentry *dentry;
991 : 77 : struct path path;
992 : 77 : int err = 0;
993 : : /*
994 : : * Get the parent directory, calculate the hash for last
995 : : * component.
996 : : */
997 : 77 : dentry = kern_path_create(AT_FDCWD, sun_path, &path, 0);
998 [ + - ]: 77 : err = PTR_ERR(dentry);
999 [ + - ]: 77 : if (IS_ERR(dentry))
1000 : : return err;
1001 : :
1002 : : /*
1003 : : * All right, let's create it.
1004 : : */
1005 : 77 : err = security_path_mknod(&path, dentry, mode, 0);
1006 : 77 : if (!err) {
1007 : 77 : err = vfs_mknod(d_inode(path.dentry), dentry, mode, 0);
1008 [ + - ]: 77 : if (!err) {
1009 : 77 : res->mnt = mntget(path.mnt);
1010 [ + - ]: 154 : res->dentry = dget(dentry);
1011 : : }
1012 : : }
1013 : 77 : done_path_create(&path, dentry);
1014 : 77 : return err;
1015 : : }
1016 : :
1017 : 77 : static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1018 : : {
1019 : 77 : struct sock *sk = sock->sk;
1020 [ + - ]: 77 : struct net *net = sock_net(sk);
1021 [ + - ]: 77 : struct unix_sock *u = unix_sk(sk);
1022 : 77 : struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
1023 : 77 : char *sun_path = sunaddr->sun_path;
1024 : 77 : int err;
1025 : 77 : unsigned int hash;
1026 : 77 : struct unix_address *addr;
1027 : 77 : struct hlist_head *list;
1028 : 77 : struct path path = { };
1029 : :
1030 : 77 : err = -EINVAL;
1031 [ + - ]: 77 : if (addr_len < offsetofend(struct sockaddr_un, sun_family) ||
1032 [ - + ]: 77 : sunaddr->sun_family != AF_UNIX)
1033 : 0 : goto out;
1034 : :
1035 [ - + ]: 77 : if (addr_len == sizeof(short)) {
1036 : 0 : err = unix_autobind(sock);
1037 : 0 : goto out;
1038 : : }
1039 : :
1040 : 77 : err = unix_mkname(sunaddr, addr_len, &hash);
1041 [ - + ]: 77 : if (err < 0)
1042 : 0 : goto out;
1043 : 77 : addr_len = err;
1044 : :
1045 [ + - ]: 77 : if (sun_path[0]) {
1046 : 77 : umode_t mode = S_IFSOCK |
1047 : 77 : (SOCK_INODE(sock)->i_mode & ~current_umask());
1048 : 77 : err = unix_mknod(sun_path, mode, &path);
1049 [ - + ]: 77 : if (err) {
1050 [ # # ]: 0 : if (err == -EEXIST)
1051 : 0 : err = -EADDRINUSE;
1052 : 0 : goto out;
1053 : : }
1054 : : }
1055 : :
1056 : 77 : err = mutex_lock_interruptible(&u->bindlock);
1057 [ - + ]: 77 : if (err)
1058 : 0 : goto out_put;
1059 : :
1060 : 77 : err = -EINVAL;
1061 [ - + ]: 77 : if (u->addr)
1062 : 0 : goto out_up;
1063 : :
1064 : 77 : err = -ENOMEM;
1065 [ - + ]: 77 : addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
1066 [ - + ]: 77 : if (!addr)
1067 : 0 : goto out_up;
1068 : :
1069 : 77 : memcpy(addr->name, sunaddr, addr_len);
1070 : 77 : addr->len = addr_len;
1071 : 77 : addr->hash = hash ^ sk->sk_type;
1072 : 77 : refcount_set(&addr->refcnt, 1);
1073 : :
1074 [ + - ]: 77 : if (sun_path[0]) {
1075 : 77 : addr->hash = UNIX_HASH_SIZE;
1076 : 77 : hash = d_backing_inode(path.dentry)->i_ino & (UNIX_HASH_SIZE - 1);
1077 : 77 : spin_lock(&unix_table_lock);
1078 : 77 : u->path = path;
1079 : 77 : list = &unix_socket_table[hash];
1080 : : } else {
1081 : 0 : spin_lock(&unix_table_lock);
1082 : 0 : err = -EADDRINUSE;
1083 [ # # ]: 0 : if (__unix_find_socket_byname(net, sunaddr, addr_len,
1084 : 0 : sk->sk_type, hash)) {
1085 : 0 : unix_release_addr(addr);
1086 : 0 : goto out_unlock;
1087 : : }
1088 : :
1089 : 0 : list = &unix_socket_table[addr->hash];
1090 : : }
1091 : :
1092 : 77 : err = 0;
1093 : 77 : __unix_remove_socket(sk);
1094 : 77 : smp_store_release(&u->addr, addr);
1095 : 77 : __unix_insert_socket(list, sk);
1096 : :
1097 : 77 : out_unlock:
1098 : 77 : spin_unlock(&unix_table_lock);
1099 : 77 : out_up:
1100 : 77 : mutex_unlock(&u->bindlock);
1101 : 77 : out_put:
1102 [ + - ]: 77 : if (err)
1103 : 0 : path_put(&path);
1104 : 77 : out:
1105 : 77 : return err;
1106 : : }
1107 : :
1108 : 242 : static void unix_state_double_lock(struct sock *sk1, struct sock *sk2)
1109 : : {
1110 [ + - - + ]: 242 : if (unlikely(sk1 == sk2) || !sk2) {
1111 : 0 : unix_state_lock(sk1);
1112 : 0 : return;
1113 : : }
1114 [ + + ]: 242 : if (sk1 < sk2) {
1115 : 172 : unix_state_lock(sk1);
1116 : 172 : unix_state_lock_nested(sk2);
1117 : : } else {
1118 : 70 : unix_state_lock(sk2);
1119 : 70 : unix_state_lock_nested(sk1);
1120 : : }
1121 : : }
1122 : :
1123 : 242 : static void unix_state_double_unlock(struct sock *sk1, struct sock *sk2)
1124 : : {
1125 [ - - - + ]: 242 : if (unlikely(sk1 == sk2) || !sk2) {
1126 : 0 : unix_state_unlock(sk1);
1127 : 0 : return;
1128 : : }
1129 : 242 : unix_state_unlock(sk1);
1130 : 242 : unix_state_unlock(sk2);
1131 : : }
1132 : :
1133 : 242 : static int unix_dgram_connect(struct socket *sock, struct sockaddr *addr,
1134 : : int alen, int flags)
1135 : : {
1136 : 242 : struct sock *sk = sock->sk;
1137 [ - + ]: 242 : struct net *net = sock_net(sk);
1138 : 242 : struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
1139 : 242 : struct sock *other;
1140 : 242 : unsigned int hash;
1141 : 242 : int err;
1142 : :
1143 : 242 : err = -EINVAL;
1144 [ - + ]: 242 : if (alen < offsetofend(struct sockaddr, sa_family))
1145 : 0 : goto out;
1146 : :
1147 [ + - ]: 242 : if (addr->sa_family != AF_UNSPEC) {
1148 : 242 : err = unix_mkname(sunaddr, alen, &hash);
1149 [ - + ]: 242 : if (err < 0)
1150 : 0 : goto out;
1151 : 242 : alen = err;
1152 : :
1153 [ + - ]: 242 : if (test_bit(SOCK_PASSCRED, &sock->flags) &&
1154 [ # # # # ]: 0 : !unix_sk(sk)->addr && (err = unix_autobind(sock)) != 0)
1155 : 0 : goto out;
1156 : :
1157 : 242 : restart:
1158 : 242 : other = unix_find_other(net, sunaddr, alen, sock->type, hash, &err);
1159 [ - + ]: 242 : if (!other)
1160 : 0 : goto out;
1161 : :
1162 : 242 : unix_state_double_lock(sk, other);
1163 : :
1164 : : /* Apparently VFS overslept socket death. Retry. */
1165 [ - + ]: 242 : if (sock_flag(other, SOCK_DEAD)) {
1166 [ # # ]: 0 : unix_state_double_unlock(sk, other);
1167 : 0 : sock_put(other);
1168 : 0 : goto restart;
1169 : : }
1170 : :
1171 : 242 : err = -EPERM;
1172 [ - + ]: 242 : if (!unix_may_send(sk, other))
1173 : 0 : goto out_unlock;
1174 : :
1175 : 242 : err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1176 [ - + ]: 242 : if (err)
1177 : 0 : goto out_unlock;
1178 : :
1179 : : } else {
1180 : : /*
1181 : : * 1003.1g breaking connected state with AF_UNSPEC
1182 : : */
1183 : 0 : other = NULL;
1184 : 0 : unix_state_double_lock(sk, other);
1185 : : }
1186 : :
1187 : : /*
1188 : : * If it was connected, reconnect.
1189 : : */
1190 [ - + ]: 242 : if (unix_peer(sk)) {
1191 : 0 : struct sock *old_peer = unix_peer(sk);
1192 : 0 : unix_peer(sk) = other;
1193 : 0 : unix_dgram_peer_wake_disconnect_wakeup(sk, old_peer);
1194 : :
1195 [ # # ]: 0 : unix_state_double_unlock(sk, other);
1196 : :
1197 [ # # ]: 0 : if (other != old_peer)
1198 : 0 : unix_dgram_disconnected(sk, old_peer);
1199 : 0 : sock_put(old_peer);
1200 : : } else {
1201 [ + - ]: 242 : unix_peer(sk) = other;
1202 [ + - ]: 242 : unix_state_double_unlock(sk, other);
1203 : : }
1204 : : return 0;
1205 : :
1206 : 0 : out_unlock:
1207 [ # # ]: 0 : unix_state_double_unlock(sk, other);
1208 : 0 : sock_put(other);
1209 : 0 : out:
1210 : 0 : return err;
1211 : : }
1212 : :
1213 : 0 : static long unix_wait_for_peer(struct sock *other, long timeo)
1214 : : {
1215 : 0 : struct unix_sock *u = unix_sk(other);
1216 : 0 : int sched;
1217 : 0 : DEFINE_WAIT(wait);
1218 : :
1219 : 0 : prepare_to_wait_exclusive(&u->peer_wait, &wait, TASK_INTERRUPTIBLE);
1220 : :
1221 : 0 : sched = !sock_flag(other, SOCK_DEAD) &&
1222 [ # # # # : 0 : !(other->sk_shutdown & RCV_SHUTDOWN) &&
# # ]
1223 : : unix_recvq_full(other);
1224 : :
1225 : 0 : unix_state_unlock(other);
1226 : :
1227 [ # # ]: 0 : if (sched)
1228 : 0 : timeo = schedule_timeout(timeo);
1229 : :
1230 : 0 : finish_wait(&u->peer_wait, &wait);
1231 : 0 : return timeo;
1232 : : }
1233 : :
1234 : 1232 : static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr,
1235 : : int addr_len, int flags)
1236 : : {
1237 : 1232 : struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
1238 : 1232 : struct sock *sk = sock->sk;
1239 : 1232 : struct net *net = sock_net(sk);
1240 : 1232 : struct unix_sock *u = unix_sk(sk), *newu, *otheru;
1241 : 1232 : struct sock *newsk = NULL;
1242 : 1232 : struct sock *other = NULL;
1243 : 1232 : struct sk_buff *skb = NULL;
1244 : 1232 : unsigned int hash;
1245 : 1232 : int st;
1246 : 1232 : int err;
1247 : 1232 : long timeo;
1248 : :
1249 : 1232 : err = unix_mkname(sunaddr, addr_len, &hash);
1250 [ - + ]: 1232 : if (err < 0)
1251 : 0 : goto out;
1252 : 1232 : addr_len = err;
1253 : :
1254 [ - + - - ]: 1232 : if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr &&
1255 [ # # ]: 0 : (err = unix_autobind(sock)) != 0)
1256 : 0 : goto out;
1257 : :
1258 [ + + ]: 1232 : timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
1259 : :
1260 : : /* First of all allocate resources.
1261 : : If we will make it after state is locked,
1262 : : we will have to recheck all again in any case.
1263 : : */
1264 : :
1265 : 1232 : err = -ENOMEM;
1266 : :
1267 : : /* create new sock for complete connection */
1268 : 1232 : newsk = unix_create1(sock_net(sk), NULL, 0);
1269 [ - + ]: 1232 : if (newsk == NULL)
1270 : 0 : goto out;
1271 : :
1272 : : /* Allocate skb for sending to listening sock */
1273 : 1232 : skb = sock_wmalloc(newsk, 1, 0, GFP_KERNEL);
1274 [ + - ]: 1232 : if (skb == NULL)
1275 : 0 : goto out;
1276 : :
1277 : 1232 : restart:
1278 : : /* Find listening sock. */
1279 : 1232 : other = unix_find_other(net, sunaddr, addr_len, sk->sk_type, hash, &err);
1280 [ + + ]: 1232 : if (!other)
1281 : 913 : goto out;
1282 : :
1283 : : /* Latch state of peer */
1284 : 319 : unix_state_lock(other);
1285 : :
1286 : : /* Apparently VFS overslept socket death. Retry. */
1287 [ - + ]: 319 : if (sock_flag(other, SOCK_DEAD)) {
1288 : 0 : unix_state_unlock(other);
1289 : 0 : sock_put(other);
1290 : 0 : goto restart;
1291 : : }
1292 : :
1293 : 319 : err = -ECONNREFUSED;
1294 [ - + ]: 319 : if (other->sk_state != TCP_LISTEN)
1295 : 0 : goto out_unlock;
1296 [ - + ]: 319 : if (other->sk_shutdown & RCV_SHUTDOWN)
1297 : 0 : goto out_unlock;
1298 : :
1299 [ - + ]: 319 : if (unix_recvq_full(other)) {
1300 : 0 : err = -EAGAIN;
1301 [ # # ]: 0 : if (!timeo)
1302 : 0 : goto out_unlock;
1303 : :
1304 : 0 : timeo = unix_wait_for_peer(other, timeo);
1305 : :
1306 [ # # ]: 0 : err = sock_intr_errno(timeo);
1307 [ # # ]: 0 : if (signal_pending(current))
1308 : 0 : goto out;
1309 : 0 : sock_put(other);
1310 : 0 : goto restart;
1311 : : }
1312 : :
1313 : : /* Latch our state.
1314 : :
1315 : : It is tricky place. We need to grab our state lock and cannot
1316 : : drop lock on peer. It is dangerous because deadlock is
1317 : : possible. Connect to self case and simultaneous
1318 : : attempt to connect are eliminated by checking socket
1319 : : state. other is TCP_LISTEN, if sk is TCP_LISTEN we
1320 : : check this before attempt to grab lock.
1321 : :
1322 : : Well, and we have to recheck the state after socket locked.
1323 : : */
1324 : 319 : st = sk->sk_state;
1325 : :
1326 [ - - + ]: 319 : switch (st) {
1327 : : case TCP_CLOSE:
1328 : : /* This is ok... continue with connect */
1329 : 319 : break;
1330 : 0 : case TCP_ESTABLISHED:
1331 : : /* Socket is already connected */
1332 : 0 : err = -EISCONN;
1333 : 0 : goto out_unlock;
1334 : 0 : default:
1335 : 0 : err = -EINVAL;
1336 : 0 : goto out_unlock;
1337 : : }
1338 : :
1339 : 319 : unix_state_lock_nested(sk);
1340 : :
1341 [ - + ]: 319 : if (sk->sk_state != st) {
1342 : 0 : unix_state_unlock(sk);
1343 : 0 : unix_state_unlock(other);
1344 : 0 : sock_put(other);
1345 : 0 : goto restart;
1346 : : }
1347 : :
1348 : 319 : err = security_unix_stream_connect(sk, other, newsk);
1349 [ - + ]: 319 : if (err) {
1350 : 0 : unix_state_unlock(sk);
1351 : 0 : goto out_unlock;
1352 : : }
1353 : :
1354 : : /* The way is open! Fastly set all the necessary fields... */
1355 : :
1356 : 319 : sock_hold(sk);
1357 : 319 : unix_peer(newsk) = sk;
1358 : 319 : newsk->sk_state = TCP_ESTABLISHED;
1359 : 319 : newsk->sk_type = sk->sk_type;
1360 : 319 : init_peercred(newsk);
1361 [ + - ]: 319 : newu = unix_sk(newsk);
1362 [ + - ]: 319 : RCU_INIT_POINTER(newsk->sk_wq, &newu->peer_wq);
1363 : 319 : otheru = unix_sk(other);
1364 : :
1365 : : /* copy address information from listening to new sock
1366 : : *
1367 : : * The contents of *(otheru->addr) and otheru->path
1368 : : * are seen fully set up here, since we have found
1369 : : * otheru in hash under unix_table_lock. Insertion
1370 : : * into the hash chain we'd found it in had been done
1371 : : * in an earlier critical area protected by unix_table_lock,
1372 : : * the same one where we'd set *(otheru->addr) contents,
1373 : : * as well as otheru->path and otheru->addr itself.
1374 : : *
1375 : : * Using smp_store_release() here to set newu->addr
1376 : : * is enough to make those stores, as well as stores
1377 : : * to newu->path visible to anyone who gets newu->addr
1378 : : * by smp_load_acquire(). IOW, the same warranties
1379 : : * as for unix_sock instances bound in unix_bind() or
1380 : : * in unix_autobind().
1381 : : */
1382 [ + - ]: 319 : if (otheru->path.dentry) {
1383 : 319 : path_get(&otheru->path);
1384 : 319 : newu->path = otheru->path;
1385 : : }
1386 : 319 : refcount_inc(&otheru->addr->refcnt);
1387 : 319 : smp_store_release(&newu->addr, otheru->addr);
1388 : :
1389 : : /* Set credentials */
1390 : 319 : copy_peercred(sk, other);
1391 : :
1392 : 319 : sock->state = SS_CONNECTED;
1393 : 319 : sk->sk_state = TCP_ESTABLISHED;
1394 : 319 : sock_hold(newsk);
1395 : :
1396 : 319 : smp_mb__after_atomic(); /* sock_hold() does an atomic_inc() */
1397 : 319 : unix_peer(sk) = newsk;
1398 : :
1399 : 319 : unix_state_unlock(sk);
1400 : :
1401 : : /* take ten and and send info to listening sock */
1402 : 319 : spin_lock(&other->sk_receive_queue.lock);
1403 : 319 : __skb_queue_tail(&other->sk_receive_queue, skb);
1404 : 319 : spin_unlock(&other->sk_receive_queue.lock);
1405 : 319 : unix_state_unlock(other);
1406 : 319 : other->sk_data_ready(other);
1407 : 319 : sock_put(other);
1408 : 319 : return 0;
1409 : :
1410 : 0 : out_unlock:
1411 : 0 : if (other)
1412 : 0 : unix_state_unlock(other);
1413 : :
1414 : 913 : out:
1415 : 913 : kfree_skb(skb);
1416 [ + - ]: 913 : if (newsk)
1417 : 913 : unix_release_sock(newsk, 0);
1418 [ - + ]: 913 : if (other)
1419 : 0 : sock_put(other);
1420 : 913 : return err;
1421 : : }
1422 : :
1423 : 44 : static int unix_socketpair(struct socket *socka, struct socket *sockb)
1424 : : {
1425 : 44 : struct sock *ska = socka->sk, *skb = sockb->sk;
1426 : :
1427 : : /* Join our sockets back to back */
1428 : 44 : sock_hold(ska);
1429 : 44 : sock_hold(skb);
1430 : 44 : unix_peer(ska) = skb;
1431 : 44 : unix_peer(skb) = ska;
1432 : 44 : init_peercred(ska);
1433 : 44 : init_peercred(skb);
1434 : :
1435 [ - + ]: 44 : if (ska->sk_type != SOCK_DGRAM) {
1436 : 0 : ska->sk_state = TCP_ESTABLISHED;
1437 : 0 : skb->sk_state = TCP_ESTABLISHED;
1438 : 0 : socka->state = SS_CONNECTED;
1439 : 0 : sockb->state = SS_CONNECTED;
1440 : : }
1441 : 44 : return 0;
1442 : : }
1443 : :
1444 : 319 : static void unix_sock_inherit_flags(const struct socket *old,
1445 : : struct socket *new)
1446 : : {
1447 [ + + ]: 319 : if (test_bit(SOCK_PASSCRED, &old->flags))
1448 : 286 : set_bit(SOCK_PASSCRED, &new->flags);
1449 [ + + ]: 319 : if (test_bit(SOCK_PASSSEC, &old->flags))
1450 : 286 : set_bit(SOCK_PASSSEC, &new->flags);
1451 : 319 : }
1452 : :
1453 : 319 : static int unix_accept(struct socket *sock, struct socket *newsock, int flags,
1454 : : bool kern)
1455 : : {
1456 : 319 : struct sock *sk = sock->sk;
1457 : 319 : struct sock *tsk;
1458 : 319 : struct sk_buff *skb;
1459 : 319 : int err;
1460 : :
1461 : 319 : err = -EOPNOTSUPP;
1462 [ - + ]: 319 : if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
1463 : 0 : goto out;
1464 : :
1465 : 319 : err = -EINVAL;
1466 [ - + ]: 319 : if (sk->sk_state != TCP_LISTEN)
1467 : 0 : goto out;
1468 : :
1469 : : /* If socket state is TCP_LISTEN it cannot change (for now...),
1470 : : * so that no locks are necessary.
1471 : : */
1472 : :
1473 : 319 : skb = skb_recv_datagram(sk, 0, flags&O_NONBLOCK, &err);
1474 [ - + ]: 319 : if (!skb) {
1475 : : /* This means receive shutdown. */
1476 [ # # ]: 0 : if (err == 0)
1477 : 0 : err = -EINVAL;
1478 : 0 : goto out;
1479 : : }
1480 : :
1481 : 319 : tsk = skb->sk;
1482 : 319 : skb_free_datagram(sk, skb);
1483 : 319 : wake_up_interruptible(&unix_sk(sk)->peer_wait);
1484 : :
1485 : : /* attach accepted sock to socket */
1486 : 319 : unix_state_lock(tsk);
1487 : 319 : newsock->state = SS_CONNECTED;
1488 : 319 : unix_sock_inherit_flags(sock, newsock);
1489 : 319 : sock_graft(tsk, newsock);
1490 : 319 : unix_state_unlock(tsk);
1491 : 319 : return 0;
1492 : :
1493 : 0 : out:
1494 : 0 : return err;
1495 : : }
1496 : :
1497 : :
1498 : 143 : static int unix_getname(struct socket *sock, struct sockaddr *uaddr, int peer)
1499 : : {
1500 : 143 : struct sock *sk = sock->sk;
1501 : 143 : struct unix_address *addr;
1502 : 143 : DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, uaddr);
1503 : 143 : int err = 0;
1504 : :
1505 [ - + ]: 143 : if (peer) {
1506 : 0 : sk = unix_peer_get(sk);
1507 : :
1508 : 0 : err = -ENOTCONN;
1509 [ # # ]: 0 : if (!sk)
1510 : 0 : goto out;
1511 : : err = 0;
1512 : : } else {
1513 : 143 : sock_hold(sk);
1514 : : }
1515 : :
1516 : 143 : addr = smp_load_acquire(&unix_sk(sk)->addr);
1517 [ + + ]: 143 : if (!addr) {
1518 : 33 : sunaddr->sun_family = AF_UNIX;
1519 : 33 : sunaddr->sun_path[0] = 0;
1520 : 33 : err = sizeof(short);
1521 : : } else {
1522 : 110 : err = addr->len;
1523 : 110 : memcpy(sunaddr, addr->name, addr->len);
1524 : : }
1525 : 143 : sock_put(sk);
1526 : 143 : out:
1527 : 143 : return err;
1528 : : }
1529 : :
1530 : 9726 : static int unix_scm_to_skb(struct scm_cookie *scm, struct sk_buff *skb, bool send_fds)
1531 : : {
1532 : 9726 : int err = 0;
1533 : :
1534 [ + + ]: 9726 : UNIXCB(skb).pid = get_pid(scm->pid);
1535 : 9726 : UNIXCB(skb).uid = scm->creds.uid;
1536 : 9726 : UNIXCB(skb).gid = scm->creds.gid;
1537 : 9726 : UNIXCB(skb).fp = NULL;
1538 : 9726 : unix_get_secdata(scm, skb);
1539 [ + + + - ]: 9726 : if (scm->fp && send_fds)
1540 : 286 : err = unix_attach_fds(scm, skb);
1541 : :
1542 : 9726 : skb->destructor = unix_destruct_scm;
1543 : 9726 : return err;
1544 : : }
1545 : :
1546 : 8715 : static bool unix_passcred_enabled(const struct socket *sock,
1547 : : const struct sock *other)
1548 : : {
1549 : 8715 : return test_bit(SOCK_PASSCRED, &sock->flags) ||
1550 [ + - + + : 17248 : !other->sk_socket ||
+ + ]
1551 : 8533 : test_bit(SOCK_PASSCRED, &other->sk_socket->flags);
1552 : : }
1553 : :
1554 : : /*
1555 : : * Some apps rely on write() giving SCM_CREDENTIALS
1556 : : * We include credentials if source or destination socket
1557 : : * asserted SOCK_PASSCRED.
1558 : : */
1559 : 9726 : static void maybe_add_creds(struct sk_buff *skb, const struct socket *sock,
1560 : : const struct sock *other)
1561 : : {
1562 [ + + ]: 9726 : if (UNIXCB(skb).pid)
1563 : : return;
1564 [ + + ]: 8715 : if (unix_passcred_enabled(sock, other)) {
1565 [ + - ]: 7900 : UNIXCB(skb).pid = get_pid(task_tgid(current));
1566 : 7900 : current_uid_gid(&UNIXCB(skb).uid, &UNIXCB(skb).gid);
1567 : : }
1568 : : }
1569 : :
1570 : 0 : static int maybe_init_creds(struct scm_cookie *scm,
1571 : : struct socket *socket,
1572 : : const struct sock *other)
1573 : : {
1574 : 0 : int err;
1575 : 0 : struct msghdr msg = { .msg_controllen = 0 };
1576 : :
1577 : 0 : err = scm_send(socket, &msg, scm, false);
1578 [ # # ]: 0 : if (err)
1579 : : return err;
1580 : :
1581 [ # # ]: 0 : if (unix_passcred_enabled(socket, other)) {
1582 [ # # ]: 0 : scm->pid = get_pid(task_tgid(current));
1583 : 0 : current_uid_gid(&scm->creds.uid, &scm->creds.gid);
1584 : : }
1585 : : return err;
1586 : : }
1587 : :
1588 : 0 : static bool unix_skb_scm_eq(struct sk_buff *skb,
1589 : : struct scm_cookie *scm)
1590 : : {
1591 : 0 : const struct unix_skb_parms *u = &UNIXCB(skb);
1592 : :
1593 [ # # # # ]: 0 : return u->pid == scm->pid &&
1594 [ # # # # ]: 0 : uid_eq(u->uid, scm->creds.uid) &&
1595 [ # # ]: 0 : gid_eq(u->gid, scm->creds.gid) &&
1596 [ # # # # ]: 0 : unix_secdata_eq(scm, skb);
1597 : : }
1598 : :
1599 : 9726 : static void scm_stat_add(struct sock *sk, struct sk_buff *skb)
1600 : : {
1601 : 9726 : struct scm_fp_list *fp = UNIXCB(skb).fp;
1602 : 9726 : struct unix_sock *u = unix_sk(sk);
1603 : :
1604 : 9726 : lockdep_assert_held(&sk->sk_receive_queue.lock);
1605 : :
1606 [ - + - - : 9726 : if (unlikely(fp && fp->count))
+ + + - ]
1607 : 286 : u->scm_stat.nr_fds += fp->count;
1608 : : }
1609 : :
1610 : 8798 : static void scm_stat_del(struct sock *sk, struct sk_buff *skb)
1611 : : {
1612 : 8798 : struct scm_fp_list *fp = UNIXCB(skb).fp;
1613 [ + + ]: 8798 : struct unix_sock *u = unix_sk(sk);
1614 : :
1615 : 8798 : lockdep_assert_held(&sk->sk_receive_queue.lock);
1616 : :
1617 [ - - - - : 8798 : if (unlikely(fp && fp->count))
+ + + - ]
1618 : 286 : u->scm_stat.nr_fds -= fp->count;
1619 : 8798 : }
1620 : :
1621 : : /*
1622 : : * Send AF_UNIX data.
1623 : : */
1624 : :
1625 : 8875 : static int unix_dgram_sendmsg(struct socket *sock, struct msghdr *msg,
1626 : : size_t len)
1627 : : {
1628 : 8875 : struct sock *sk = sock->sk;
1629 : 8875 : struct net *net = sock_net(sk);
1630 : 8875 : struct unix_sock *u = unix_sk(sk);
1631 : 8875 : DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, msg->msg_name);
1632 : 8875 : struct sock *other = NULL;
1633 : 8875 : int namelen = 0; /* fake GCC */
1634 : 8875 : int err;
1635 : 8875 : unsigned int hash;
1636 : 8875 : struct sk_buff *skb;
1637 : 8875 : long timeo;
1638 : 8875 : struct scm_cookie scm;
1639 : 8875 : int data_len = 0;
1640 : 8875 : int sk_locked;
1641 : :
1642 : 8875 : wait_for_unix_gc();
1643 : 8875 : err = scm_send(sock, msg, &scm, false);
1644 [ + + ]: 8875 : if (err < 0)
1645 : : return err;
1646 : :
1647 : 8798 : err = -EOPNOTSUPP;
1648 [ - + ]: 8798 : if (msg->msg_flags&MSG_OOB)
1649 : 0 : goto out;
1650 : :
1651 [ + + ]: 8798 : if (msg->msg_namelen) {
1652 : 1308 : err = unix_mkname(sunaddr, msg->msg_namelen, &hash);
1653 [ - + ]: 1308 : if (err < 0)
1654 : 0 : goto out;
1655 : : namelen = err;
1656 : : } else {
1657 : 7490 : sunaddr = NULL;
1658 : 7490 : err = -ENOTCONN;
1659 : 7490 : other = unix_peer_get(sk);
1660 [ - + ]: 7490 : if (!other)
1661 : 0 : goto out;
1662 : : }
1663 : :
1664 [ + + - + ]: 8798 : if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr
1665 [ # # ]: 0 : && (err = unix_autobind(sock)) != 0)
1666 : 0 : goto out;
1667 : :
1668 : 8798 : err = -EMSGSIZE;
1669 [ - + ]: 8798 : if (len > sk->sk_sndbuf - 32)
1670 : 0 : goto out;
1671 : :
1672 [ - + ]: 8798 : if (len > SKB_MAX_ALLOC) {
1673 : 0 : data_len = min_t(size_t,
1674 : : len - SKB_MAX_ALLOC,
1675 : : MAX_SKB_FRAGS * PAGE_SIZE);
1676 : 0 : data_len = PAGE_ALIGN(data_len);
1677 : :
1678 : 0 : BUILD_BUG_ON(SKB_MAX_ALLOC < PAGE_SIZE);
1679 : : }
1680 : :
1681 : 8798 : skb = sock_alloc_send_pskb(sk, len - data_len, data_len,
1682 : 8798 : msg->msg_flags & MSG_DONTWAIT, &err,
1683 : : PAGE_ALLOC_COSTLY_ORDER);
1684 [ - + ]: 8798 : if (skb == NULL)
1685 : 0 : goto out;
1686 : :
1687 : 8798 : err = unix_scm_to_skb(&scm, skb, true);
1688 [ - + ]: 8798 : if (err < 0)
1689 : 0 : goto out_free;
1690 : :
1691 : 8798 : skb_put(skb, len - data_len);
1692 : 8798 : skb->data_len = data_len;
1693 : 8798 : skb->len = len;
1694 : 8798 : err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, len);
1695 [ - + ]: 8798 : if (err)
1696 : 0 : goto out_free;
1697 : :
1698 [ + + ]: 8798 : timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1699 : :
1700 : 8798 : restart:
1701 [ + + ]: 8798 : if (!other) {
1702 : 1308 : err = -ECONNRESET;
1703 [ - + ]: 1308 : if (sunaddr == NULL)
1704 : 0 : goto out_free;
1705 : :
1706 : 1308 : other = unix_find_other(net, sunaddr, namelen, sk->sk_type,
1707 : : hash, &err);
1708 [ - + ]: 1308 : if (other == NULL)
1709 : 0 : goto out_free;
1710 : : }
1711 : :
1712 [ - + ]: 8798 : if (sk_filter(other, skb) < 0) {
1713 : : /* Toss the packet but do not return any error to the sender */
1714 : 0 : err = len;
1715 : 0 : goto out_free;
1716 : : }
1717 : :
1718 : 8798 : sk_locked = 0;
1719 : 8798 : unix_state_lock(other);
1720 : 8798 : restart_locked:
1721 : 8798 : err = -EPERM;
1722 [ + + ]: 8798 : if (!unix_may_send(sk, other))
1723 : 0 : goto out_unlock;
1724 : :
1725 [ - + ]: 8798 : if (unlikely(sock_flag(other, SOCK_DEAD))) {
1726 : : /*
1727 : : * Check with 1003.1g - what should
1728 : : * datagram error
1729 : : */
1730 : 0 : unix_state_unlock(other);
1731 : 0 : sock_put(other);
1732 : :
1733 [ # # ]: 0 : if (!sk_locked)
1734 : 0 : unix_state_lock(sk);
1735 : :
1736 : 0 : err = 0;
1737 [ # # ]: 0 : if (unix_peer(sk) == other) {
1738 : 0 : unix_peer(sk) = NULL;
1739 : 0 : unix_dgram_peer_wake_disconnect_wakeup(sk, other);
1740 : :
1741 : 0 : unix_state_unlock(sk);
1742 : :
1743 : 0 : unix_dgram_disconnected(sk, other);
1744 : 0 : sock_put(other);
1745 : 0 : err = -ECONNREFUSED;
1746 : : } else {
1747 : 0 : unix_state_unlock(sk);
1748 : : }
1749 : :
1750 : 0 : other = NULL;
1751 [ # # ]: 0 : if (err)
1752 : 0 : goto out_free;
1753 : 0 : goto restart;
1754 : : }
1755 : :
1756 : 8798 : err = -EPIPE;
1757 [ - + ]: 8798 : if (other->sk_shutdown & RCV_SHUTDOWN)
1758 : 0 : goto out_unlock;
1759 : :
1760 [ + - ]: 8798 : if (sk->sk_type != SOCK_SEQPACKET) {
1761 : 8798 : err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1762 [ - + ]: 8798 : if (err)
1763 : 0 : goto out_unlock;
1764 : : }
1765 : :
1766 : : /* other == sk && unix_peer(other) != sk if
1767 : : * - unix_peer(sk) == NULL, destination address bound to sk
1768 : : * - unix_peer(sk) == sk by time of get but disconnected before lock
1769 : : */
1770 [ + - ]: 8798 : if (other != sk &&
1771 [ + + - + ]: 8798 : unlikely(unix_peer(other) != sk &&
1772 : : unix_recvq_full_lockless(other))) {
1773 [ # # ]: 0 : if (timeo) {
1774 : 0 : timeo = unix_wait_for_peer(other, timeo);
1775 : :
1776 [ # # ]: 0 : err = sock_intr_errno(timeo);
1777 [ # # ]: 0 : if (signal_pending(current))
1778 : 0 : goto out_free;
1779 : :
1780 : 0 : goto restart;
1781 : : }
1782 : :
1783 [ # # ]: 0 : if (!sk_locked) {
1784 : 0 : unix_state_unlock(other);
1785 : 0 : unix_state_double_lock(sk, other);
1786 : : }
1787 : :
1788 [ # # # # ]: 0 : if (unix_peer(sk) != other ||
1789 : 0 : unix_dgram_peer_wake_me(sk, other)) {
1790 : 0 : err = -EAGAIN;
1791 : 0 : sk_locked = 1;
1792 : 0 : goto out_unlock;
1793 : : }
1794 : :
1795 [ # # ]: 0 : if (!sk_locked) {
1796 : 0 : sk_locked = 1;
1797 : 0 : goto restart_locked;
1798 : : }
1799 : : }
1800 : :
1801 [ - + ]: 8798 : if (unlikely(sk_locked))
1802 : 0 : unix_state_unlock(sk);
1803 : :
1804 [ + + ]: 8798 : if (sock_flag(other, SOCK_RCVTSTAMP))
1805 : 1092 : __net_timestamp(skb);
1806 : 8798 : maybe_add_creds(skb, sock, other);
1807 : 8798 : spin_lock(&other->sk_receive_queue.lock);
1808 [ + + ]: 8798 : scm_stat_add(other, skb);
1809 : 8798 : __skb_queue_tail(&other->sk_receive_queue, skb);
1810 : 8798 : spin_unlock(&other->sk_receive_queue.lock);
1811 : 8798 : unix_state_unlock(other);
1812 : 8798 : other->sk_data_ready(other);
1813 : 8798 : sock_put(other);
1814 : 8798 : scm_destroy(&scm);
1815 : 8798 : return len;
1816 : :
1817 : 0 : out_unlock:
1818 [ # # ]: 0 : if (sk_locked)
1819 : 0 : unix_state_unlock(sk);
1820 : 0 : unix_state_unlock(other);
1821 : 0 : out_free:
1822 : 0 : kfree_skb(skb);
1823 : 0 : out:
1824 [ # # ]: 0 : if (other)
1825 : 0 : sock_put(other);
1826 : 0 : scm_destroy(&scm);
1827 : 0 : return err;
1828 : : }
1829 : :
1830 : : /* We use paged skbs for stream sockets, and limit occupancy to 32768
1831 : : * bytes, and a minimum of a full page.
1832 : : */
1833 : : #define UNIX_SKB_FRAGS_SZ (PAGE_SIZE << get_order(32768))
1834 : :
1835 : 947 : static int unix_stream_sendmsg(struct socket *sock, struct msghdr *msg,
1836 : : size_t len)
1837 : : {
1838 : 947 : struct sock *sk = sock->sk;
1839 : 947 : struct sock *other = NULL;
1840 : 947 : int err, size;
1841 : 947 : struct sk_buff *skb;
1842 : 947 : int sent = 0;
1843 : 947 : struct scm_cookie scm;
1844 : 947 : bool fds_sent = false;
1845 : 947 : int data_len;
1846 : :
1847 : 947 : wait_for_unix_gc();
1848 : 947 : err = scm_send(sock, msg, &scm, false);
1849 [ + - ]: 947 : if (err < 0)
1850 : : return err;
1851 : :
1852 : 947 : err = -EOPNOTSUPP;
1853 [ - + ]: 947 : if (msg->msg_flags&MSG_OOB)
1854 : 0 : goto out_err;
1855 : :
1856 [ - + ]: 947 : if (msg->msg_namelen) {
1857 [ # # ]: 0 : err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;
1858 : 0 : goto out_err;
1859 : : } else {
1860 : 947 : err = -ENOTCONN;
1861 [ - + ]: 947 : other = unix_peer(sk);
1862 [ - + ]: 947 : if (!other)
1863 : 0 : goto out_err;
1864 : : }
1865 : :
1866 [ + + ]: 947 : if (sk->sk_shutdown & SEND_SHUTDOWN)
1867 : 19 : goto pipe_err;
1868 : :
1869 [ + + ]: 1856 : while (sent < len) {
1870 : 928 : size = len - sent;
1871 : :
1872 : : /* Keep two messages in the pipe so it schedules better */
1873 : 928 : size = min_t(int, size, (sk->sk_sndbuf >> 1) - 64);
1874 : :
1875 : : /* allow fallback to order-0 allocations */
1876 : 928 : size = min_t(int, size, SKB_MAX_HEAD(0) + UNIX_SKB_FRAGS_SZ);
1877 : :
1878 : 928 : data_len = max_t(int, 0, size - SKB_MAX_HEAD(0));
1879 : :
1880 : 928 : data_len = min_t(size_t, size, PAGE_ALIGN(data_len));
1881 : :
1882 : 928 : skb = sock_alloc_send_pskb(sk, size - data_len, data_len,
1883 : 928 : msg->msg_flags & MSG_DONTWAIT, &err,
1884 : : get_order(UNIX_SKB_FRAGS_SZ));
1885 [ - + ]: 928 : if (!skb)
1886 : 0 : goto out_err;
1887 : :
1888 : : /* Only send the fds in the first buffer */
1889 : 928 : err = unix_scm_to_skb(&scm, skb, !fds_sent);
1890 [ - + ]: 928 : if (err < 0) {
1891 : 0 : kfree_skb(skb);
1892 : 0 : goto out_err;
1893 : : }
1894 : 928 : fds_sent = true;
1895 : :
1896 : 928 : skb_put(skb, size - data_len);
1897 : 928 : skb->data_len = data_len;
1898 : 928 : skb->len = size;
1899 : 928 : err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, size);
1900 [ - + ]: 928 : if (err) {
1901 : 0 : kfree_skb(skb);
1902 : 0 : goto out_err;
1903 : : }
1904 : :
1905 : 928 : unix_state_lock(other);
1906 : :
1907 [ + - ]: 928 : if (sock_flag(other, SOCK_DEAD) ||
1908 [ - + ]: 928 : (other->sk_shutdown & RCV_SHUTDOWN))
1909 : 0 : goto pipe_err_free;
1910 : :
1911 : 928 : maybe_add_creds(skb, sock, other);
1912 : 928 : spin_lock(&other->sk_receive_queue.lock);
1913 [ - + ]: 928 : scm_stat_add(other, skb);
1914 : 928 : __skb_queue_tail(&other->sk_receive_queue, skb);
1915 : 928 : spin_unlock(&other->sk_receive_queue.lock);
1916 : 928 : unix_state_unlock(other);
1917 : 928 : other->sk_data_ready(other);
1918 : 928 : sent += size;
1919 : : }
1920 : :
1921 : 928 : scm_destroy(&scm);
1922 : :
1923 : 928 : return sent;
1924 : :
1925 : : pipe_err_free:
1926 : 0 : unix_state_unlock(other);
1927 : 0 : kfree_skb(skb);
1928 : : pipe_err:
1929 [ - - - + ]: 19 : if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
1930 : 0 : send_sig(SIGPIPE, current, 0);
1931 : 19 : err = -EPIPE;
1932 : 19 : out_err:
1933 : 19 : scm_destroy(&scm);
1934 [ + - ]: 19 : return sent ? : err;
1935 : : }
1936 : :
1937 : 0 : static ssize_t unix_stream_sendpage(struct socket *socket, struct page *page,
1938 : : int offset, size_t size, int flags)
1939 : : {
1940 : 0 : int err;
1941 : 0 : bool send_sigpipe = false;
1942 : 0 : bool init_scm = true;
1943 : 0 : struct scm_cookie scm;
1944 : 0 : struct sock *other, *sk = socket->sk;
1945 : 0 : struct sk_buff *skb, *newskb = NULL, *tail = NULL;
1946 : :
1947 [ # # ]: 0 : if (flags & MSG_OOB)
1948 : : return -EOPNOTSUPP;
1949 : :
1950 [ # # ]: 0 : other = unix_peer(sk);
1951 [ # # # # ]: 0 : if (!other || sk->sk_state != TCP_ESTABLISHED)
1952 : : return -ENOTCONN;
1953 : :
1954 : : if (false) {
1955 : 0 : alloc_skb:
1956 : 0 : unix_state_unlock(other);
1957 : 0 : mutex_unlock(&unix_sk(other)->iolock);
1958 : 0 : newskb = sock_alloc_send_pskb(sk, 0, 0, flags & MSG_DONTWAIT,
1959 : : &err, 0);
1960 [ # # ]: 0 : if (!newskb)
1961 : 0 : goto err;
1962 : : }
1963 : :
1964 : : /* we must acquire iolock as we modify already present
1965 : : * skbs in the sk_receive_queue and mess with skb->len
1966 : : */
1967 : 0 : err = mutex_lock_interruptible(&unix_sk(other)->iolock);
1968 [ # # ]: 0 : if (err) {
1969 [ # # ]: 0 : err = flags & MSG_DONTWAIT ? -EAGAIN : -ERESTARTSYS;
1970 : 0 : goto err;
1971 : : }
1972 : :
1973 [ # # ]: 0 : if (sk->sk_shutdown & SEND_SHUTDOWN) {
1974 : 0 : err = -EPIPE;
1975 : 0 : send_sigpipe = true;
1976 : 0 : goto err_unlock;
1977 : : }
1978 : :
1979 : 0 : unix_state_lock(other);
1980 : :
1981 [ # # ]: 0 : if (sock_flag(other, SOCK_DEAD) ||
1982 [ # # ]: 0 : other->sk_shutdown & RCV_SHUTDOWN) {
1983 : 0 : err = -EPIPE;
1984 : 0 : send_sigpipe = true;
1985 : 0 : goto err_state_unlock;
1986 : : }
1987 : :
1988 [ # # ]: 0 : if (init_scm) {
1989 : 0 : err = maybe_init_creds(&scm, socket, other);
1990 [ # # ]: 0 : if (err)
1991 : 0 : goto err_state_unlock;
1992 : : init_scm = false;
1993 : : }
1994 : :
1995 [ # # ]: 0 : skb = skb_peek_tail(&other->sk_receive_queue);
1996 [ # # ]: 0 : if (tail && tail == skb) {
1997 : : skb = newskb;
1998 [ # # # # ]: 0 : } else if (!skb || !unix_skb_scm_eq(skb, &scm)) {
1999 [ # # ]: 0 : if (newskb) {
2000 : : skb = newskb;
2001 : : } else {
2002 : 0 : tail = skb;
2003 : 0 : goto alloc_skb;
2004 : : }
2005 [ # # ]: 0 : } else if (newskb) {
2006 : : /* this is fast path, we don't necessarily need to
2007 : : * call to kfree_skb even though with newskb == NULL
2008 : : * this - does no harm
2009 : : */
2010 : 0 : consume_skb(newskb);
2011 : 0 : newskb = NULL;
2012 : : }
2013 : :
2014 [ # # ]: 0 : if (skb_append_pagefrags(skb, page, offset, size)) {
2015 : 0 : tail = skb;
2016 : 0 : goto alloc_skb;
2017 : : }
2018 : :
2019 : 0 : skb->len += size;
2020 : 0 : skb->data_len += size;
2021 : 0 : skb->truesize += size;
2022 : 0 : refcount_add(size, &sk->sk_wmem_alloc);
2023 : :
2024 [ # # ]: 0 : if (newskb) {
2025 : 0 : err = unix_scm_to_skb(&scm, skb, false);
2026 [ # # ]: 0 : if (err)
2027 : 0 : goto err_state_unlock;
2028 : 0 : spin_lock(&other->sk_receive_queue.lock);
2029 : 0 : __skb_queue_tail(&other->sk_receive_queue, newskb);
2030 : 0 : spin_unlock(&other->sk_receive_queue.lock);
2031 : : }
2032 : :
2033 : 0 : unix_state_unlock(other);
2034 : 0 : mutex_unlock(&unix_sk(other)->iolock);
2035 : :
2036 : 0 : other->sk_data_ready(other);
2037 : 0 : scm_destroy(&scm);
2038 : 0 : return size;
2039 : :
2040 : 0 : err_state_unlock:
2041 : 0 : unix_state_unlock(other);
2042 : 0 : err_unlock:
2043 : 0 : mutex_unlock(&unix_sk(other)->iolock);
2044 : 0 : err:
2045 : 0 : kfree_skb(newskb);
2046 [ # # # # ]: 0 : if (send_sigpipe && !(flags & MSG_NOSIGNAL))
2047 : 0 : send_sig(SIGPIPE, current, 0);
2048 [ # # ]: 0 : if (!init_scm)
2049 : 0 : scm_destroy(&scm);
2050 : 0 : return err;
2051 : : }
2052 : :
2053 : 0 : static int unix_seqpacket_sendmsg(struct socket *sock, struct msghdr *msg,
2054 : : size_t len)
2055 : : {
2056 : 0 : int err;
2057 : 0 : struct sock *sk = sock->sk;
2058 : :
2059 [ # # ]: 0 : err = sock_error(sk);
2060 [ # # ]: 0 : if (err)
2061 : : return err;
2062 : :
2063 [ # # ]: 0 : if (sk->sk_state != TCP_ESTABLISHED)
2064 : : return -ENOTCONN;
2065 : :
2066 [ # # ]: 0 : if (msg->msg_namelen)
2067 : 0 : msg->msg_namelen = 0;
2068 : :
2069 : 0 : return unix_dgram_sendmsg(sock, msg, len);
2070 : : }
2071 : :
2072 : 0 : static int unix_seqpacket_recvmsg(struct socket *sock, struct msghdr *msg,
2073 : : size_t size, int flags)
2074 : : {
2075 : 0 : struct sock *sk = sock->sk;
2076 : :
2077 [ # # ]: 0 : if (sk->sk_state != TCP_ESTABLISHED)
2078 : : return -ENOTCONN;
2079 : :
2080 : 0 : return unix_dgram_recvmsg(sock, msg, size, flags);
2081 : : }
2082 : :
2083 : 9657 : static void unix_copy_addr(struct msghdr *msg, struct sock *sk)
2084 : : {
2085 : 19314 : struct unix_address *addr = smp_load_acquire(&unix_sk(sk)->addr);
2086 : :
2087 [ + + + + ]: 9657 : if (addr) {
2088 : 1694 : msg->msg_namelen = addr->len;
2089 : 1694 : memcpy(msg->msg_name, addr->name, addr->len);
2090 : : }
2091 : : }
2092 : :
2093 : 10931 : static int unix_dgram_recvmsg(struct socket *sock, struct msghdr *msg,
2094 : : size_t size, int flags)
2095 : : {
2096 : 10931 : struct scm_cookie scm;
2097 : 10931 : struct sock *sk = sock->sk;
2098 [ - + ]: 10931 : struct unix_sock *u = unix_sk(sk);
2099 : 10931 : struct sk_buff *skb, *last;
2100 : 10931 : long timeo;
2101 : 10931 : int skip;
2102 : 10931 : int err;
2103 : :
2104 : 10931 : err = -EOPNOTSUPP;
2105 [ - + ]: 10931 : if (flags&MSG_OOB)
2106 : 0 : goto out;
2107 : :
2108 [ + + ]: 11052 : timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
2109 : :
2110 : 10931 : do {
2111 : 10931 : mutex_lock(&u->iolock);
2112 : :
2113 [ - + ]: 10931 : skip = sk_peek_offset(sk, flags);
2114 : 10931 : skb = __skb_try_recv_datagram(sk, &sk->sk_receive_queue, flags,
2115 : : scm_stat_del, &skip, &err, &last);
2116 [ + + ]: 10931 : if (skb)
2117 : : break;
2118 : :
2119 : 2133 : mutex_unlock(&u->iolock);
2120 : :
2121 [ + - ]: 2133 : if (err != -EAGAIN)
2122 : : break;
2123 [ # # ]: 0 : } while (timeo &&
2124 : 11 : !__skb_wait_for_more_packets(sk, &sk->sk_receive_queue,
2125 [ + + ]: 2133 : &err, &timeo, last));
2126 : :
2127 [ + + ]: 10920 : if (!skb) { /* implies iolock unlocked */
2128 : 2122 : unix_state_lock(sk);
2129 : : /* Signal EOF on disconnected non-blocking SEQPACKET socket. */
2130 [ - + - - ]: 2122 : if (sk->sk_type == SOCK_SEQPACKET && err == -EAGAIN &&
2131 [ # # ]: 0 : (sk->sk_shutdown & RCV_SHUTDOWN))
2132 : 0 : err = 0;
2133 : 2122 : unix_state_unlock(sk);
2134 : 2122 : goto out;
2135 : : }
2136 : :
2137 [ - + ]: 8798 : if (wq_has_sleeper(&u->peer_wait))
2138 : 0 : wake_up_interruptible_sync_poll(&u->peer_wait,
2139 : : EPOLLOUT | EPOLLWRNORM |
2140 : : EPOLLWRBAND);
2141 : :
2142 [ + + ]: 8798 : if (msg->msg_name)
2143 : 8567 : unix_copy_addr(msg, skb->sk);
2144 : :
2145 [ + + ]: 8798 : if (size > skb->len - skip)
2146 : : size = skb->len - skip;
2147 [ - + ]: 5984 : else if (size < skb->len - skip)
2148 : 0 : msg->msg_flags |= MSG_TRUNC;
2149 : :
2150 : 8798 : err = skb_copy_datagram_msg(skb, skip, msg, size);
2151 [ - + ]: 8798 : if (err)
2152 : 0 : goto out_free;
2153 : :
2154 [ + + ]: 8798 : if (sock_flag(sk, SOCK_RCVTSTAMP))
2155 : 1978 : __sock_recv_timestamp(msg, sk, skb);
2156 : :
2157 : 8798 : memset(&scm, 0, sizeof(scm));
2158 : :
2159 : 8798 : scm_set_cred(&scm, UNIXCB(skb).pid, UNIXCB(skb).uid, UNIXCB(skb).gid);
2160 : 8798 : unix_set_secdata(&scm, skb);
2161 : :
2162 [ + - ]: 8798 : if (!(flags & MSG_PEEK)) {
2163 [ + + ]: 8798 : if (UNIXCB(skb).fp)
2164 : 286 : unix_detach_fds(&scm, skb);
2165 : :
2166 [ - + ]: 8798 : sk_peek_offset_bwd(sk, skb->len);
2167 : : } else {
2168 : : /* It is questionable: on PEEK we could:
2169 : : - do not return fds - good, but too simple 8)
2170 : : - return fds, and do not return them on read (old strategy,
2171 : : apparently wrong)
2172 : : - clone fds (I chose it for now, it is the most universal
2173 : : solution)
2174 : :
2175 : : POSIX 1003.1g does not actually define this clearly
2176 : : at all. POSIX 1003.1g doesn't define a lot of things
2177 : : clearly however!
2178 : :
2179 : : */
2180 : :
2181 [ # # ]: 0 : sk_peek_offset_fwd(sk, size);
2182 : :
2183 [ # # ]: 0 : if (UNIXCB(skb).fp)
2184 : 0 : scm.fp = scm_fp_dup(UNIXCB(skb).fp);
2185 : : }
2186 [ + + ]: 8798 : err = (flags & MSG_TRUNC) ? skb->len - skip : size;
2187 : :
2188 : 8798 : scm_recv(sock, msg, &scm, flags);
2189 : :
2190 : 8798 : out_free:
2191 : 8798 : skb_free_datagram(sk, skb);
2192 : 8798 : mutex_unlock(&u->iolock);
2193 : 10920 : out:
2194 : 10920 : return err;
2195 : : }
2196 : :
2197 : : /*
2198 : : * Sleep until more data has arrived. But check for races..
2199 : : */
2200 : 0 : static long unix_stream_data_wait(struct sock *sk, long timeo,
2201 : : struct sk_buff *last, unsigned int last_len,
2202 : : bool freezable)
2203 : : {
2204 : 0 : struct sk_buff *tail;
2205 : 0 : DEFINE_WAIT(wait);
2206 : :
2207 : 0 : unix_state_lock(sk);
2208 : :
2209 : 0 : for (;;) {
2210 : 0 : prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
2211 : :
2212 [ # # ]: 0 : tail = skb_peek_tail(&sk->sk_receive_queue);
2213 [ # # # # ]: 0 : if (tail != last ||
2214 [ # # ]: 0 : (tail && tail->len != last_len) ||
2215 [ # # ]: 0 : sk->sk_err ||
2216 [ # # # # ]: 0 : (sk->sk_shutdown & RCV_SHUTDOWN) ||
2217 [ # # ]: 0 : signal_pending(current) ||
2218 : : !timeo)
2219 : : break;
2220 : :
2221 : 0 : sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2222 : 0 : unix_state_unlock(sk);
2223 [ # # ]: 0 : if (freezable)
2224 : 0 : timeo = freezable_schedule_timeout(timeo);
2225 : : else
2226 : 0 : timeo = schedule_timeout(timeo);
2227 : 0 : unix_state_lock(sk);
2228 : :
2229 [ # # ]: 0 : if (sock_flag(sk, SOCK_DEAD))
2230 : : break;
2231 : :
2232 : 0 : sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2233 : : }
2234 : :
2235 : 0 : finish_wait(sk_sleep(sk), &wait);
2236 : 0 : unix_state_unlock(sk);
2237 : 0 : return timeo;
2238 : : }
2239 : :
2240 : 5680 : static unsigned int unix_skb_len(const struct sk_buff *skb)
2241 : : {
2242 : 5680 : return skb->len - UNIXCB(skb).consumed;
2243 : : }
2244 : :
2245 : : struct unix_stream_read_state {
2246 : : int (*recv_actor)(struct sk_buff *, int, int,
2247 : : struct unix_stream_read_state *);
2248 : : struct socket *socket;
2249 : : struct msghdr *msg;
2250 : : struct pipe_inode_info *pipe;
2251 : : size_t size;
2252 : : int flags;
2253 : : unsigned int splice_flags;
2254 : : };
2255 : :
2256 : 2011 : static int unix_stream_read_generic(struct unix_stream_read_state *state,
2257 : : bool freezable)
2258 : : {
2259 : 2011 : struct scm_cookie scm;
2260 : 2011 : struct socket *sock = state->socket;
2261 : 2011 : struct sock *sk = sock->sk;
2262 [ - + ]: 2011 : struct unix_sock *u = unix_sk(sk);
2263 : 2011 : int copied = 0;
2264 : 2011 : int flags = state->flags;
2265 : 2011 : int noblock = flags & MSG_DONTWAIT;
2266 : 2011 : bool check_creds = false;
2267 : 2011 : int target;
2268 : 2011 : int err = 0;
2269 : 2011 : long timeo;
2270 : 2011 : int skip;
2271 : 2011 : size_t size = state->size;
2272 : 2011 : unsigned int last_len;
2273 : :
2274 [ - + ]: 2011 : if (unlikely(sk->sk_state != TCP_ESTABLISHED)) {
2275 : 0 : err = -EINVAL;
2276 : 0 : goto out;
2277 : : }
2278 : :
2279 [ - + ]: 2011 : if (unlikely(flags & MSG_OOB)) {
2280 : 0 : err = -EOPNOTSUPP;
2281 : 0 : goto out;
2282 : : }
2283 : :
2284 [ + - ]: 2011 : target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
2285 [ - + ]: 2011 : timeo = sock_rcvtimeo(sk, noblock);
2286 : :
2287 : 2011 : memset(&scm, 0, sizeof(scm));
2288 : :
2289 : : /* Lock the socket to prevent queue disordering
2290 : : * while sleeps in memcpy_tomsg
2291 : : */
2292 : 2011 : mutex_lock(&u->iolock);
2293 : :
2294 [ - + ]: 2011 : skip = max(sk_peek_offset(sk, flags), 0);
2295 : :
2296 : 2407 : do {
2297 : 2407 : int chunk;
2298 : 2407 : bool drop_skb;
2299 : 2407 : struct sk_buff *skb, *last;
2300 : :
2301 : 396 : redo:
2302 : 2407 : unix_state_lock(sk);
2303 [ - + ]: 2407 : if (sock_flag(sk, SOCK_DEAD)) {
2304 : 0 : err = -ECONNRESET;
2305 : 0 : goto unlock;
2306 : : }
2307 [ + + ]: 2407 : last = skb = skb_peek(&sk->sk_receive_queue);
2308 [ + - ]: 1420 : last_len = last ? last->len : 0;
2309 : : again:
2310 [ + + ]: 2407 : if (skb == NULL) {
2311 [ + + ]: 987 : if (copied >= target)
2312 : 396 : goto unlock;
2313 : :
2314 : : /*
2315 : : * POSIX 1003.1g mandates this order.
2316 : : */
2317 : :
2318 [ - + ]: 591 : err = sock_error(sk);
2319 [ # # ]: 0 : if (err)
2320 : 0 : goto unlock;
2321 [ + + ]: 591 : if (sk->sk_shutdown & RCV_SHUTDOWN)
2322 : 245 : goto unlock;
2323 : :
2324 : 346 : unix_state_unlock(sk);
2325 [ - + ]: 346 : if (!timeo) {
2326 : : err = -EAGAIN;
2327 : : break;
2328 : : }
2329 : :
2330 : 0 : mutex_unlock(&u->iolock);
2331 : :
2332 : 0 : timeo = unix_stream_data_wait(sk, timeo, last,
2333 : : last_len, freezable);
2334 : :
2335 [ # # ]: 0 : if (signal_pending(current)) {
2336 [ # # ]: 0 : err = sock_intr_errno(timeo);
2337 : 0 : scm_destroy(&scm);
2338 : 0 : goto out;
2339 : : }
2340 : :
2341 : 0 : mutex_lock(&u->iolock);
2342 : 0 : goto redo;
2343 : 641 : unlock:
2344 : 641 : unix_state_unlock(sk);
2345 : : break;
2346 : : }
2347 : :
2348 [ - + ]: 1420 : while (skip >= unix_skb_len(skb)) {
2349 : 0 : skip -= unix_skb_len(skb);
2350 : 0 : last = skb;
2351 : 0 : last_len = skb->len;
2352 [ # # ]: 0 : skb = skb_peek_next(skb, &sk->sk_receive_queue);
2353 [ # # ]: 0 : if (!skb)
2354 : 0 : goto again;
2355 : : }
2356 : :
2357 : 1420 : unix_state_unlock(sk);
2358 : :
2359 [ - + ]: 1420 : if (check_creds) {
2360 : : /* Never glue messages from different writers */
2361 [ # # # # ]: 0 : if (!unix_skb_scm_eq(skb, &scm))
2362 : : break;
2363 [ + + ]: 1420 : } else if (test_bit(SOCK_PASSCRED, &sock->flags)) {
2364 : : /* Copy credentials */
2365 : 330 : scm_set_cred(&scm, UNIXCB(skb).pid, UNIXCB(skb).uid, UNIXCB(skb).gid);
2366 : 330 : unix_set_secdata(&scm, skb);
2367 : 330 : check_creds = true;
2368 : : }
2369 : :
2370 : : /* Copy address just once */
2371 [ + - + + ]: 1420 : if (state->msg && state->msg->msg_name) {
2372 : 1090 : DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr,
2373 : : state->msg->msg_name);
2374 : 1090 : unix_copy_addr(state->msg, skb->sk);
2375 : : sunaddr = NULL;
2376 : : }
2377 : :
2378 : 1420 : chunk = min_t(unsigned int, unix_skb_len(skb) - skip, size);
2379 : 1420 : skb_get(skb);
2380 : 1420 : chunk = state->recv_actor(skb, skip, chunk, state);
2381 : 1420 : drop_skb = !unix_skb_len(skb);
2382 : : /* skb is only safe to use if !drop_skb */
2383 : 1420 : consume_skb(skb);
2384 [ - + ]: 1420 : if (chunk < 0) {
2385 [ # # ]: 0 : if (copied == 0)
2386 : 0 : copied = -EFAULT;
2387 : : break;
2388 : : }
2389 : 1420 : copied += chunk;
2390 : 1420 : size -= chunk;
2391 : :
2392 [ + - ]: 1420 : if (drop_skb) {
2393 : : /* the skb was touched by a concurrent reader;
2394 : : * we should not expect anything from this skb
2395 : : * anymore and assume it invalid - we can be
2396 : : * sure it was dropped from the socket queue
2397 : : *
2398 : : * let's report a short read
2399 : : */
2400 : : err = 0;
2401 : : break;
2402 : : }
2403 : :
2404 : : /* Mark read part of skb as used */
2405 [ + - ]: 1420 : if (!(flags & MSG_PEEK)) {
2406 : 1420 : UNIXCB(skb).consumed += chunk;
2407 : :
2408 [ - + ]: 1420 : sk_peek_offset_bwd(sk, chunk);
2409 : :
2410 [ - + ]: 1420 : if (UNIXCB(skb).fp) {
2411 : 0 : spin_lock(&sk->sk_receive_queue.lock);
2412 [ # # ]: 0 : scm_stat_del(sk, skb);
2413 : 0 : spin_unlock(&sk->sk_receive_queue.lock);
2414 : 0 : unix_detach_fds(&scm, skb);
2415 : : }
2416 : :
2417 [ + + ]: 1420 : if (unix_skb_len(skb))
2418 : : break;
2419 : :
2420 : 908 : skb_unlink(skb, &sk->sk_receive_queue);
2421 : 908 : consume_skb(skb);
2422 : :
2423 [ + - ]: 908 : if (scm.fp)
2424 : : break;
2425 : : } else {
2426 : : /* It is questionable, see note in unix_dgram_recvmsg.
2427 : : */
2428 [ # # ]: 0 : if (UNIXCB(skb).fp)
2429 : 0 : scm.fp = scm_fp_dup(UNIXCB(skb).fp);
2430 : :
2431 [ # # ]: 0 : sk_peek_offset_fwd(sk, chunk);
2432 : :
2433 [ # # ]: 0 : if (UNIXCB(skb).fp)
2434 : : break;
2435 : :
2436 : 0 : skip = 0;
2437 : 0 : last = skb;
2438 : 0 : last_len = skb->len;
2439 : 0 : unix_state_lock(sk);
2440 [ # # ]: 0 : skb = skb_peek_next(skb, &sk->sk_receive_queue);
2441 [ # # ]: 0 : if (skb)
2442 : 0 : goto again;
2443 : 0 : unix_state_unlock(sk);
2444 : : break;
2445 : : }
2446 [ + + ]: 908 : } while (size);
2447 : :
2448 : 2011 : mutex_unlock(&u->iolock);
2449 [ + - ]: 2011 : if (state->msg)
2450 : 2011 : scm_recv(sock, state->msg, &scm, flags);
2451 : : else
2452 : 0 : scm_destroy(&scm);
2453 : 2011 : out:
2454 [ + + ]: 2011 : return copied ? : err;
2455 : : }
2456 : :
2457 : 1420 : static int unix_stream_read_actor(struct sk_buff *skb,
2458 : : int skip, int chunk,
2459 : : struct unix_stream_read_state *state)
2460 : : {
2461 : 1420 : int ret;
2462 : :
2463 : 1420 : ret = skb_copy_datagram_msg(skb, UNIXCB(skb).consumed + skip,
2464 : : state->msg, chunk);
2465 [ + - ]: 1420 : return ret ?: chunk;
2466 : : }
2467 : :
2468 : 2011 : static int unix_stream_recvmsg(struct socket *sock, struct msghdr *msg,
2469 : : size_t size, int flags)
2470 : : {
2471 : 2011 : struct unix_stream_read_state state = {
2472 : : .recv_actor = unix_stream_read_actor,
2473 : : .socket = sock,
2474 : : .msg = msg,
2475 : : .size = size,
2476 : : .flags = flags
2477 : : };
2478 : :
2479 : 2011 : return unix_stream_read_generic(&state, true);
2480 : : }
2481 : :
2482 : 0 : static int unix_stream_splice_actor(struct sk_buff *skb,
2483 : : int skip, int chunk,
2484 : : struct unix_stream_read_state *state)
2485 : : {
2486 : 0 : return skb_splice_bits(skb, state->socket->sk,
2487 : 0 : UNIXCB(skb).consumed + skip,
2488 : : state->pipe, chunk, state->splice_flags);
2489 : : }
2490 : :
2491 : 0 : static ssize_t unix_stream_splice_read(struct socket *sock, loff_t *ppos,
2492 : : struct pipe_inode_info *pipe,
2493 : : size_t size, unsigned int flags)
2494 : : {
2495 : 0 : struct unix_stream_read_state state = {
2496 : : .recv_actor = unix_stream_splice_actor,
2497 : : .socket = sock,
2498 : : .pipe = pipe,
2499 : : .size = size,
2500 : : .splice_flags = flags,
2501 : : };
2502 : :
2503 [ # # ]: 0 : if (unlikely(*ppos))
2504 : : return -ESPIPE;
2505 : :
2506 [ # # ]: 0 : if (sock->file->f_flags & O_NONBLOCK ||
2507 [ # # ]: 0 : flags & SPLICE_F_NONBLOCK)
2508 : 0 : state.flags = MSG_DONTWAIT;
2509 : :
2510 : 0 : return unix_stream_read_generic(&state, false);
2511 : : }
2512 : :
2513 : 572 : static int unix_shutdown(struct socket *sock, int mode)
2514 : : {
2515 : 572 : struct sock *sk = sock->sk;
2516 : 572 : struct sock *other;
2517 : :
2518 [ + - ]: 572 : if (mode < SHUT_RD || mode > SHUT_RDWR)
2519 : : return -EINVAL;
2520 : : /* This maps:
2521 : : * SHUT_RD (0) -> RCV_SHUTDOWN (1)
2522 : : * SHUT_WR (1) -> SEND_SHUTDOWN (2)
2523 : : * SHUT_RDWR (2) -> SHUTDOWN_MASK (3)
2524 : : */
2525 : 572 : ++mode;
2526 : :
2527 : 572 : unix_state_lock(sk);
2528 : 572 : sk->sk_shutdown |= mode;
2529 [ + - ]: 572 : other = unix_peer(sk);
2530 [ + - ]: 572 : if (other)
2531 : 572 : sock_hold(other);
2532 : 572 : unix_state_unlock(sk);
2533 : 572 : sk->sk_state_change(sk);
2534 : :
2535 [ + - ]: 572 : if (other &&
2536 [ + - ]: 572 : (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET)) {
2537 : :
2538 : 572 : int peer_mode = 0;
2539 : :
2540 [ + + ]: 572 : if (mode&RCV_SHUTDOWN)
2541 : 286 : peer_mode |= SEND_SHUTDOWN;
2542 [ + + ]: 572 : if (mode&SEND_SHUTDOWN)
2543 : 286 : peer_mode |= RCV_SHUTDOWN;
2544 : 572 : unix_state_lock(other);
2545 : 572 : other->sk_shutdown |= peer_mode;
2546 : 572 : unix_state_unlock(other);
2547 : 572 : other->sk_state_change(other);
2548 [ - + ]: 572 : if (peer_mode == SHUTDOWN_MASK)
2549 : 0 : sk_wake_async(other, SOCK_WAKE_WAITD, POLL_HUP);
2550 [ + + ]: 572 : else if (peer_mode & RCV_SHUTDOWN)
2551 : 286 : sk_wake_async(other, SOCK_WAKE_WAITD, POLL_IN);
2552 : : }
2553 [ + - ]: 572 : if (other)
2554 : 572 : sock_put(other);
2555 : :
2556 : : return 0;
2557 : : }
2558 : :
2559 : 967 : long unix_inq_len(struct sock *sk)
2560 : : {
2561 : 967 : struct sk_buff *skb;
2562 : 967 : long amount = 0;
2563 : :
2564 [ + - ]: 967 : if (sk->sk_state == TCP_LISTEN)
2565 : : return -EINVAL;
2566 : :
2567 : 967 : spin_lock(&sk->sk_receive_queue.lock);
2568 [ - + ]: 967 : if (sk->sk_type == SOCK_STREAM ||
2569 : : sk->sk_type == SOCK_SEQPACKET) {
2570 [ # # ]: 0 : skb_queue_walk(&sk->sk_receive_queue, skb)
2571 : 0 : amount += unix_skb_len(skb);
2572 : : } else {
2573 [ + - ]: 967 : skb = skb_peek(&sk->sk_receive_queue);
2574 [ + - ]: 967 : if (skb)
2575 : 967 : amount = skb->len;
2576 : : }
2577 : 967 : spin_unlock(&sk->sk_receive_queue.lock);
2578 : :
2579 : 967 : return amount;
2580 : : }
2581 : : EXPORT_SYMBOL_GPL(unix_inq_len);
2582 : :
2583 : 0 : long unix_outq_len(struct sock *sk)
2584 : : {
2585 : 0 : return sk_wmem_alloc_get(sk);
2586 : : }
2587 : : EXPORT_SYMBOL_GPL(unix_outq_len);
2588 : :
2589 : 0 : static int unix_open_file(struct sock *sk)
2590 : : {
2591 : 0 : struct path path;
2592 : 0 : struct file *f;
2593 : 0 : int fd;
2594 : :
2595 [ # # ]: 0 : if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
2596 : : return -EPERM;
2597 : :
2598 [ # # ]: 0 : if (!smp_load_acquire(&unix_sk(sk)->addr))
2599 : : return -ENOENT;
2600 : :
2601 [ # # ]: 0 : path = unix_sk(sk)->path;
2602 [ # # ]: 0 : if (!path.dentry)
2603 : : return -ENOENT;
2604 : :
2605 : 0 : path_get(&path);
2606 : :
2607 : 0 : fd = get_unused_fd_flags(O_CLOEXEC);
2608 [ # # ]: 0 : if (fd < 0)
2609 : 0 : goto out;
2610 : :
2611 : 0 : f = dentry_open(&path, O_PATH, current_cred());
2612 [ # # ]: 0 : if (IS_ERR(f)) {
2613 : 0 : put_unused_fd(fd);
2614 : 0 : fd = PTR_ERR(f);
2615 : 0 : goto out;
2616 : : }
2617 : :
2618 : 0 : fd_install(fd, f);
2619 : 0 : out:
2620 : 0 : path_put(&path);
2621 : :
2622 : 0 : return fd;
2623 : : }
2624 : :
2625 : 1352 : static int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2626 : : {
2627 : 1352 : struct sock *sk = sock->sk;
2628 : 1352 : long amount = 0;
2629 : 1352 : int err;
2630 : :
2631 [ - + - + ]: 1352 : switch (cmd) {
2632 : : case SIOCOUTQ:
2633 : 0 : amount = unix_outq_len(sk);
2634 : 0 : err = put_user(amount, (int __user *)arg);
2635 : 0 : break;
2636 : 967 : case SIOCINQ:
2637 : 967 : amount = unix_inq_len(sk);
2638 [ - + ]: 967 : if (amount < 0)
2639 : 0 : err = amount;
2640 : : else
2641 : 967 : err = put_user(amount, (int __user *)arg);
2642 : : break;
2643 : 0 : case SIOCUNIXFILE:
2644 : 0 : err = unix_open_file(sk);
2645 : 0 : break;
2646 : : default:
2647 : : err = -ENOIOCTLCMD;
2648 : : break;
2649 : : }
2650 : 1352 : return err;
2651 : : }
2652 : :
2653 : : #ifdef CONFIG_COMPAT
2654 : 0 : static int unix_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2655 : : {
2656 : 0 : return unix_ioctl(sock, cmd, (unsigned long)compat_ptr(arg));
2657 : : }
2658 : : #endif
2659 : :
2660 : 5633 : static __poll_t unix_poll(struct file *file, struct socket *sock, poll_table *wait)
2661 : : {
2662 : 5633 : struct sock *sk = sock->sk;
2663 : 5633 : __poll_t mask;
2664 : :
2665 : 5633 : sock_poll_wait(file, sock, wait);
2666 : 5633 : mask = 0;
2667 : :
2668 : : /* exceptional events? */
2669 [ + + ]: 5633 : if (sk->sk_err)
2670 : 14 : mask |= EPOLLERR;
2671 [ + + ]: 5633 : if (sk->sk_shutdown == SHUTDOWN_MASK)
2672 : 2241 : mask |= EPOLLHUP;
2673 [ + + ]: 5633 : if (sk->sk_shutdown & RCV_SHUTDOWN)
2674 : 2241 : mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
2675 : :
2676 : : /* readable? */
2677 [ + + ]: 5633 : if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
2678 : 2679 : mask |= EPOLLIN | EPOLLRDNORM;
2679 : :
2680 : : /* Connection-based need to check for termination and startup */
2681 [ + - ]: 5633 : if ((sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) &&
2682 [ - + ]: 5633 : sk->sk_state == TCP_CLOSE)
2683 : 0 : mask |= EPOLLHUP;
2684 : :
2685 : : /*
2686 : : * we set writable also when the other side has shut down the
2687 : : * connection. This prevents stuck sockets.
2688 : : */
2689 [ + + ]: 5633 : if (unix_writable(sk))
2690 : 4263 : mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
2691 : :
2692 : 5633 : return mask;
2693 : : }
2694 : :
2695 : 11468 : static __poll_t unix_dgram_poll(struct file *file, struct socket *sock,
2696 : : poll_table *wait)
2697 : : {
2698 : 11468 : struct sock *sk = sock->sk, *other;
2699 : 11468 : unsigned int writable;
2700 : 11468 : __poll_t mask;
2701 : :
2702 : 11468 : sock_poll_wait(file, sock, wait);
2703 : 11468 : mask = 0;
2704 : :
2705 : : /* exceptional events? */
2706 [ + - - + ]: 11468 : if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
2707 [ # # ]: 0 : mask |= EPOLLERR |
2708 : : (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
2709 : :
2710 [ - + ]: 11468 : if (sk->sk_shutdown & RCV_SHUTDOWN)
2711 : 0 : mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
2712 [ - + ]: 11468 : if (sk->sk_shutdown == SHUTDOWN_MASK)
2713 : 0 : mask |= EPOLLHUP;
2714 : :
2715 : : /* readable? */
2716 [ + + ]: 11468 : if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
2717 : 7519 : mask |= EPOLLIN | EPOLLRDNORM;
2718 : :
2719 : : /* Connection-based need to check for termination and startup */
2720 [ + + ]: 11468 : if (sk->sk_type == SOCK_SEQPACKET) {
2721 [ - + ]: 22 : if (sk->sk_state == TCP_CLOSE)
2722 : 0 : mask |= EPOLLHUP;
2723 : : /* connection hasn't started yet? */
2724 [ + - ]: 22 : if (sk->sk_state == TCP_SYN_SENT)
2725 : : return mask;
2726 : : }
2727 : :
2728 : : /* No write status requested, avoid expensive OUT tests. */
2729 [ + - + + ]: 22936 : if (!(poll_requested_events(wait) & (EPOLLWRBAND|EPOLLWRNORM|EPOLLOUT)))
2730 : : return mask;
2731 : :
2732 [ + - ]: 605 : writable = unix_writable(sk);
2733 [ + - ]: 605 : if (writable) {
2734 : 605 : unix_state_lock(sk);
2735 : :
2736 [ + - ]: 605 : other = unix_peer(sk);
2737 [ + - + - : 605 : if (other && unix_peer(other) != sk &&
- + ]
2738 [ # # ]: 0 : unix_recvq_full(other) &&
2739 : 0 : unix_dgram_peer_wake_me(sk, other))
2740 : 0 : writable = 0;
2741 : :
2742 : 605 : unix_state_unlock(sk);
2743 : : }
2744 : :
2745 [ + - ]: 605 : if (writable)
2746 : 605 : mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
2747 : : else
2748 : 0 : sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
2749 : :
2750 : : return mask;
2751 : : }
2752 : :
2753 : : #ifdef CONFIG_PROC_FS
2754 : :
2755 : : #define BUCKET_SPACE (BITS_PER_LONG - (UNIX_HASH_BITS + 1) - 1)
2756 : :
2757 : : #define get_bucket(x) ((x) >> BUCKET_SPACE)
2758 : : #define get_offset(x) ((x) & ((1L << BUCKET_SPACE) - 1))
2759 : : #define set_bucket_offset(b, o) ((b) << BUCKET_SPACE | (o))
2760 : :
2761 : : static struct sock *unix_from_bucket(struct seq_file *seq, loff_t *pos)
2762 : : {
2763 : : unsigned long offset = get_offset(*pos);
2764 : : unsigned long bucket = get_bucket(*pos);
2765 : : struct sock *sk;
2766 : : unsigned long count = 0;
2767 : :
2768 : : for (sk = sk_head(&unix_socket_table[bucket]); sk; sk = sk_next(sk)) {
2769 : : if (sock_net(sk) != seq_file_net(seq))
2770 : : continue;
2771 : : if (++count == offset)
2772 : : break;
2773 : : }
2774 : :
2775 : : return sk;
2776 : : }
2777 : :
2778 : 0 : static struct sock *unix_next_socket(struct seq_file *seq,
2779 : : struct sock *sk,
2780 : : loff_t *pos)
2781 : : {
2782 : 0 : unsigned long bucket;
2783 : :
2784 [ # # ]: 0 : while (sk > (struct sock *)SEQ_START_TOKEN) {
2785 [ # # ]: 0 : sk = sk_next(sk);
2786 [ # # ]: 0 : if (!sk)
2787 : 0 : goto next_bucket;
2788 [ # # ]: 0 : if (sock_net(sk) == seq_file_net(seq))
2789 : 0 : return sk;
2790 : : }
2791 : :
2792 : 0 : do {
2793 : 0 : sk = unix_from_bucket(seq, pos);
2794 [ # # ]: 0 : if (sk)
2795 : : return sk;
2796 : :
2797 : 0 : next_bucket:
2798 : 0 : bucket = get_bucket(*pos) + 1;
2799 : 0 : *pos = set_bucket_offset(bucket, 1);
2800 [ # # ]: 0 : } while (bucket < ARRAY_SIZE(unix_socket_table));
2801 : :
2802 : : return NULL;
2803 : : }
2804 : :
2805 : 0 : static void *unix_seq_start(struct seq_file *seq, loff_t *pos)
2806 : : __acquires(unix_table_lock)
2807 : : {
2808 : 0 : spin_lock(&unix_table_lock);
2809 : :
2810 [ # # ]: 0 : if (!*pos)
2811 : : return SEQ_START_TOKEN;
2812 : :
2813 [ # # ]: 0 : if (get_bucket(*pos) >= ARRAY_SIZE(unix_socket_table))
2814 : : return NULL;
2815 : :
2816 : 0 : return unix_next_socket(seq, NULL, pos);
2817 : : }
2818 : :
2819 : 0 : static void *unix_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2820 : : {
2821 : 0 : ++*pos;
2822 : 0 : return unix_next_socket(seq, v, pos);
2823 : : }
2824 : :
2825 : 0 : static void unix_seq_stop(struct seq_file *seq, void *v)
2826 : : __releases(unix_table_lock)
2827 : : {
2828 : 0 : spin_unlock(&unix_table_lock);
2829 : 0 : }
2830 : :
2831 : 0 : static int unix_seq_show(struct seq_file *seq, void *v)
2832 : : {
2833 : :
2834 [ # # ]: 0 : if (v == SEQ_START_TOKEN)
2835 : 0 : seq_puts(seq, "Num RefCount Protocol Flags Type St "
2836 : : "Inode Path\n");
2837 : : else {
2838 : 0 : struct sock *s = v;
2839 : 0 : struct unix_sock *u = unix_sk(s);
2840 : 0 : unix_state_lock(s);
2841 : :
2842 : 0 : seq_printf(seq, "%pK: %08X %08X %08X %04X %02X %5lu",
2843 : : s,
2844 : : refcount_read(&s->sk_refcnt),
2845 : : 0,
2846 : 0 : s->sk_state == TCP_LISTEN ? __SO_ACCEPTCON : 0,
2847 [ # # ]: 0 : s->sk_type,
2848 [ # # ]: 0 : s->sk_socket ?
2849 [ # # ]: 0 : (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTED : SS_UNCONNECTED) :
2850 [ # # ]: 0 : (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTING : SS_DISCONNECTING),
2851 : : sock_i_ino(s));
2852 : :
2853 [ # # ]: 0 : if (u->addr) { // under unix_table_lock here
2854 : 0 : int i, len;
2855 : 0 : seq_putc(seq, ' ');
2856 : :
2857 : 0 : i = 0;
2858 : 0 : len = u->addr->len - sizeof(short);
2859 [ # # ]: 0 : if (!UNIX_ABSTRACT(s))
2860 : 0 : len--;
2861 : : else {
2862 : 0 : seq_putc(seq, '@');
2863 : 0 : i++;
2864 : : }
2865 [ # # ]: 0 : for ( ; i < len; i++)
2866 [ # # ]: 0 : seq_putc(seq, u->addr->name->sun_path[i] ?:
2867 : : '@');
2868 : : }
2869 : 0 : unix_state_unlock(s);
2870 : 0 : seq_putc(seq, '\n');
2871 : : }
2872 : :
2873 : 0 : return 0;
2874 : : }
2875 : :
2876 : : static const struct seq_operations unix_seq_ops = {
2877 : : .start = unix_seq_start,
2878 : : .next = unix_seq_next,
2879 : : .stop = unix_seq_stop,
2880 : : .show = unix_seq_show,
2881 : : };
2882 : : #endif
2883 : :
2884 : : static const struct net_proto_family unix_family_ops = {
2885 : : .family = PF_UNIX,
2886 : : .create = unix_create,
2887 : : .owner = THIS_MODULE,
2888 : : };
2889 : :
2890 : :
2891 : 11 : static int __net_init unix_net_init(struct net *net)
2892 : : {
2893 : 11 : int error = -ENOMEM;
2894 : :
2895 : 11 : net->unx.sysctl_max_dgram_qlen = 10;
2896 [ - + ]: 11 : if (unix_sysctl_register(net))
2897 : 0 : goto out;
2898 : :
2899 : : #ifdef CONFIG_PROC_FS
2900 [ - + ]: 11 : if (!proc_create_net("unix", 0, net->proc_net, &unix_seq_ops,
2901 : : sizeof(struct seq_net_private))) {
2902 : 0 : unix_sysctl_unregister(net);
2903 : 0 : goto out;
2904 : : }
2905 : : #endif
2906 : : error = 0;
2907 : 11 : out:
2908 : 11 : return error;
2909 : : }
2910 : :
2911 : 0 : static void __net_exit unix_net_exit(struct net *net)
2912 : : {
2913 : 0 : unix_sysctl_unregister(net);
2914 : 0 : remove_proc_entry("unix", net->proc_net);
2915 : 0 : }
2916 : :
2917 : : static struct pernet_operations unix_net_ops = {
2918 : : .init = unix_net_init,
2919 : : .exit = unix_net_exit,
2920 : : };
2921 : :
2922 : 11 : static int __init af_unix_init(void)
2923 : : {
2924 : 11 : int rc = -1;
2925 : :
2926 : 11 : BUILD_BUG_ON(sizeof(struct unix_skb_parms) > sizeof_field(struct sk_buff, cb));
2927 : :
2928 : 11 : rc = proto_register(&unix_proto, 1);
2929 [ - + ]: 11 : if (rc != 0) {
2930 : 0 : pr_crit("%s: Cannot create unix_sock SLAB cache!\n", __func__);
2931 : 0 : goto out;
2932 : : }
2933 : :
2934 : 11 : sock_register(&unix_family_ops);
2935 : 11 : register_pernet_subsys(&unix_net_ops);
2936 : 11 : out:
2937 : 11 : return rc;
2938 : : }
2939 : :
2940 : 0 : static void __exit af_unix_exit(void)
2941 : : {
2942 : 0 : sock_unregister(PF_UNIX);
2943 : 0 : proto_unregister(&unix_proto);
2944 : 0 : unregister_pernet_subsys(&unix_net_ops);
2945 : 0 : }
2946 : :
2947 : : /* Earlier than device_initcall() so that other drivers invoking
2948 : : request_module() don't end up in a loop when modprobe tries
2949 : : to use a UNIX socket. But later than subsys_initcall() because
2950 : : we depend on stuff initialised there */
2951 : : fs_initcall(af_unix_init);
2952 : : module_exit(af_unix_exit);
2953 : :
2954 : : MODULE_LICENSE("GPL");
2955 : : MODULE_ALIAS_NETPROTO(PF_UNIX);
|
