Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-16 09:02:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

unix_bind(): take BSD and abstract address cases into new helpers

Browse Source 
unix_bind_bsd() and unix_bind_abstract() respectively.

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Al Viro 2021-06-19 03:50:29 +00:00 committed by David S. Miller
parent aee5151705
commit fa42d910a3
1 changed files with 74 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
net/unix/af_unix.c
View File

@ -1014,104 +1014,105 @@ static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
return err;
}
static int unix_bind_bsd(struct sock *sk, struct unix_address *addr)
{
struct unix_sock *u = unix_sk(sk);
struct path path = { };
umode_t mode = S_IFSOCK |
(SOCK_INODE(sk->sk_socket)->i_mode & ~current_umask());
unsigned int hash;
int err;
err = unix_mknod(addr->name->sun_path, mode, &path);
if (err)
return err;
err = mutex_lock_interruptible(&u->bindlock);
if (err) {
path_put(&path);
return err;
}
if (u->addr) {
mutex_unlock(&u->bindlock);
path_put(&path);
return -EINVAL;
}
addr->hash = UNIX_HASH_SIZE;
hash = d_backing_inode(path.dentry)->i_ino & (UNIX_HASH_SIZE - 1);
spin_lock(&unix_table_lock);
u->path = path;
__unix_set_addr(sk, addr, hash);
spin_unlock(&unix_table_lock);
mutex_unlock(&u->bindlock);
return 0;
}
static int unix_bind_abstract(struct sock *sk, unsigned hash,
struct unix_address *addr)
{
struct unix_sock *u = unix_sk(sk);
int err;
err = mutex_lock_interruptible(&u->bindlock);
if (err)
return err;
if (u->addr) {
mutex_unlock(&u->bindlock);
return -EINVAL;
}
spin_lock(&unix_table_lock);
if (__unix_find_socket_byname(sock_net(sk), addr->name, addr->len,
sk->sk_type, hash)) {
spin_unlock(&unix_table_lock);
mutex_unlock(&u->bindlock);
return -EADDRINUSE;
}
__unix_set_addr(sk, addr, addr->hash);
spin_unlock(&unix_table_lock);
mutex_unlock(&u->bindlock);
return 0;
}
static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
{
struct sock *sk = sock->sk;
struct net *net = sock_net(sk);
struct unix_sock *u = unix_sk(sk);
struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
char *sun_path = sunaddr->sun_path;
int err;
unsigned int hash;
struct unix_address *addr;
err = -EINVAL;
if (addr_len < offsetofend(struct sockaddr_un, sun_family) ||
sunaddr->sun_family != AF_UNIX)
goto out;
return -EINVAL;
if (addr_len == sizeof(short)) {
err = unix_autobind(sock);
goto out;
}
if (addr_len == sizeof(short))
return unix_autobind(sock);
err = unix_mkname(sunaddr, addr_len, &hash);
if (err < 0)
goto out;
return err;
addr_len = err;
err = -ENOMEM;
addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
if (!addr)
goto out;
return -ENOMEM;
memcpy(addr->name, sunaddr, addr_len);
addr->len = addr_len;
addr->hash = hash ^ sk->sk_type;
refcount_set(&addr->refcnt, 1);
if (sun_path[0]) {
struct path path = { };
umode_t mode = S_IFSOCK |
(SOCK_INODE(sock)->i_mode & ~current_umask());
err = unix_mknod(sun_path, mode, &path);
if (err) {
if (err == -EEXIST)
err = -EADDRINUSE;
goto out_addr;
}
err = mutex_lock_interruptible(&u->bindlock);
if (err) {
path_put(&path);
goto out_addr;
}
err = -EINVAL;
if (u->addr) {
mutex_unlock(&u->bindlock);
path_put(&path);
goto out_addr;
}
addr->hash = UNIX_HASH_SIZE;
hash = d_backing_inode(path.dentry)->i_ino & (UNIX_HASH_SIZE - 1);
spin_lock(&unix_table_lock);
u->path = path;
__unix_set_addr(sk, addr, hash);
spin_unlock(&unix_table_lock);
mutex_unlock(&u->bindlock);
addr = NULL;
err = 0;
} else {
err = mutex_lock_interruptible(&u->bindlock);
if (err)
goto out_addr;
err = -EINVAL;
if (u->addr) {
mutex_unlock(&u->bindlock);
goto out_addr;
}
spin_lock(&unix_table_lock);
err = -EADDRINUSE;
if (__unix_find_socket_byname(net, sunaddr, addr_len,
sk->sk_type, hash)) {
spin_unlock(&unix_table_lock);
mutex_unlock(&u->bindlock);
goto out_addr;
}
__unix_set_addr(sk, addr, addr->hash);
spin_unlock(&unix_table_lock);
mutex_unlock(&u->bindlock);
addr = NULL;
err = 0;
}
out_addr:
if (addr)
if (sun_path[0])
err = unix_bind_bsd(sk, addr);
else
err = unix_bind_abstract(sk, hash, addr);
if (err)
unix_release_addr(addr);
out:
return err;
return err == -EEXIST ? -EADDRINUSE : err;
}
static void unix_state_double_lock(struct sock *sk1, struct sock *sk2)