Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'net-introduce-struct-sockaddr_unsized'
Kees Cook says:
====================
net: Introduce struct sockaddr_unsized
The historically fixed-size struct sockaddr is part of UAPI and embedded
in many existing structures. The kernel uses struct sockaddr extensively
within the kernel to represent arbitrarily sized sockaddr structures,
which caused problems with the compiler's ability to determine object
sizes correctly. The "temporary" solution was to make sockaddr explicitly
use a flexible array, but this causes problems for embedding struct
sockaddr in structures, where once again the compiler has to guess about
the size of such objects, and causes thousands of warnings under the
coming -Wflex-array-member-not-at-end warning.
Switching to sockaddr_storage internally everywhere wastes a lot of memory,
so we are left with needing two changes:
- introduction of an explicitly arbitrarily sized sockaddr struct
- switch struct sockaddr back to being fixed size
Doing the latter step requires all "arbitrarily sized" uses of struct
sockaddr to be replaced with the new struct from the first step.
So, introduce the new struct and do enough conversions that we can
switch sockaddr back to a fixed-size sa_data.
====================
Link: https://patch.msgid.link/20251104002608.do.383-kees@kernel.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
+320
-290
+1
-1
crypto/af_alg.c
+1
-1
crypto/af_alg.c
···
145
145
}
146
146
EXPORT_SYMBOL_GPL(af_alg_release_parent);
147
147
148
-
static int alg_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
148
+
static int alg_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
149
149
{
150
150
const u32 allowed = CRYPTO_ALG_KERN_DRIVER_ONLY;
151
151
struct sock *sk = sock->sk;
+3
-3
drivers/block/drbd/drbd_receiver.c
+3
-3
drivers/block/drbd/drbd_receiver.c
···
450
450
* a free one dynamically.
451
451
*/
452
452
what = "bind before connect";
453
-
err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len);
453
+
err = sock->ops->bind(sock, (struct sockaddr_unsized *) &src_in6, my_addr_len);
454
454
if (err < 0)
455
455
goto out;
456
456
···
458
458
* stay C_WF_CONNECTION, don't go Disconnecting! */
459
459
disconnect_on_error = 0;
460
460
what = "connect";
461
-
err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0);
461
+
err = sock->ops->connect(sock, (struct sockaddr_unsized *) &peer_in6, peer_addr_len, 0);
462
462
463
463
out:
464
464
if (err < 0) {
···
537
537
drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size);
538
538
539
539
what = "bind before listen";
540
-
err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len);
540
+
err = s_listen->ops->bind(s_listen, (struct sockaddr_unsized *)&my_addr, my_addr_len);
541
541
if (err < 0)
542
542
goto out;
543
543
+3
-3
drivers/infiniband/hw/erdma/erdma_cm.c
+3
-3
drivers/infiniband/hw/erdma/erdma_cm.c
···
993
993
int ret;
994
994
995
995
sock_set_reuseaddr(s->sk);
996
-
ret = s->ops->bind(s, laddr, laddrlen);
996
+
ret = s->ops->bind(s, (struct sockaddr_unsized *)laddr, laddrlen);
997
997
if (ret)
998
998
return ret;
999
-
ret = s->ops->connect(s, raddr, raddrlen, flags);
999
+
ret = s->ops->connect(s, (struct sockaddr_unsized *)raddr, raddrlen, flags);
1000
1000
return ret < 0 ? ret : 0;
1001
1001
}
1002
1002
···
1315
1315
if (ipv4_is_zeronet(laddr->sin_addr.s_addr))
1316
1316
s->sk->sk_bound_dev_if = dev->netdev->ifindex;
1317
1317
1318
-
ret = s->ops->bind(s, (struct sockaddr *)laddr,
1318
+
ret = s->ops->bind(s, (struct sockaddr_unsized *)laddr,
1319
1319
sizeof(struct sockaddr_in));
1320
1320
if (ret)
1321
1321
goto error;
+4
-4
drivers/infiniband/sw/siw/siw_cm.c
+4
-4
drivers/infiniband/sw/siw/siw_cm.c
···
1340
1340
return rv;
1341
1341
}
1342
1342
1343
-
rv = s->ops->bind(s, laddr, size);
1343
+
rv = s->ops->bind(s, (struct sockaddr_unsized *)laddr, size);
1344
1344
if (rv < 0)
1345
1345
return rv;
1346
1346
1347
-
rv = s->ops->connect(s, raddr, size, flags);
1347
+
rv = s->ops->connect(s, (struct sockaddr_unsized *)raddr, size, flags);
1348
1348
1349
1349
return rv < 0 ? rv : 0;
1350
1350
}
···
1789
1789
goto error;
1790
1790
}
1791
1791
}
1792
-
rv = s->ops->bind(s, (struct sockaddr *)laddr,
1792
+
rv = s->ops->bind(s, (struct sockaddr_unsized *)laddr,
1793
1793
sizeof(struct sockaddr_in));
1794
1794
} else {
1795
1795
struct sockaddr_in6 *laddr = &to_sockaddr_in6(id->local_addr);
···
1813
1813
goto error;
1814
1814
}
1815
1815
}
1816
-
rv = s->ops->bind(s, (struct sockaddr *)laddr,
1816
+
rv = s->ops->bind(s, (struct sockaddr_unsized *)laddr,
1817
1817
sizeof(struct sockaddr_in6));
1818
1818
}
1819
1819
if (rv) {
+1
-1
drivers/isdn/mISDN/l1oip_core.c
+1
-1
drivers/isdn/mISDN/l1oip_core.c
···
676
676
hc->sin_remote.sin_port = htons((unsigned short)hc->remoteport);
677
677
678
678
/* bind to incoming port */
679
-
if (socket->ops->bind(socket, (struct sockaddr *)&hc->sin_local,
679
+
if (socket->ops->bind(socket, (struct sockaddr_unsized *)&hc->sin_local,
680
680
sizeof(hc->sin_local))) {
681
681
printk(KERN_ERR "%s: Failed to bind socket to port %d.\n",
682
682
__func__, hc->localport);
+2
-2
drivers/isdn/mISDN/socket.c
+2
-2
drivers/isdn/mISDN/socket.c
···
462
462
}
463
463
464
464
static int
465
-
data_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
465
+
data_sock_bind(struct socket *sock, struct sockaddr_unsized *addr, int addr_len)
466
466
{
467
467
struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
468
468
struct sock *sk = sock->sk;
···
696
696
}
697
697
698
698
static int
699
-
base_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
699
+
base_sock_bind(struct socket *sock, struct sockaddr_unsized *addr, int addr_len)
700
700
{
701
701
struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
702
702
struct sock *sk = sock->sk;
+2
-2
drivers/net/ppp/pppoe.c
+2
-2
drivers/net/ppp/pppoe.c
···
608
608
return 0;
609
609
}
610
610
611
-
static int pppoe_connect(struct socket *sock, struct sockaddr *uservaddr,
612
-
int sockaddr_len, int flags)
611
+
static int pppoe_connect(struct socket *sock, struct sockaddr_unsized *uservaddr,
612
+
int sockaddr_len, int flags)
613
613
{
614
614
struct sock *sk = sock->sk;
615
615
struct sockaddr_pppox *sp = (struct sockaddr_pppox *)uservaddr;
+4
-4
drivers/net/ppp/pptp.c
+4
-4
drivers/net/ppp/pptp.c
···
382
382
return NET_RX_DROP;
383
383
}
384
384
385
-
static int pptp_bind(struct socket *sock, struct sockaddr *uservaddr,
386
-
int sockaddr_len)
385
+
static int pptp_bind(struct socket *sock, struct sockaddr_unsized *uservaddr,
386
+
int sockaddr_len)
387
387
{
388
388
struct sock *sk = sock->sk;
389
389
struct sockaddr_pppox *sp = (struct sockaddr_pppox *) uservaddr;
···
415
415
return error;
416
416
}
417
417
418
-
static int pptp_connect(struct socket *sock, struct sockaddr *uservaddr,
419
-
int sockaddr_len, int flags)
418
+
static int pptp_connect(struct socket *sock, struct sockaddr_unsized *uservaddr,
419
+
int sockaddr_len, int flags)
420
420
{
421
421
struct sock *sk = sock->sk;
422
422
struct sockaddr_pppox *sp = (struct sockaddr_pppox *) uservaddr;
+1
-1
drivers/net/wireless/ath/ath10k/qmi.c
+1
-1
drivers/net/wireless/ath/ath10k/qmi.c
···
986
986
987
987
ath10k_dbg(ar, ATH10K_DBG_QMI, "wifi fw qmi service found\n");
988
988
989
-
ret = kernel_connect(qmi_hdl->sock, (struct sockaddr *)&qmi->sq,
989
+
ret = kernel_connect(qmi_hdl->sock, (struct sockaddr_unsized *)&qmi->sq,
990
990
sizeof(qmi->sq), 0);
991
991
if (ret) {
992
992
ath10k_err(ar, "failed to connect to a remote QMI service port\n");
+1
-1
drivers/net/wireless/ath/ath11k/qmi.c
+1
-1
drivers/net/wireless/ath/ath11k/qmi.c
···
3177
3177
sq->sq_node = service->node;
3178
3178
sq->sq_port = service->port;
3179
3179
3180
-
ret = kernel_connect(qmi_hdl->sock, (struct sockaddr *)sq,
3180
+
ret = kernel_connect(qmi_hdl->sock, (struct sockaddr_unsized *)sq,
3181
3181
sizeof(*sq), 0);
3182
3182
if (ret) {
3183
3183
ath11k_warn(ab, "failed to connect to qmi remote service: %d\n", ret);
+1
-1
drivers/net/wireless/ath/ath12k/qmi.c
+1
-1
drivers/net/wireless/ath/ath12k/qmi.c
···
3740
3740
sq->sq_node = service->node;
3741
3741
sq->sq_port = service->port;
3742
3742
3743
-
ret = kernel_connect(qmi_hdl->sock, (struct sockaddr *)sq,
3743
+
ret = kernel_connect(qmi_hdl->sock, (struct sockaddr_unsized *)sq,
3744
3744
sizeof(*sq), 0);
3745
3745
if (ret) {
3746
3746
ath12k_warn(ab, "qmi failed to connect to remote service %d\n", ret);
+2
-2
drivers/nvme/host/tcp.c
+2
-2
drivers/nvme/host/tcp.c
···
1834
1834
sk_set_memalloc(queue->sock->sk);
1835
1835
1836
1836
if (nctrl->opts->mask & NVMF_OPT_HOST_TRADDR) {
1837
-
ret = kernel_bind(queue->sock, (struct sockaddr *)&ctrl->src_addr,
1837
+
ret = kernel_bind(queue->sock, (struct sockaddr_unsized *)&ctrl->src_addr,
1838
1838
sizeof(ctrl->src_addr));
1839
1839
if (ret) {
1840
1840
dev_err(nctrl->device,
···
1872
1872
dev_dbg(nctrl->device, "connecting queue %d\n",
1873
1873
nvme_tcp_queue_id(queue));
1874
1874
1875
-
ret = kernel_connect(queue->sock, (struct sockaddr *)&ctrl->addr,
1875
+
ret = kernel_connect(queue->sock, (struct sockaddr_unsized *)&ctrl->addr,
1876
1876
sizeof(ctrl->addr), 0);
1877
1877
if (ret) {
1878
1878
dev_err(nctrl->device,
+1
-1
drivers/nvme/target/tcp.c
+1
-1
drivers/nvme/target/tcp.c
···
2055
2055
if (so_priority > 0)
2056
2056
sock_set_priority(port->sock->sk, so_priority);
2057
2057
2058
-
ret = kernel_bind(port->sock, (struct sockaddr *)&port->addr,
2058
+
ret = kernel_bind(port->sock, (struct sockaddr_unsized *)&port->addr,
2059
2059
sizeof(port->addr));
2060
2060
if (ret) {
2061
2061
pr_err("failed to bind port socket %d\n", ret);
+1
-1
drivers/slimbus/qcom-ngd-ctrl.c
+1
-1
drivers/slimbus/qcom-ngd-ctrl.c
+1
-1
drivers/target/iscsi/iscsi_target_login.c
+1
-1
drivers/target/iscsi/iscsi_target_login.c
···
822
822
sock_set_reuseaddr(sock->sk);
823
823
ip_sock_set_freebind(sock->sk);
824
824
825
-
ret = kernel_bind(sock, (struct sockaddr *)&np->np_sockaddr, len);
825
+
ret = kernel_bind(sock, (struct sockaddr_unsized *)&np->np_sockaddr, len);
826
826
if (ret < 0) {
827
827
pr_err("kernel_bind() failed: %d\n", ret);
828
828
goto fail;
+2
-2
drivers/xen/pvcalls-back.c
+2
-2
drivers/xen/pvcalls-back.c
···
409
409
ret = sock_create(AF_INET, SOCK_STREAM, 0, &sock);
410
410
if (ret < 0)
411
411
goto out;
412
-
ret = inet_stream_connect(sock, sa, req->u.connect.len, 0);
412
+
ret = inet_stream_connect(sock, (struct sockaddr_unsized *)sa, req->u.connect.len, 0);
413
413
if (ret < 0) {
414
414
sock_release(sock);
415
415
goto out;
···
650
650
if (ret < 0)
651
651
goto out;
652
652
653
-
ret = inet_bind(map->sock, (struct sockaddr *)&req->u.bind.addr,
653
+
ret = inet_bind(map->sock, (struct sockaddr_unsized *)&req->u.bind.addr,
654
654
req->u.bind.len);
655
655
if (ret < 0)
656
656
goto out;
+3
-3
fs/afs/rxrpc.c
+3
-3
fs/afs/rxrpc.c
···
82
82
if (ret < 0)
83
83
pr_err("Couldn't create RxGK CM key: %d\n", ret);
84
84
85
-
ret = kernel_bind(socket, (struct sockaddr *) &srx, sizeof(srx));
85
+
ret = kernel_bind(socket, (struct sockaddr_unsized *) &srx, sizeof(srx));
86
86
if (ret == -EADDRINUSE) {
87
87
srx.transport.sin6.sin6_port = 0;
88
-
ret = kernel_bind(socket, (struct sockaddr *) &srx, sizeof(srx));
88
+
ret = kernel_bind(socket, (struct sockaddr_unsized *) &srx, sizeof(srx));
89
89
}
90
90
if (ret < 0)
91
91
goto error_2;
92
92
93
93
srx.srx_service = YFS_CM_SERVICE;
94
-
ret = kernel_bind(socket, (struct sockaddr *) &srx, sizeof(srx));
94
+
ret = kernel_bind(socket, (struct sockaddr_unsized *) &srx, sizeof(srx));
95
95
if (ret < 0)
96
96
goto error_2;
97
97
+1
-1
fs/coredump.c
+1
-1
fs/coredump.c
+4
-4
fs/dlm/lowcomms.c
+4
-4
fs/dlm/lowcomms.c
···
1126
1126
static int sctp_bind_addrs(struct socket *sock, __be16 port)
1127
1127
{
1128
1128
struct sockaddr_storage localaddr;
1129
-
struct sockaddr *addr = (struct sockaddr *)&localaddr;
1129
+
struct sockaddr_unsized *addr = (struct sockaddr_unsized *)&localaddr;
1130
1130
int i, addr_len, result = 0;
1131
1131
1132
1132
for (i = 0; i < dlm_local_count; i++) {
···
1599
1599
1600
1600
log_print_ratelimited("connecting to %d", con->nodeid);
1601
1601
make_sockaddr(&addr, dlm_config.ci_tcp_port, &addr_len);
1602
-
result = kernel_connect(sock, (struct sockaddr *)&addr, addr_len, 0);
1602
+
result = kernel_connect(sock, (struct sockaddr_unsized *)&addr, addr_len, 0);
1603
1603
switch (result) {
1604
1604
case -EINPROGRESS:
1605
1605
/* not an error */
···
1813
1813
memcpy(&src_addr, &dlm_local_addr[0], sizeof(src_addr));
1814
1814
make_sockaddr(&src_addr, 0, &addr_len);
1815
1815
1816
-
result = kernel_bind(sock, (struct sockaddr *)&src_addr,
1816
+
result = kernel_bind(sock, (struct sockaddr_unsized *)&src_addr,
1817
1817
addr_len);
1818
1818
if (result < 0) {
1819
1819
/* This *may* not indicate a critical error */
···
1852
1852
1853
1853
/* Bind to our port */
1854
1854
make_sockaddr(&dlm_local_addr[0], dlm_config.ci_tcp_port, &addr_len);
1855
-
return kernel_bind(sock, (struct sockaddr *)&dlm_local_addr[0],
1855
+
return kernel_bind(sock, (struct sockaddr_unsized *)&dlm_local_addr[0],
1856
1856
addr_len);
1857
1857
}
1858
1858
+3
-3
fs/ocfs2/cluster/tcp.c
+3
-3
fs/ocfs2/cluster/tcp.c
···
1615
1615
myaddr.sin_addr.s_addr = mynode->nd_ipv4_address;
1616
1616
myaddr.sin_port = htons(0); /* any port */
1617
1617
1618
-
ret = sock->ops->bind(sock, (struct sockaddr *)&myaddr,
1618
+
ret = sock->ops->bind(sock, (struct sockaddr_unsized *)&myaddr,
1619
1619
sizeof(myaddr));
1620
1620
if (ret) {
1621
1621
mlog(ML_ERROR, "bind failed with %d at address %pI4\n",
···
1638
1638
remoteaddr.sin_port = node->nd_ipv4_port;
1639
1639
1640
1640
ret = sc->sc_sock->ops->connect(sc->sc_sock,
1641
-
(struct sockaddr *)&remoteaddr,
1641
+
(struct sockaddr_unsized *)&remoteaddr,
1642
1642
sizeof(remoteaddr),
1643
1643
O_NONBLOCK);
1644
1644
if (ret == -EINPROGRESS)
···
2002
2002
INIT_WORK(&o2net_listen_work, o2net_accept_many);
2003
2003
2004
2004
sock->sk->sk_reuse = SK_CAN_REUSE;
2005
-
ret = sock->ops->bind(sock, (struct sockaddr *)&sin, sizeof(sin));
2005
+
ret = sock->ops->bind(sock, (struct sockaddr_unsized *)&sin, sizeof(sin));
2006
2006
if (ret < 0) {
2007
2007
printk(KERN_ERR "o2net: Error %d while binding socket at "
2008
2008
"%pI4:%u\n", ret, &addr, ntohs(port));
+2
-2
fs/smb/client/connect.c
+2
-2
fs/smb/client/connect.c
···
3112
3112
struct socket *socket = server->ssocket;
3113
3113
3114
3114
rc = kernel_bind(socket,
3115
-
(struct sockaddr *) &server->srcaddr,
3115
+
(struct sockaddr_unsized *) &server->srcaddr,
3116
3116
sizeof(server->srcaddr));
3117
3117
if (rc < 0) {
3118
3118
struct sockaddr_in *saddr4;
···
3411
3411
socket->sk->sk_sndbuf,
3412
3412
socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3413
3413
3414
-
rc = kernel_connect(socket, saddr, slen,
3414
+
rc = kernel_connect(socket, (struct sockaddr_unsized *)saddr, slen,
3415
3415
server->noblockcnt ? O_NONBLOCK : 0);
3416
3416
/*
3417
3417
* When mounting SMB root file systems, we do not want to block in
+2
-2
fs/smb/server/transport_tcp.c
+2
-2
fs/smb/server/transport_tcp.c
···
519
519
}
520
520
521
521
if (ipv4)
522
-
ret = kernel_bind(ksmbd_socket, (struct sockaddr *)&sin,
522
+
ret = kernel_bind(ksmbd_socket, (struct sockaddr_unsized *)&sin,
523
523
sizeof(sin));
524
524
else
525
-
ret = kernel_bind(ksmbd_socket, (struct sockaddr *)&sin6,
525
+
ret = kernel_bind(ksmbd_socket, (struct sockaddr_unsized *)&sin6,
526
526
sizeof(sin6));
527
527
if (ret) {
528
528
pr_err("Failed to bind socket: %d\n", ret);
+10
-7
include/linux/bpf-cgroup.h
+10
-7
include/linux/bpf-cgroup.h
···
120
120
enum cgroup_bpf_attach_type atype);
121
121
122
122
int __cgroup_bpf_run_filter_sock_addr(struct sock *sk,
123
-
struct sockaddr *uaddr,
123
+
struct sockaddr_unsized *uaddr,
124
124
int *uaddrlen,
125
125
enum cgroup_bpf_attach_type atype,
126
126
void *t_ctx,
···
238
238
({ \
239
239
int __ret = 0; \
240
240
if (cgroup_bpf_enabled(atype)) \
241
-
__ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, uaddrlen, \
242
-
atype, NULL, NULL); \
241
+
__ret = __cgroup_bpf_run_filter_sock_addr(sk, \
242
+
(struct sockaddr_unsized *)uaddr, uaddrlen, \
243
+
atype, NULL, NULL); \
243
244
__ret; \
244
245
})
245
246
···
249
248
int __ret = 0; \
250
249
if (cgroup_bpf_enabled(atype)) { \
251
250
lock_sock(sk); \
252
-
__ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, uaddrlen, \
253
-
atype, t_ctx, NULL); \
251
+
__ret = __cgroup_bpf_run_filter_sock_addr(sk, \
252
+
(struct sockaddr_unsized *)uaddr, uaddrlen, \
253
+
atype, t_ctx, NULL); \
254
254
release_sock(sk); \
255
255
} \
256
256
__ret; \
···
268
266
int __ret = 0; \
269
267
if (cgroup_bpf_enabled(atype)) { \
270
268
lock_sock(sk); \
271
-
__ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, uaddrlen, \
272
-
atype, NULL, &__flags); \
269
+
__ret = __cgroup_bpf_run_filter_sock_addr(sk, \
270
+
(struct sockaddr_unsized *)uaddr, uaddrlen, \
271
+
atype, NULL, &__flags); \
273
272
release_sock(sk); \
274
273
if (__flags & BPF_RET_BIND_NO_CAP_NET_BIND_SERVICE) \
275
274
*bind_flags |= BIND_NO_CAP_NET_BIND_SERVICE; \
+1
-1
include/linux/filter.h
+1
-1
include/linux/filter.h
···
1515
1515
1516
1516
struct bpf_sock_addr_kern {
1517
1517
struct sock *sk;
1518
-
struct sockaddr *uaddr;
1518
+
struct sockaddr_unsized *uaddr;
1519
1519
/* Temporary "register" to make indirect stores to nested structures
1520
1520
* defined above. We need three registers to make such a store, but
1521
1521
* only two (src and dst) are available at convert_ctx_access time
+4
-5
include/linux/net.h
+4
-5
include/linux/net.h
···
148
148
149
149
struct vm_area_struct;
150
150
struct page;
151
-
struct sockaddr;
152
151
struct msghdr;
153
152
struct module;
154
153
struct sk_buff;
···
162
163
struct module *owner;
163
164
int (*release) (struct socket *sock);
164
165
int (*bind) (struct socket *sock,
165
-
struct sockaddr *myaddr,
166
+
struct sockaddr_unsized *myaddr,
166
167
int sockaddr_len);
167
168
int (*connect) (struct socket *sock,
168
-
struct sockaddr *vaddr,
169
+
struct sockaddr_unsized *vaddr,
169
170
int sockaddr_len, int flags);
170
171
int (*socketpair)(struct socket *sock1,
171
172
struct socket *sock2);
···
344
345
int kernel_recvmsg(struct socket *sock, struct msghdr *msg, struct kvec *vec,
345
346
size_t num, size_t len, int flags);
346
347
347
-
int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen);
348
+
int kernel_bind(struct socket *sock, struct sockaddr_unsized *addr, int addrlen);
348
349
int kernel_listen(struct socket *sock, int backlog);
349
350
int kernel_accept(struct socket *sock, struct socket **newsock, int flags);
350
-
int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
351
+
int kernel_connect(struct socket *sock, struct sockaddr_unsized *addr, int addrlen,
351
352
int flags);
352
353
int kernel_getsockname(struct socket *sock, struct sockaddr *addr);
353
354
int kernel_getpeername(struct socket *sock, struct sockaddr *addr);
+19
-4
include/linux/socket.h
+19
-4
include/linux/socket.h
···
32
32
* 1003.1g requires sa_family_t and that sa_data is char.
33
33
*/
34
34
35
+
/* Deprecated for in-kernel use. Use struct sockaddr_unsized instead. */
35
36
struct sockaddr {
36
37
sa_family_t sa_family; /* address family, AF_xxx */
37
-
union {
38
-
char sa_data_min[14]; /* Minimum 14 bytes of protocol address */
39
-
DECLARE_FLEX_ARRAY(char, sa_data);
40
-
};
38
+
char sa_data[14]; /* 14 bytes of protocol address */
39
+
};
40
+
41
+
/**
42
+
* struct sockaddr_unsized - Unspecified size sockaddr for callbacks
43
+
* @sa_family: Address family (AF_UNIX, AF_INET, AF_INET6, etc.)
44
+
* @sa_data: Flexible array for address data
45
+
*
46
+
* This structure is designed for callback interfaces where the
47
+
* total size is known via the sockaddr_len parameter. Unlike struct
48
+
* sockaddr which has a fixed 14-byte sa_data limit or struct
49
+
* sockaddr_storage which has a fixed 128-byte sa_data limit, this
50
+
* structure can accommodate addresses of any size, but must be used
51
+
* carefully.
52
+
*/
53
+
struct sockaddr_unsized {
54
+
__kernel_sa_family_t sa_family; /* address family, AF_xxx */
55
+
char sa_data[]; /* flexible address data */
41
56
};
42
57
43
58
struct linger {
+6
-7
include/net/inet_common.h
+6
-7
include/net/inet_common.h
···
19
19
struct net;
20
20
struct page;
21
21
struct sock;
22
-
struct sockaddr;
23
22
struct socket;
24
23
25
24
int inet_release(struct socket *sock);
26
-
int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
25
+
int inet_stream_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
27
26
int addr_len, int flags);
28
-
int __inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
27
+
int __inet_stream_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
29
28
int addr_len, int flags, int is_sendmsg);
30
-
int inet_dgram_connect(struct socket *sock, struct sockaddr *uaddr,
29
+
int inet_dgram_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
31
30
int addr_len, int flags);
32
31
int inet_accept(struct socket *sock, struct socket *newsock,
33
32
struct proto_accept_arg *arg);
···
41
42
int inet_listen(struct socket *sock, int backlog);
42
43
int __inet_listen_sk(struct sock *sk, int backlog);
43
44
void inet_sock_destruct(struct sock *sk);
44
-
int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len);
45
-
int inet_bind_sk(struct sock *sk, struct sockaddr *uaddr, int addr_len);
45
+
int inet_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len);
46
+
int inet_bind_sk(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len);
46
47
/* Don't allocate port at this moment, defer to connect. */
47
48
#define BIND_FORCE_ADDRESS_NO_PORT (1 << 0)
48
49
/* Grab and release socket lock. */
···
51
52
#define BIND_FROM_BPF (1 << 2)
52
53
/* Skip CAP_NET_BIND_SERVICE check. */
53
54
#define BIND_NO_CAP_NET_BIND_SERVICE (1 << 3)
54
-
int __inet_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len,
55
+
int __inet_bind(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len,
55
56
u32 flags);
56
57
int inet_getname(struct socket *sock, struct sockaddr *uaddr,
57
58
int peer);
+2
-2
include/net/ip.h
+2
-2
include/net/ip.h
···
261
261
}
262
262
263
263
/* datagram.c */
264
-
int __ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
265
-
int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
264
+
int __ip4_datagram_connect(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len);
265
+
int ip4_datagram_connect(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len);
266
266
267
267
void ip4_datagram_release_cb(struct sock *sk);
268
268
+5
-5
include/net/ipv6.h
+5
-5
include/net/ipv6.h
···
1188
1188
int ipv6_getsockopt(struct sock *sk, int level, int optname,
1189
1189
char __user *optval, int __user *optlen);
1190
1190
1191
-
int __ip6_datagram_connect(struct sock *sk, struct sockaddr *addr,
1191
+
int __ip6_datagram_connect(struct sock *sk, struct sockaddr_unsized *addr,
1192
1192
int addr_len);
1193
-
int ip6_datagram_connect(struct sock *sk, struct sockaddr *addr, int addr_len);
1194
-
int ip6_datagram_connect_v6_only(struct sock *sk, struct sockaddr *addr,
1193
+
int ip6_datagram_connect(struct sock *sk, struct sockaddr_unsized *addr, int addr_len);
1194
+
int ip6_datagram_connect_v6_only(struct sock *sk, struct sockaddr_unsized *addr,
1195
1195
int addr_len);
1196
1196
int ip6_datagram_dst_update(struct sock *sk, bool fix_sk_saddr);
1197
1197
void ip6_datagram_release_cb(struct sock *sk);
···
1208
1208
void inet6_cleanup_sock(struct sock *sk);
1209
1209
void inet6_sock_destruct(struct sock *sk);
1210
1210
int inet6_release(struct socket *sock);
1211
-
int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len);
1212
-
int inet6_bind_sk(struct sock *sk, struct sockaddr *uaddr, int addr_len);
1211
+
int inet6_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len);
1212
+
int inet6_bind_sk(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len);
1213
1213
int inet6_getname(struct socket *sock, struct sockaddr *uaddr,
1214
1214
int peer);
1215
1215
int inet6_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
+1
-1
include/net/ipv6_stubs.h
+1
-1
include/net/ipv6_stubs.h
···
80
80
81
81
/* A stub used by bpf helpers. Similarly ugly as ipv6_stub */
82
82
struct ipv6_bpf_stub {
83
-
int (*inet6_bind)(struct sock *sk, struct sockaddr *uaddr, int addr_len,
83
+
int (*inet6_bind)(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len,
84
84
u32 flags);
85
85
struct sock *(*udp6_lib_lookup)(const struct net *net,
86
86
const struct in6_addr *saddr, __be16 sport,
+1
-1
include/net/ping.h
+1
-1
include/net/ping.h
···
58
58
59
59
int ping_init_sock(struct sock *sk);
60
60
void ping_close(struct sock *sk, long timeout);
61
-
int ping_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len);
61
+
int ping_bind(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len);
62
62
void ping_err(struct sk_buff *skb, int offset, u32 info);
63
63
int ping_getfrag(void *from, char *to, int offset, int fraglen, int odd,
64
64
struct sk_buff *);
+1
-1
include/net/sctp/sctp.h
+1
-1
include/net/sctp/sctp.h
···
85
85
/*
86
86
* sctp/socket.c
87
87
*/
88
-
int sctp_inet_connect(struct socket *sock, struct sockaddr *uaddr,
88
+
int sctp_inet_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
89
89
int addr_len, int flags);
90
90
int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb);
91
91
int sctp_inet_listen(struct socket *sock, int backlog);
+7
-7
include/net/sock.h
+7
-7
include/net/sock.h
···
1274
1274
void (*close)(struct sock *sk,
1275
1275
long timeout);
1276
1276
int (*pre_connect)(struct sock *sk,
1277
-
struct sockaddr *uaddr,
1277
+
struct sockaddr_unsized *uaddr,
1278
1278
int addr_len);
1279
1279
int (*connect)(struct sock *sk,
1280
-
struct sockaddr *uaddr,
1280
+
struct sockaddr_unsized *uaddr,
1281
1281
int addr_len);
1282
1282
int (*disconnect)(struct sock *sk, int flags);
1283
1283
···
1306
1306
size_t len, int flags, int *addr_len);
1307
1307
void (*splice_eof)(struct socket *sock);
1308
1308
int (*bind)(struct sock *sk,
1309
-
struct sockaddr *addr, int addr_len);
1309
+
struct sockaddr_unsized *addr, int addr_len);
1310
1310
int (*bind_add)(struct sock *sk,
1311
-
struct sockaddr *addr, int addr_len);
1311
+
struct sockaddr_unsized *addr, int addr_len);
1312
1312
1313
1313
int (*backlog_rcv) (struct sock *sk,
1314
1314
struct sk_buff *skb);
···
1920
1920
* Functions to fill in entries in struct proto_ops when a protocol
1921
1921
* does not implement a particular function.
1922
1922
*/
1923
-
int sock_no_bind(struct socket *, struct sockaddr *, int);
1924
-
int sock_no_connect(struct socket *, struct sockaddr *, int, int);
1923
+
int sock_no_bind(struct socket *sock, struct sockaddr_unsized *saddr, int len);
1924
+
int sock_no_connect(struct socket *sock, struct sockaddr_unsized *saddr, int len, int flags);
1925
1925
int sock_no_socketpair(struct socket *, struct socket *);
1926
1926
int sock_no_accept(struct socket *, struct socket *, struct proto_accept_arg *);
1927
1927
int sock_no_getname(struct socket *, struct sockaddr *, int);
···
3105
3105
void sock_set_reuseport(struct sock *sk);
3106
3106
void sock_set_sndtimeo(struct sock *sk, s64 secs);
3107
3107
3108
-
int sock_bind_add(struct sock *sk, struct sockaddr *addr, int addr_len);
3108
+
int sock_bind_add(struct sock *sk, struct sockaddr_unsized *addr, int addr_len);
3109
3109
3110
3110
int sock_get_timeout(long timeo, void *optval, bool old_timeval);
3111
3111
int sock_copy_user_timeval(struct __kernel_sock_timeval *tv,
+1
-1
include/net/tcp.h
+1
-1
include/net/tcp.h
···
535
535
struct request_sock *req_unhash,
536
536
bool *own_req);
537
537
int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb);
538
-
int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
538
+
int tcp_v4_connect(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len);
539
539
int tcp_connect(struct sock *sk);
540
540
enum tcp_synack_type {
541
541
TCP_SYNACK_NORMAL,
+1
-1
include/net/udp.h
+1
-1
include/net/udp.h
···
424
424
int udp_rcv(struct sk_buff *skb);
425
425
int udp_ioctl(struct sock *sk, int cmd, int *karg);
426
426
int udp_init_sock(struct sock *sk);
427
-
int udp_pre_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
427
+
int udp_pre_connect(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len);
428
428
int __udp_disconnect(struct sock *sk, int flags);
429
429
int udp_disconnect(struct sock *sk, int flags);
430
430
__poll_t udp_poll(struct file *file, struct socket *sock, poll_table *wait);
+1
-1
include/net/vsock_addr.h
+1
-1
include/net/vsock_addr.h
···
16
16
void vsock_addr_unbind(struct sockaddr_vm *addr);
17
17
bool vsock_addr_equals_addr(const struct sockaddr_vm *addr,
18
18
const struct sockaddr_vm *other);
19
-
int vsock_addr_cast(const struct sockaddr *addr, size_t len,
19
+
int vsock_addr_cast(const struct sockaddr_unsized *addr, size_t len,
20
20
struct sockaddr_vm **out_addr);
21
21
22
22
#endif
+4
-4
kernel/bpf/cgroup.c
+4
-4
kernel/bpf/cgroup.c
···
1665
1665
* returned value != 1 during execution. In all other cases, 0 is returned.
1666
1666
*/
1667
1667
int __cgroup_bpf_run_filter_sock_addr(struct sock *sk,
1668
-
struct sockaddr *uaddr,
1668
+
struct sockaddr_unsized *uaddr,
1669
1669
int *uaddrlen,
1670
1670
enum cgroup_bpf_attach_type atype,
1671
1671
void *t_ctx,
···
1676
1676
.uaddr = uaddr,
1677
1677
.t_ctx = t_ctx,
1678
1678
};
1679
-
struct sockaddr_storage unspec;
1679
+
struct sockaddr_storage storage;
1680
1680
struct cgroup *cgrp;
1681
1681
int ret;
1682
1682
···
1688
1688
return 0;
1689
1689
1690
1690
if (!ctx.uaddr) {
1691
-
memset(&unspec, 0, sizeof(unspec));
1692
-
ctx.uaddr = (struct sockaddr *)&unspec;
1691
+
memset(&storage, 0, sizeof(storage));
1692
+
ctx.uaddr = (struct sockaddr_unsized *)&storage;
1693
1693
ctx.uaddrlen = 0;
1694
1694
} else {
1695
1695
ctx.uaddrlen = *uaddrlen;
+4
-4
net/9p/trans_fd.c
+4
-4
net/9p/trans_fd.c
···
966
966
((struct sockaddr_in *)&stor)->sin_port = htons((ushort)port);
967
967
else
968
968
((struct sockaddr_in6 *)&stor)->sin6_port = htons((ushort)port);
969
-
err = kernel_bind(sock, (struct sockaddr *)&stor, sizeof(stor));
969
+
err = kernel_bind(sock, (struct sockaddr_unsized *)&stor, sizeof(stor));
970
970
if (err != -EADDRINUSE)
971
971
break;
972
972
}
···
1018
1018
}
1019
1019
1020
1020
err = READ_ONCE(csocket->ops)->connect(csocket,
1021
-
(struct sockaddr *)&stor,
1021
+
(struct sockaddr_unsized *)&stor,
1022
1022
sizeof(stor), 0);
1023
1023
if (err < 0) {
1024
1024
pr_err("%s (%d): problem connecting socket to %s\n",
···
1058
1058
1059
1059
return err;
1060
1060
}
1061
-
err = READ_ONCE(csocket->ops)->connect(csocket, (struct sockaddr *)&sun_server,
1062
-
sizeof(struct sockaddr_un) - 1, 0);
1061
+
err = READ_ONCE(csocket->ops)->connect(csocket, (struct sockaddr_unsized *)&sun_server,
1062
+
sizeof(struct sockaddr_un) - 1, 0);
1063
1063
if (err < 0) {
1064
1064
pr_err("%s (%d): problem connecting socket: %s: %d\n",
1065
1065
__func__, task_pid_nr(current), addr, err);
+2
-2
net/appletalk/ddp.c
+2
-2
net/appletalk/ddp.c
···
1149
1149
}
1150
1150
1151
1151
/* Set the address 'our end' of the connection */
1152
-
static int atalk_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1152
+
static int atalk_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
1153
1153
{
1154
1154
struct sockaddr_at *addr = (struct sockaddr_at *)uaddr;
1155
1155
struct sock *sk = sock->sk;
···
1204
1204
}
1205
1205
1206
1206
/* Set the address we talk to */
1207
-
static int atalk_connect(struct socket *sock, struct sockaddr *uaddr,
1207
+
static int atalk_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
1208
1208
int addr_len, int flags)
1209
1209
{
1210
1210
struct sock *sk = sock->sk;
+2
-2
net/atm/pvc.c
+2
-2
net/atm/pvc.c
···
24
24
return 0;
25
25
}
26
26
27
-
static int pvc_bind(struct socket *sock, struct sockaddr *sockaddr,
27
+
static int pvc_bind(struct socket *sock, struct sockaddr_unsized *sockaddr,
28
28
int sockaddr_len)
29
29
{
30
30
struct sock *sk = sock->sk;
···
56
56
return error;
57
57
}
58
58
59
-
static int pvc_connect(struct socket *sock, struct sockaddr *sockaddr,
59
+
static int pvc_connect(struct socket *sock, struct sockaddr_unsized *sockaddr,
60
60
int sockaddr_len, int flags)
61
61
{
62
62
return pvc_bind(sock, sockaddr, sockaddr_len);
+2
-2
net/atm/svc.c
+2
-2
net/atm/svc.c
···
97
97
return 0;
98
98
}
99
99
100
-
static int svc_bind(struct socket *sock, struct sockaddr *sockaddr,
100
+
static int svc_bind(struct socket *sock, struct sockaddr_unsized *sockaddr,
101
101
int sockaddr_len)
102
102
{
103
103
DEFINE_WAIT(wait);
···
153
153
return error;
154
154
}
155
155
156
-
static int svc_connect(struct socket *sock, struct sockaddr *sockaddr,
156
+
static int svc_connect(struct socket *sock, struct sockaddr_unsized *sockaddr,
157
157
int sockaddr_len, int flags)
158
158
{
159
159
DEFINE_WAIT(wait);
+2
-2
net/ax25/af_ax25.c
+2
-2
net/ax25/af_ax25.c
···
1094
1094
* that we've implemented support for SO_BINDTODEVICE. It is however small
1095
1095
* and trivially backward compatible.
1096
1096
*/
1097
-
static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1097
+
static int ax25_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
1098
1098
{
1099
1099
struct sock *sk = sock->sk;
1100
1100
struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
···
1175
1175
* FIXME: nonblock behaviour looks like it may have a bug.
1176
1176
*/
1177
1177
static int __must_check ax25_connect(struct socket *sock,
1178
-
struct sockaddr *uaddr, int addr_len, int flags)
1178
+
struct sockaddr_unsized *uaddr, int addr_len, int flags)
1179
1179
{
1180
1180
struct sock *sk = sock->sk;
1181
1181
ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
+1
-1
net/bluetooth/hci_sock.c
+1
-1
net/bluetooth/hci_sock.c
+3
-3
net/bluetooth/iso.c
+3
-3
net/bluetooth/iso.c
···
944
944
return 0;
945
945
}
946
946
947
-
static int iso_sock_bind_bc(struct socket *sock, struct sockaddr *addr,
947
+
static int iso_sock_bind_bc(struct socket *sock, struct sockaddr_unsized *addr,
948
948
int addr_len)
949
949
{
950
950
struct sockaddr_iso *sa = (struct sockaddr_iso *)addr;
···
1022
1022
return err;
1023
1023
}
1024
1024
1025
-
static int iso_sock_bind(struct socket *sock, struct sockaddr *addr,
1025
+
static int iso_sock_bind(struct socket *sock, struct sockaddr_unsized *addr,
1026
1026
int addr_len)
1027
1027
{
1028
1028
struct sockaddr_iso *sa = (struct sockaddr_iso *)addr;
···
1080
1080
return err;
1081
1081
}
1082
1082
1083
-
static int iso_sock_connect(struct socket *sock, struct sockaddr *addr,
1083
+
static int iso_sock_connect(struct socket *sock, struct sockaddr_unsized *addr,
1084
1084
int alen, int flags)
1085
1085
{
1086
1086
struct sockaddr_iso *sa = (struct sockaddr_iso *)addr;
+2
-2
net/bluetooth/l2cap_sock.c
+2
-2
net/bluetooth/l2cap_sock.c
···
80
80
return 0;
81
81
}
82
82
83
-
static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
83
+
static int l2cap_sock_bind(struct socket *sock, struct sockaddr_unsized *addr, int alen)
84
84
{
85
85
struct sock *sk = sock->sk;
86
86
struct l2cap_chan *chan = l2cap_pi(sk)->chan;
···
178
178
return err;
179
179
}
180
180
181
-
static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr,
181
+
static int l2cap_sock_connect(struct socket *sock, struct sockaddr_unsized *addr,
182
182
int alen, int flags)
183
183
{
184
184
struct sock *sk = sock->sk;
+3
-3
net/bluetooth/rfcomm/core.c
+3
-3
net/bluetooth/rfcomm/core.c
···
781
781
addr.l2_psm = 0;
782
782
addr.l2_cid = 0;
783
783
addr.l2_bdaddr_type = BDADDR_BREDR;
784
-
*err = kernel_bind(sock, (struct sockaddr *) &addr, sizeof(addr));
784
+
*err = kernel_bind(sock, (struct sockaddr_unsized *)&addr, sizeof(addr));
785
785
if (*err < 0)
786
786
goto failed;
787
787
···
808
808
addr.l2_psm = cpu_to_le16(L2CAP_PSM_RFCOMM);
809
809
addr.l2_cid = 0;
810
810
addr.l2_bdaddr_type = BDADDR_BREDR;
811
-
*err = kernel_connect(sock, (struct sockaddr *) &addr, sizeof(addr), O_NONBLOCK);
811
+
*err = kernel_connect(sock, (struct sockaddr_unsized *)&addr, sizeof(addr), O_NONBLOCK);
812
812
if (*err == 0 || *err == -EINPROGRESS)
813
813
return s;
814
814
···
2068
2068
addr.l2_psm = cpu_to_le16(L2CAP_PSM_RFCOMM);
2069
2069
addr.l2_cid = 0;
2070
2070
addr.l2_bdaddr_type = BDADDR_BREDR;
2071
-
err = kernel_bind(sock, (struct sockaddr *) &addr, sizeof(addr));
2071
+
err = kernel_bind(sock, (struct sockaddr_unsized *)&addr, sizeof(addr));
2072
2072
if (err < 0) {
2073
2073
BT_ERR("Bind failed %d", err);
2074
2074
goto failed;
+3
-2
net/bluetooth/rfcomm/sock.c
+3
-2
net/bluetooth/rfcomm/sock.c
···
324
324
return 0;
325
325
}
326
326
327
-
static int rfcomm_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
327
+
static int rfcomm_sock_bind(struct socket *sock, struct sockaddr_unsized *addr, int addr_len)
328
328
{
329
329
struct sockaddr_rc sa;
330
330
struct sock *sk = sock->sk;
···
371
371
return err;
372
372
}
373
373
374
-
static int rfcomm_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
374
+
static int rfcomm_sock_connect(struct socket *sock, struct sockaddr_unsized *addr,
375
+
int alen, int flags)
375
376
{
376
377
struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
377
378
struct sock *sk = sock->sk;
+2
-2
net/bluetooth/sco.c
+2
-2
net/bluetooth/sco.c
···
605
605
return 0;
606
606
}
607
607
608
-
static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
608
+
static int sco_sock_bind(struct socket *sock, struct sockaddr_unsized *addr,
609
609
int addr_len)
610
610
{
611
611
struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
···
639
639
return err;
640
640
}
641
641
642
-
static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
642
+
static int sco_sock_connect(struct socket *sock, struct sockaddr_unsized *addr, int alen, int flags)
643
643
{
644
644
struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
645
645
struct sock *sk = sock->sk;
+1
-1
net/caif/caif_socket.c
+1
-1
net/caif/caif_socket.c
···
734
734
* o sock->state: holds the SS_* socket state and is updated by connect and
735
735
* disconnect.
736
736
*/
737
-
static int caif_connect(struct socket *sock, struct sockaddr *uaddr,
737
+
static int caif_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
738
738
int addr_len, int flags)
739
739
{
740
740
struct sock *sk = sock->sk;
+1
-1
net/can/bcm.c
+1
-1
net/can/bcm.c
···
1657
1657
return 0;
1658
1658
}
1659
1659
1660
-
static int bcm_connect(struct socket *sock, struct sockaddr *uaddr, int len,
1660
+
static int bcm_connect(struct socket *sock, struct sockaddr_unsized *uaddr, int len,
1661
1661
int flags)
1662
1662
{
1663
1663
struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
+1
-1
net/can/isotp.c
+1
-1
net/can/isotp.c
···
1246
1246
return 0;
1247
1247
}
1248
1248
1249
-
static int isotp_bind(struct socket *sock, struct sockaddr *uaddr, int len)
1249
+
static int isotp_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int len)
1250
1250
{
1251
1251
struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
1252
1252
struct sock *sk = sock->sk;
+2
-2
net/can/j1939/socket.c
+2
-2
net/can/j1939/socket.c
···
440
440
return 0;
441
441
}
442
442
443
-
static int j1939_sk_bind(struct socket *sock, struct sockaddr *uaddr, int len)
443
+
static int j1939_sk_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int len)
444
444
{
445
445
struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
446
446
struct j1939_sock *jsk = j1939_sk(sock->sk);
···
535
535
return ret;
536
536
}
537
537
538
-
static int j1939_sk_connect(struct socket *sock, struct sockaddr *uaddr,
538
+
static int j1939_sk_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
539
539
int len, int flags)
540
540
{
541
541
struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
+1
-1
net/can/raw.c
+1
-1
net/can/raw.c
···
449
449
return 0;
450
450
}
451
451
452
-
static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
452
+
static int raw_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int len)
453
453
{
454
454
struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
455
455
struct sock *sk = sock->sk;
+1
-1
net/ceph/messenger.c
+1
-1
net/ceph/messenger.c
···
460
460
set_sock_callbacks(sock, con);
461
461
462
462
con_sock_state_connecting(con);
463
-
ret = kernel_connect(sock, (struct sockaddr *)&ss, sizeof(ss),
463
+
ret = kernel_connect(sock, (struct sockaddr_unsized *)&ss, sizeof(ss),
464
464
O_NONBLOCK);
465
465
if (ret == -EINPROGRESS) {
466
466
dout("connect %s EINPROGRESS sk_state = %u\n",
+1
-1
net/core/dev.c
+1
-1
net/core/dev.c
···
9973
9973
/* "sa" is a true struct sockaddr with limited "sa_data" member. */
9974
9974
int netif_get_mac_address(struct sockaddr *sa, struct net *net, char *dev_name)
9975
9975
{
9976
-
size_t size = sizeof(sa->sa_data_min);
9976
+
size_t size = sizeof(sa->sa_data);
9977
9977
struct net_device *dev;
9978
9978
int ret = 0;
9979
9979
+1
-1
net/core/dev_ioctl.c
+1
-1
net/core/dev_ioctl.c
···
596
596
if (ifr->ifr_hwaddr.sa_family != dev->type)
597
597
return -EINVAL;
598
598
memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
599
-
min(sizeof(ifr->ifr_hwaddr.sa_data_min),
599
+
min(sizeof(ifr->ifr_hwaddr.sa_data),
600
600
(size_t)dev->addr_len));
601
601
netdev_lock_ops(dev);
602
602
call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
+3
-2
net/core/filter.c
+3
-2
net/core/filter.c
···
5978
5978
return err;
5979
5979
if (((struct sockaddr_in *)addr)->sin_port == htons(0))
5980
5980
flags |= BIND_FORCE_ADDRESS_NO_PORT;
5981
-
return __inet_bind(sk, addr, addr_len, flags);
5981
+
return __inet_bind(sk, (struct sockaddr_unsized *)addr, addr_len, flags);
5982
5982
#if IS_ENABLED(CONFIG_IPV6)
5983
5983
} else if (addr->sa_family == AF_INET6) {
5984
5984
if (addr_len < SIN6_LEN_RFC2133)
···
5988
5988
/* ipv6_bpf_stub cannot be NULL, since it's called from
5989
5989
* bpf_cgroup_inet6_connect hook and ipv6 is already loaded
5990
5990
*/
5991
-
return ipv6_bpf_stub->inet6_bind(sk, addr, addr_len, flags);
5991
+
return ipv6_bpf_stub->inet6_bind(sk, (struct sockaddr_unsized *)addr,
5992
+
addr_len, flags);
5992
5993
#endif /* CONFIG_IPV6 */
5993
5994
}
5994
5995
#endif /* CONFIG_INET */
+3
-3
net/core/sock.c
+3
-3
net/core/sock.c
···
3462
3462
* function, some default processing is provided.
3463
3463
*/
3464
3464
3465
-
int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
3465
+
int sock_no_bind(struct socket *sock, struct sockaddr_unsized *saddr, int len)
3466
3466
{
3467
3467
return -EOPNOTSUPP;
3468
3468
}
3469
3469
EXPORT_SYMBOL(sock_no_bind);
3470
3470
3471
-
int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
3471
+
int sock_no_connect(struct socket *sock, struct sockaddr_unsized *saddr,
3472
3472
int len, int flags)
3473
3473
{
3474
3474
return -EOPNOTSUPP;
···
4395
4395
EXPORT_SYMBOL(sk_busy_loop_end);
4396
4396
#endif /* CONFIG_NET_RX_BUSY_POLL */
4397
4397
4398
-
int sock_bind_add(struct sock *sk, struct sockaddr *addr, int addr_len)
4398
+
int sock_bind_add(struct sock *sk, struct sockaddr_unsized *addr, int addr_len)
4399
4399
{
4400
4400
if (!sk->sk_prot->bind_add)
4401
4401
return -EOPNOTSUPP;
+6
-6
net/ieee802154/socket.c
+6
-6
net/ieee802154/socket.c
···
96
96
return sk->sk_prot->sendmsg(sk, msg, len);
97
97
}
98
98
99
-
static int ieee802154_sock_bind(struct socket *sock, struct sockaddr *uaddr,
99
+
static int ieee802154_sock_bind(struct socket *sock, struct sockaddr_unsized *uaddr,
100
100
int addr_len)
101
101
{
102
102
struct sock *sk = sock->sk;
···
107
107
return sock_no_bind(sock, uaddr, addr_len);
108
108
}
109
109
110
-
static int ieee802154_sock_connect(struct socket *sock, struct sockaddr *uaddr,
110
+
static int ieee802154_sock_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
111
111
int addr_len, int flags)
112
112
{
113
113
struct sock *sk = sock->sk;
···
193
193
sk_common_release(sk);
194
194
}
195
195
196
-
static int raw_bind(struct sock *sk, struct sockaddr *_uaddr, int len)
196
+
static int raw_bind(struct sock *sk, struct sockaddr_unsized *_uaddr, int len)
197
197
{
198
198
struct ieee802154_addr addr;
199
199
struct sockaddr_ieee802154 *uaddr = (struct sockaddr_ieee802154 *)_uaddr;
···
227
227
return err;
228
228
}
229
229
230
-
static int raw_connect(struct sock *sk, struct sockaddr *uaddr,
230
+
static int raw_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
231
231
int addr_len)
232
232
{
233
233
return -ENOTSUPP;
···
485
485
sk_common_release(sk);
486
486
}
487
487
488
-
static int dgram_bind(struct sock *sk, struct sockaddr *uaddr, int len)
488
+
static int dgram_bind(struct sock *sk, struct sockaddr_unsized *uaddr, int len)
489
489
{
490
490
struct sockaddr_ieee802154 *addr = (struct sockaddr_ieee802154 *)uaddr;
491
491
struct ieee802154_addr haddr;
···
563
563
}
564
564
565
565
/* FIXME: autobind */
566
-
static int dgram_connect(struct sock *sk, struct sockaddr *uaddr,
566
+
static int dgram_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
567
567
int len)
568
568
{
569
569
struct sockaddr_ieee802154 *addr = (struct sockaddr_ieee802154 *)uaddr;
+8
-8
net/ipv4/af_inet.c
+8
-8
net/ipv4/af_inet.c
···
441
441
}
442
442
EXPORT_SYMBOL(inet_release);
443
443
444
-
int inet_bind_sk(struct sock *sk, struct sockaddr *uaddr, int addr_len)
444
+
int inet_bind_sk(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len)
445
445
{
446
446
u32 flags = BIND_WITH_LOCK;
447
447
int err;
···
464
464
return __inet_bind(sk, uaddr, addr_len, flags);
465
465
}
466
466
467
-
int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
467
+
int inet_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
468
468
{
469
469
return inet_bind_sk(sock->sk, uaddr, addr_len);
470
470
}
471
471
EXPORT_SYMBOL(inet_bind);
472
472
473
-
int __inet_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len,
473
+
int __inet_bind(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len,
474
474
u32 flags)
475
475
{
476
476
struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
···
567
567
return err;
568
568
}
569
569
570
-
int inet_dgram_connect(struct socket *sock, struct sockaddr *uaddr,
570
+
int inet_dgram_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
571
571
int addr_len, int flags)
572
572
{
573
573
struct sock *sk = sock->sk;
···
623
623
* Connect to a remote host. There is regrettably still a little
624
624
* TCP 'magic' in here.
625
625
*/
626
-
int __inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
626
+
int __inet_stream_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
627
627
int addr_len, int flags, int is_sendmsg)
628
628
{
629
629
struct sock *sk = sock->sk;
···
741
741
}
742
742
EXPORT_SYMBOL(__inet_stream_connect);
743
743
744
-
int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
744
+
int inet_stream_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
745
745
int addr_len, int flags)
746
746
{
747
747
int err;
···
834
834
}
835
835
sin->sin_port = inet->inet_dport;
836
836
sin->sin_addr.s_addr = inet->inet_daddr;
837
-
BPF_CGROUP_RUN_SA_PROG(sk, (struct sockaddr *)sin, &sin_addr_len,
837
+
BPF_CGROUP_RUN_SA_PROG(sk, sin, &sin_addr_len,
838
838
CGROUP_INET4_GETPEERNAME);
839
839
} else {
840
840
__be32 addr = inet->inet_rcv_saddr;
···
842
842
addr = inet->inet_saddr;
843
843
sin->sin_port = inet->inet_sport;
844
844
sin->sin_addr.s_addr = addr;
845
-
BPF_CGROUP_RUN_SA_PROG(sk, (struct sockaddr *)sin, &sin_addr_len,
845
+
BPF_CGROUP_RUN_SA_PROG(sk, sin, &sin_addr_len,
846
846
CGROUP_INET4_GETSOCKNAME);
847
847
}
848
848
release_sock(sk);
+1
-1
net/ipv4/arp.c
+1
-1
net/ipv4/arp.c
···
1189
1189
1190
1190
read_lock_bh(&neigh->lock);
1191
1191
memcpy(r->arp_ha.sa_data, neigh->ha,
1192
-
min(dev->addr_len, sizeof(r->arp_ha.sa_data_min)));
1192
+
min(dev->addr_len, sizeof(r->arp_ha.sa_data)));
1193
1193
r->arp_flags = arp_state_to_flags(neigh);
1194
1194
read_unlock_bh(&neigh->lock);
1195
1195
+2
-2
net/ipv4/datagram.c
+2
-2
net/ipv4/datagram.c
···
16
16
#include <net/tcp_states.h>
17
17
#include <net/sock_reuseport.h>
18
18
19
-
int __ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
19
+
int __ip4_datagram_connect(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len)
20
20
{
21
21
struct inet_sock *inet = inet_sk(sk);
22
22
struct sockaddr_in *usin = (struct sockaddr_in *) uaddr;
···
84
84
}
85
85
EXPORT_SYMBOL(__ip4_datagram_connect);
86
86
87
-
int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
87
+
int ip4_datagram_connect(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len)
88
88
{
89
89
int res;
90
90
+4
-4
net/ipv4/ping.c
+4
-4
net/ipv4/ping.c
···
286
286
}
287
287
EXPORT_IPV6_MOD_GPL(ping_close);
288
288
289
-
static int ping_pre_connect(struct sock *sk, struct sockaddr *uaddr,
289
+
static int ping_pre_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
290
290
int addr_len)
291
291
{
292
292
/* This check is replicated from __ip4_datagram_connect() and
···
301
301
302
302
/* Checks the bind address and possibly modifies sk->sk_bound_dev_if. */
303
303
static int ping_check_bind_addr(struct sock *sk, struct inet_sock *isk,
304
-
struct sockaddr *uaddr, int addr_len)
304
+
struct sockaddr_unsized *uaddr, int addr_len)
305
305
{
306
306
struct net *net = sock_net(sk);
307
307
if (sk->sk_family == AF_INET) {
···
387
387
return 0;
388
388
}
389
389
390
-
static void ping_set_saddr(struct sock *sk, struct sockaddr *saddr)
390
+
static void ping_set_saddr(struct sock *sk, struct sockaddr_unsized *saddr)
391
391
{
392
392
if (saddr->sa_family == AF_INET) {
393
393
struct inet_sock *isk = inet_sk(sk);
···
407
407
* Moreover, we don't allow binding to multi- and broadcast addresses.
408
408
*/
409
409
410
-
int ping_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
410
+
int ping_bind(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len)
411
411
{
412
412
struct inet_sock *isk = inet_sk(sk);
413
413
unsigned short snum;
+2
-1
net/ipv4/raw.c
+2
-1
net/ipv4/raw.c
···
697
697
}
698
698
699
699
/* This gets rid of all the nasties in af_inet. -DaveM */
700
-
static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
700
+
static int raw_bind(struct sock *sk, struct sockaddr_unsized *uaddr,
701
+
int addr_len)
701
702
{
702
703
struct inet_sock *inet = inet_sk(sk);
703
704
struct sockaddr_in *addr = (struct sockaddr_in *) uaddr;
+1
-1
net/ipv4/tcp.c
+1
-1
net/ipv4/tcp.c
···
1061
1061
}
1062
1062
}
1063
1063
flags = (msg->msg_flags & MSG_DONTWAIT) ? O_NONBLOCK : 0;
1064
-
err = __inet_stream_connect(sk->sk_socket, uaddr,
1064
+
err = __inet_stream_connect(sk->sk_socket, (struct sockaddr_unsized *)uaddr,
1065
1065
msg->msg_namelen, flags, 1);
1066
1066
/* fastopen_req could already be freed in __inet_stream_connect
1067
1067
* if the connection times out or gets rst
+2
-2
net/ipv4/tcp_ipv4.c
+2
-2
net/ipv4/tcp_ipv4.c
···
205
205
}
206
206
EXPORT_IPV6_MOD_GPL(tcp_twsk_unique);
207
207
208
-
static int tcp_v4_pre_connect(struct sock *sk, struct sockaddr *uaddr,
208
+
static int tcp_v4_pre_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
209
209
int addr_len)
210
210
{
211
211
/* This check is replicated from tcp_v4_connect() and intended to
···
221
221
}
222
222
223
223
/* This will initiate an outgoing connection. */
224
-
int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
224
+
int tcp_v4_connect(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len)
225
225
{
226
226
struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
227
227
struct inet_timewait_death_row *tcp_death_row;
+4
-2
net/ipv4/udp.c
+4
-2
net/ipv4/udp.c
···
2159
2159
goto try_again;
2160
2160
}
2161
2161
2162
-
int udp_pre_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
2162
+
int udp_pre_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
2163
+
int addr_len)
2163
2164
{
2164
2165
/* This check is replicated from __ip4_datagram_connect() and
2165
2166
* intended to prevent BPF program called below from accessing bytes
···
2173
2172
}
2174
2173
EXPORT_IPV6_MOD(udp_pre_connect);
2175
2174
2176
-
static int udp_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
2175
+
static int udp_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
2176
+
int addr_len)
2177
2177
{
2178
2178
int res;
2179
2179
+2
-2
net/ipv4/udp_tunnel_core.c
+2
-2
net/ipv4/udp_tunnel_core.c
···
29
29
udp_addr.sin_family = AF_INET;
30
30
udp_addr.sin_addr = cfg->local_ip;
31
31
udp_addr.sin_port = cfg->local_udp_port;
32
-
err = kernel_bind(sock, (struct sockaddr *)&udp_addr,
32
+
err = kernel_bind(sock, (struct sockaddr_unsized *)&udp_addr,
33
33
sizeof(udp_addr));
34
34
if (err < 0)
35
35
goto error;
···
38
38
udp_addr.sin_family = AF_INET;
39
39
udp_addr.sin_addr = cfg->peer_ip;
40
40
udp_addr.sin_port = cfg->peer_udp_port;
41
-
err = kernel_connect(sock, (struct sockaddr *)&udp_addr,
41
+
err = kernel_connect(sock, (struct sockaddr_unsized *)&udp_addr,
42
42
sizeof(udp_addr), 0);
43
43
if (err < 0)
44
44
goto error;
+3
-3
net/ipv6/af_inet6.c
+3
-3
net/ipv6/af_inet6.c
···
277
277
goto out;
278
278
}
279
279
280
-
static int __inet6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len,
280
+
static int __inet6_bind(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len,
281
281
u32 flags)
282
282
{
283
283
struct sockaddr_in6 *addr = (struct sockaddr_in6 *)uaddr;
···
438
438
goto out;
439
439
}
440
440
441
-
int inet6_bind_sk(struct sock *sk, struct sockaddr *uaddr, int addr_len)
441
+
int inet6_bind_sk(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len)
442
442
{
443
443
u32 flags = BIND_WITH_LOCK;
444
444
const struct proto *prot;
···
465
465
}
466
466
467
467
/* bind for INET6 API */
468
-
int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
468
+
int inet6_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
469
469
{
470
470
return inet6_bind_sk(sock->sk, uaddr, addr_len);
471
471
}
+4
-4
net/ipv6/datagram.c
+4
-4
net/ipv6/datagram.c
···
138
138
}
139
139
EXPORT_SYMBOL_GPL(ip6_datagram_release_cb);
140
140
141
-
int __ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr,
141
+
int __ip6_datagram_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
142
142
int addr_len)
143
143
{
144
144
struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
···
194
194
sin.sin_port = usin->sin6_port;
195
195
196
196
err = __ip4_datagram_connect(sk,
197
-
(struct sockaddr *) &sin,
197
+
(struct sockaddr_unsized *)&sin,
198
198
sizeof(sin));
199
199
200
200
ipv4_connected:
···
271
271
}
272
272
EXPORT_SYMBOL_GPL(__ip6_datagram_connect);
273
273
274
-
int ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
274
+
int ip6_datagram_connect(struct sock *sk, struct sockaddr_unsized *uaddr, int addr_len)
275
275
{
276
276
int res;
277
277
···
282
282
}
283
283
EXPORT_SYMBOL_GPL(ip6_datagram_connect);
284
284
285
-
int ip6_datagram_connect_v6_only(struct sock *sk, struct sockaddr *uaddr,
285
+
int ip6_datagram_connect_v6_only(struct sock *sk, struct sockaddr_unsized *uaddr,
286
286
int addr_len)
287
287
{
288
288
DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, uaddr);
+2
-2
net/ipv6/ip6_udp_tunnel.c
+2
-2
net/ipv6/ip6_udp_tunnel.c
···
40
40
memcpy(&udp6_addr.sin6_addr, &cfg->local_ip6,
41
41
sizeof(udp6_addr.sin6_addr));
42
42
udp6_addr.sin6_port = cfg->local_udp_port;
43
-
err = kernel_bind(sock, (struct sockaddr *)&udp6_addr,
43
+
err = kernel_bind(sock, (struct sockaddr_unsized *)&udp6_addr,
44
44
sizeof(udp6_addr));
45
45
if (err < 0)
46
46
goto error;
···
52
52
sizeof(udp6_addr.sin6_addr));
53
53
udp6_addr.sin6_port = cfg->peer_udp_port;
54
54
err = kernel_connect(sock,
55
-
(struct sockaddr *)&udp6_addr,
55
+
(struct sockaddr_unsized *)&udp6_addr,
56
56
sizeof(udp6_addr), 0);
57
57
}
58
58
if (err < 0)
+1
-1
net/ipv6/ping.c
+1
-1
net/ipv6/ping.c
+2
-1
net/ipv6/raw.c
+2
-1
net/ipv6/raw.c
···
214
214
}
215
215
216
216
/* This cleans up af_inet6 a bit. -DaveM */
217
-
static int rawv6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
217
+
static int rawv6_bind(struct sock *sk, struct sockaddr_unsized *uaddr,
218
+
int addr_len)
218
219
{
219
220
struct inet_sock *inet = inet_sk(sk);
220
221
struct ipv6_pinfo *np = inet6_sk(sk);
+3
-3
net/ipv6/tcp_ipv6.c
+3
-3
net/ipv6/tcp_ipv6.c
···
118
118
ipv6_hdr(skb)->saddr.s6_addr32);
119
119
}
120
120
121
-
static int tcp_v6_pre_connect(struct sock *sk, struct sockaddr *uaddr,
121
+
static int tcp_v6_pre_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
122
122
int addr_len)
123
123
{
124
124
/* This check is replicated from tcp_v6_connect() and intended to
···
133
133
return BPF_CGROUP_RUN_PROG_INET6_CONNECT(sk, uaddr, &addr_len);
134
134
}
135
135
136
-
static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
136
+
static int tcp_v6_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
137
137
int addr_len)
138
138
{
139
139
struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
···
238
238
tp->af_specific = &tcp_sock_ipv6_mapped_specific;
239
239
#endif
240
240
241
-
err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
241
+
err = tcp_v4_connect(sk, (struct sockaddr_unsized *)&sin, sizeof(sin));
242
242
243
243
if (err) {
244
244
icsk->icsk_ext_hdr_len = exthdrlen;
+3
-2
net/ipv6/udp.c
+3
-2
net/ipv6/udp.c
···
1282
1282
}
1283
1283
}
1284
1284
1285
-
static int udpv6_pre_connect(struct sock *sk, struct sockaddr *uaddr,
1285
+
static int udpv6_pre_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
1286
1286
int addr_len)
1287
1287
{
1288
1288
if (addr_len < offsetofend(struct sockaddr, sa_family))
···
1303
1303
return BPF_CGROUP_RUN_PROG_INET6_CONNECT_LOCK(sk, uaddr, &addr_len);
1304
1304
}
1305
1305
1306
-
static int udpv6_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
1306
+
static int udpv6_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
1307
+
int addr_len)
1307
1308
{
1308
1309
int res;
1309
1310
+3
-3
net/iucv/af_iucv.c
+3
-3
net/iucv/af_iucv.c
···
563
563
}
564
564
565
565
/* Bind an unbound socket */
566
-
static int iucv_sock_bind(struct socket *sock, struct sockaddr *addr,
566
+
static int iucv_sock_bind(struct socket *sock, struct sockaddr_unsized *addr,
567
567
int addr_len)
568
568
{
569
569
DECLARE_SOCKADDR(struct sockaddr_iucv *, sa, addr);
···
668
668
return err;
669
669
}
670
670
671
-
static int afiucv_path_connect(struct socket *sock, struct sockaddr *addr)
671
+
static int afiucv_path_connect(struct socket *sock, struct sockaddr_unsized *addr)
672
672
{
673
673
DECLARE_SOCKADDR(struct sockaddr_iucv *, sa, addr);
674
674
struct sock *sk = sock->sk;
···
714
714
}
715
715
716
716
/* Connect an unconnected socket */
717
-
static int iucv_sock_connect(struct socket *sock, struct sockaddr *addr,
717
+
static int iucv_sock_connect(struct socket *sock, struct sockaddr_unsized *addr,
718
718
int alen, int flags)
719
719
{
720
720
DECLARE_SOCKADDR(struct sockaddr_iucv *, sa, addr);
+4
-4
net/l2tp/l2tp_core.c
+4
-4
net/l2tp/l2tp_core.c
···
1503
1503
memcpy(&ip6_addr.l2tp_addr, cfg->local_ip6,
1504
1504
sizeof(ip6_addr.l2tp_addr));
1505
1505
ip6_addr.l2tp_conn_id = tunnel_id;
1506
-
err = kernel_bind(sock, (struct sockaddr *)&ip6_addr,
1506
+
err = kernel_bind(sock, (struct sockaddr_unsized *)&ip6_addr,
1507
1507
sizeof(ip6_addr));
1508
1508
if (err < 0)
1509
1509
goto out;
···
1513
1513
sizeof(ip6_addr.l2tp_addr));
1514
1514
ip6_addr.l2tp_conn_id = peer_tunnel_id;
1515
1515
err = kernel_connect(sock,
1516
-
(struct sockaddr *)&ip6_addr,
1516
+
(struct sockaddr_unsized *)&ip6_addr,
1517
1517
sizeof(ip6_addr), 0);
1518
1518
if (err < 0)
1519
1519
goto out;
···
1530
1530
ip_addr.l2tp_family = AF_INET;
1531
1531
ip_addr.l2tp_addr = cfg->local_ip;
1532
1532
ip_addr.l2tp_conn_id = tunnel_id;
1533
-
err = kernel_bind(sock, (struct sockaddr *)&ip_addr,
1533
+
err = kernel_bind(sock, (struct sockaddr_unsized *)&ip_addr,
1534
1534
sizeof(ip_addr));
1535
1535
if (err < 0)
1536
1536
goto out;
···
1538
1538
ip_addr.l2tp_family = AF_INET;
1539
1539
ip_addr.l2tp_addr = cfg->peer_ip;
1540
1540
ip_addr.l2tp_conn_id = peer_tunnel_id;
1541
-
err = kernel_connect(sock, (struct sockaddr *)&ip_addr,
1541
+
err = kernel_connect(sock, (struct sockaddr_unsized *)&ip_addr,
1542
1542
sizeof(ip_addr), 0);
1543
1543
if (err < 0)
1544
1544
goto out;
+4
-2
net/l2tp/l2tp_ip.c
+4
-2
net/l2tp/l2tp_ip.c
···
267
267
}
268
268
}
269
269
270
-
static int l2tp_ip_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
270
+
static int l2tp_ip_bind(struct sock *sk, struct sockaddr_unsized *uaddr,
271
+
int addr_len)
271
272
{
272
273
struct inet_sock *inet = inet_sk(sk);
273
274
struct sockaddr_l2tpip *addr = (struct sockaddr_l2tpip *)uaddr;
···
329
328
return ret;
330
329
}
331
330
332
-
static int l2tp_ip_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
331
+
static int l2tp_ip_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
332
+
int addr_len)
333
333
{
334
334
struct sockaddr_l2tpip *lsa = (struct sockaddr_l2tpip *)uaddr;
335
335
struct l2tp_ip_net *pn = l2tp_ip_pernet(sock_net(sk));
+3
-2
net/l2tp/l2tp_ip6.c
+3
-2
net/l2tp/l2tp_ip6.c
···
280
280
}
281
281
}
282
282
283
-
static int l2tp_ip6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
283
+
static int l2tp_ip6_bind(struct sock *sk, struct sockaddr_unsized *uaddr,
284
+
int addr_len)
284
285
{
285
286
struct inet_sock *inet = inet_sk(sk);
286
287
struct ipv6_pinfo *np = inet6_sk(sk);
···
384
383
return err;
385
384
}
386
385
387
-
static int l2tp_ip6_connect(struct sock *sk, struct sockaddr *uaddr,
386
+
static int l2tp_ip6_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
388
387
int addr_len)
389
388
{
390
389
struct sockaddr_l2tpip6 *lsa = (struct sockaddr_l2tpip6 *)uaddr;
+1
-1
net/l2tp/l2tp_ppp.c
+1
-1
net/l2tp/l2tp_ppp.c
···
684
684
685
685
/* connect() handler. Attach a PPPoX socket to a tunnel UDP socket
686
686
*/
687
-
static int pppol2tp_connect(struct socket *sock, struct sockaddr *uservaddr,
687
+
static int pppol2tp_connect(struct socket *sock, struct sockaddr_unsized *uservaddr,
688
688
int sockaddr_len, int flags)
689
689
{
690
690
struct sock *sk = sock->sk;
+2
-2
net/llc/af_llc.c
+2
-2
net/llc/af_llc.c
···
337
337
* otherwise all hell will break loose.
338
338
* Returns: 0 upon success, negative otherwise.
339
339
*/
340
-
static int llc_ui_bind(struct socket *sock, struct sockaddr *uaddr, int addrlen)
340
+
static int llc_ui_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addrlen)
341
341
{
342
342
struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr;
343
343
struct sock *sk = sock->sk;
···
477
477
* This function will autobind if user did not previously call bind.
478
478
* Returns: 0 upon success, negative otherwise.
479
479
*/
480
-
static int llc_ui_connect(struct socket *sock, struct sockaddr *uaddr,
480
+
static int llc_ui_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
481
481
int addrlen, int flags)
482
482
{
483
483
struct sock *sk = sock->sk;
+2
-2
net/mctp/af_mctp.c
+2
-2
net/mctp/af_mctp.c
···
49
49
!addr->__smctp_pad0[2];
50
50
}
51
51
52
-
static int mctp_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
52
+
static int mctp_bind(struct socket *sock, struct sockaddr_unsized *addr, int addrlen)
53
53
{
54
54
struct sock *sk = sock->sk;
55
55
struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
···
128
128
/* Used to set a specific peer prior to bind. Not used for outbound
129
129
* connections (Tag Owner set) since MCTP is a datagram protocol.
130
130
*/
131
-
static int mctp_connect(struct socket *sock, struct sockaddr *addr,
131
+
static int mctp_connect(struct socket *sock, struct sockaddr_unsized *addr,
132
132
int addrlen, int flags)
133
133
{
134
134
struct sock *sk = sock->sk;
+1
-1
net/mctp/test/route-test.c
+1
-1
net/mctp/test/route-test.c
···
205
205
addr.smctp_network = netid;
206
206
addr.smctp_addr.s_addr = 8;
207
207
addr.smctp_type = 0;
208
-
rc = kernel_bind(sock, (struct sockaddr *)&addr, sizeof(addr));
208
+
rc = kernel_bind(sock, (struct sockaddr_unsized *)&addr, sizeof(addr));
209
209
KUNIT_ASSERT_EQ(test, rc, 0);
210
210
211
211
*devp = dev;
+3
-2
net/mctp/test/utils.c
+3
-2
net/mctp/test/utils.c
···
279
279
addr.smctp_addr.s_addr = setup->peer_addr;
280
280
/* connect() type must match bind() type */
281
281
addr.smctp_type = setup->bind_type;
282
-
rc = kernel_connect(*sock, (struct sockaddr *)&addr,
282
+
rc = kernel_connect(*sock, (struct sockaddr_unsized *)&addr,
283
283
sizeof(addr), 0);
284
284
KUNIT_EXPECT_EQ(test, rc, 0);
285
285
}
···
292
292
addr.smctp_type = setup->bind_type;
293
293
294
294
*ret_bind_errno =
295
-
kernel_bind(*sock, (struct sockaddr *)&addr, sizeof(addr));
295
+
kernel_bind(*sock, (struct sockaddr_unsized *)&addr,
296
+
sizeof(addr));
296
297
}
+2
-2
net/mptcp/pm_kernel.c
+2
-2
net/mptcp/pm_kernel.c
···
867
867
addrlen = sizeof(struct sockaddr_in6);
868
868
#endif
869
869
if (ssk->sk_family == AF_INET)
870
-
err = inet_bind_sk(ssk, (struct sockaddr *)&addr, addrlen);
870
+
err = inet_bind_sk(ssk, (struct sockaddr_unsized *)&addr, addrlen);
871
871
#if IS_ENABLED(CONFIG_MPTCP_IPV6)
872
872
else if (ssk->sk_family == AF_INET6)
873
-
err = inet6_bind_sk(ssk, (struct sockaddr *)&addr, addrlen);
873
+
err = inet6_bind_sk(ssk, (struct sockaddr_unsized *)&addr, addrlen);
874
874
#endif
875
875
if (err)
876
876
return err;
+3
-2
net/mptcp/protocol.c
+3
-2
net/mptcp/protocol.c
···
3746
3746
return 0;
3747
3747
}
3748
3748
3749
-
static int mptcp_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
3749
+
static int mptcp_connect(struct sock *sk, struct sockaddr_unsized *uaddr,
3750
+
int addr_len)
3750
3751
{
3751
3752
struct mptcp_subflow_context *subflow;
3752
3753
struct mptcp_sock *msk = mptcp_sk(sk);
···
3857
3856
.no_autobind = true,
3858
3857
};
3859
3858
3860
-
static int mptcp_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
3859
+
static int mptcp_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
3861
3860
{
3862
3861
struct mptcp_sock *msk = mptcp_sk(sock->sk);
3863
3862
struct sock *ssk, *sk = sock->sk;
+2
-2
net/mptcp/subflow.c
+2
-2
net/mptcp/subflow.c
···
1660
1660
addrlen = sizeof(struct sockaddr_in6);
1661
1661
#endif
1662
1662
ssk->sk_bound_dev_if = local->ifindex;
1663
-
err = kernel_bind(sf, (struct sockaddr *)&addr, addrlen);
1663
+
err = kernel_bind(sf, (struct sockaddr_unsized *)&addr, addrlen);
1664
1664
if (err) {
1665
1665
MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_JOINSYNTXBINDERR);
1666
1666
pr_debug("msk=%p local=%d remote=%d bind error: %d\n",
···
1680
1680
1681
1681
sock_hold(ssk);
1682
1682
list_add_tail(&subflow->node, &msk->conn_list);
1683
-
err = kernel_connect(sf, (struct sockaddr *)&addr, addrlen, O_NONBLOCK);
1683
+
err = kernel_connect(sf, (struct sockaddr_unsized *)&addr, addrlen, O_NONBLOCK);
1684
1684
if (err && err != -EINPROGRESS) {
1685
1685
MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_JOINSYNTXCONNECTERR);
1686
1686
pr_debug("msk=%p local=%d remote=%d connect error: %d\n",
+3
-3
net/netfilter/ipvs/ip_vs_sync.c
+3
-3
net/netfilter/ipvs/ip_vs_sync.c
···
1435
1435
sin.sin_addr.s_addr = addr;
1436
1436
sin.sin_port = 0;
1437
1437
1438
-
return kernel_bind(sock, (struct sockaddr *)&sin, sizeof(sin));
1438
+
return kernel_bind(sock, (struct sockaddr_unsized *)&sin, sizeof(sin));
1439
1439
}
1440
1440
1441
1441
static void get_mcast_sockaddr(union ipvs_sockaddr *sa, int *salen,
···
1501
1501
}
1502
1502
1503
1503
get_mcast_sockaddr(&mcast_addr, &salen, &ipvs->mcfg, id);
1504
-
result = kernel_connect(sock, (struct sockaddr *)&mcast_addr,
1504
+
result = kernel_connect(sock, (struct sockaddr_unsized *)&mcast_addr,
1505
1505
salen, 0);
1506
1506
if (result < 0) {
1507
1507
pr_err("Error connecting to the multicast addr\n");
···
1542
1542
1543
1543
get_mcast_sockaddr(&mcast_addr, &salen, &ipvs->bcfg, id);
1544
1544
sock->sk->sk_bound_dev_if = dev->ifindex;
1545
-
result = kernel_bind(sock, (struct sockaddr *)&mcast_addr, salen);
1545
+
result = kernel_bind(sock, (struct sockaddr_unsized *)&mcast_addr, salen);
1546
1546
if (result < 0) {
1547
1547
pr_err("Error binding to the multicast addr\n");
1548
1548
goto error;
+2
-2
net/netlink/af_netlink.c
+2
-2
net/netlink/af_netlink.c
···
966
966
nlk->netlink_unbind(sock_net(sk), undo + 1);
967
967
}
968
968
969
-
static int netlink_bind(struct socket *sock, struct sockaddr *addr,
969
+
static int netlink_bind(struct socket *sock, struct sockaddr_unsized *addr,
970
970
int addr_len)
971
971
{
972
972
struct sock *sk = sock->sk;
···
1054
1054
return err;
1055
1055
}
1056
1056
1057
-
static int netlink_connect(struct socket *sock, struct sockaddr *addr,
1057
+
static int netlink_connect(struct socket *sock, struct sockaddr_unsized *addr,
1058
1058
int alen, int flags)
1059
1059
{
1060
1060
int err = 0;
+3
-3
net/netrom/af_netrom.c
+3
-3
net/netrom/af_netrom.c
···
561
561
return 0;
562
562
}
563
563
564
-
static int nr_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
564
+
static int nr_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
565
565
{
566
566
struct sock *sk = sock->sk;
567
567
struct nr_sock *nr = nr_sk(sk);
···
632
632
return 0;
633
633
}
634
634
635
-
static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
636
-
int addr_len, int flags)
635
+
static int nr_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
636
+
int addr_len, int flags)
637
637
{
638
638
struct sock *sk = sock->sk;
639
639
struct nr_sock *nr = nr_sk(sk);
+3
-3
net/nfc/llcp_sock.c
+3
-3
net/nfc/llcp_sock.c
···
56
56
.obj_size = sizeof(struct nfc_llcp_sock),
57
57
};
58
58
59
-
static int llcp_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
59
+
static int llcp_sock_bind(struct socket *sock, struct sockaddr_unsized *addr, int alen)
60
60
{
61
61
struct sock *sk = sock->sk;
62
62
struct nfc_llcp_sock *llcp_sock = nfc_llcp_sock(sk);
···
146
146
return ret;
147
147
}
148
148
149
-
static int llcp_raw_sock_bind(struct socket *sock, struct sockaddr *addr,
149
+
static int llcp_raw_sock_bind(struct socket *sock, struct sockaddr_unsized *addr,
150
150
int alen)
151
151
{
152
152
struct sock *sk = sock->sk;
···
648
648
return err;
649
649
}
650
650
651
-
static int llcp_sock_connect(struct socket *sock, struct sockaddr *_addr,
651
+
static int llcp_sock_connect(struct socket *sock, struct sockaddr_unsized *_addr,
652
652
int len, int flags)
653
653
{
654
654
struct sock *sk = sock->sk;
+1
-1
net/nfc/rawsock.c
+1
-1
net/nfc/rawsock.c
+8
-7
net/packet/af_packet.c
+8
-7
net/packet/af_packet.c
···
3279
3279
* Bind a packet socket to a device
3280
3280
*/
3281
3281
3282
-
static int packet_bind_spkt(struct socket *sock, struct sockaddr *uaddr,
3282
+
static int packet_bind_spkt(struct socket *sock, struct sockaddr_unsized *uaddr,
3283
3283
int addr_len)
3284
3284
{
3285
3285
struct sock *sk = sock->sk;
3286
-
char name[sizeof(uaddr->sa_data_min) + 1];
3286
+
struct sockaddr *sa = (struct sockaddr *)uaddr;
3287
+
char name[sizeof(sa->sa_data) + 1];
3287
3288
3288
3289
/*
3289
3290
* Check legality
···
3295
3294
/* uaddr->sa_data comes from the userspace, it's not guaranteed to be
3296
3295
* zero-terminated.
3297
3296
*/
3298
-
memcpy(name, uaddr->sa_data, sizeof(uaddr->sa_data_min));
3299
-
name[sizeof(uaddr->sa_data_min)] = 0;
3297
+
memcpy(name, sa->sa_data, sizeof(sa->sa_data));
3298
+
name[sizeof(sa->sa_data)] = 0;
3300
3299
3301
3300
return packet_do_bind(sk, name, 0, 0);
3302
3301
}
3303
3302
3304
-
static int packet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
3303
+
static int packet_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
3305
3304
{
3306
3305
struct sockaddr_ll *sll = (struct sockaddr_ll *)uaddr;
3307
3306
struct sock *sk = sock->sk;
···
3581
3580
return -EOPNOTSUPP;
3582
3581
3583
3582
uaddr->sa_family = AF_PACKET;
3584
-
memset(uaddr->sa_data, 0, sizeof(uaddr->sa_data_min));
3583
+
memset(uaddr->sa_data, 0, sizeof(uaddr->sa_data));
3585
3584
rcu_read_lock();
3586
3585
dev = dev_get_by_index_rcu(sock_net(sk), READ_ONCE(pkt_sk(sk)->ifindex));
3587
3586
if (dev)
3588
-
strscpy(uaddr->sa_data, dev->name, sizeof(uaddr->sa_data_min));
3587
+
strscpy(uaddr->sa_data, dev->name, sizeof(uaddr->sa_data));
3589
3588
rcu_read_unlock();
3590
3589
3591
3590
return sizeof(*uaddr);
+2
-1
net/phonet/pep.c
+2
-1
net/phonet/pep.c
+5
-5
net/phonet/socket.c
+5
-5
net/phonet/socket.c
···
153
153
154
154
static DEFINE_MUTEX(port_mutex);
155
155
156
-
static int pn_socket_bind(struct socket *sock, struct sockaddr *addr, int len)
156
+
static int pn_socket_bind(struct socket *sock, struct sockaddr_unsized *addr, int len)
157
157
{
158
158
struct sock *sk = sock->sk;
159
159
struct pn_sock *pn = pn_sk(sk);
···
206
206
207
207
memset(&sa, 0, sizeof(sa));
208
208
sa.spn_family = AF_PHONET;
209
-
err = pn_socket_bind(sock, (struct sockaddr *)&sa,
210
-
sizeof(struct sockaddr_pn));
209
+
err = pn_socket_bind(sock, (struct sockaddr_unsized *)&sa,
210
+
sizeof(struct sockaddr_pn));
211
211
if (err != -EINVAL)
212
212
return err;
213
213
BUG_ON(!pn_port(pn_sk(sock->sk)->sobject));
214
214
return 0; /* socket was already bound */
215
215
}
216
216
217
-
static int pn_socket_connect(struct socket *sock, struct sockaddr *addr,
218
-
int len, int flags)
217
+
static int pn_socket_connect(struct socket *sock, struct sockaddr_unsized *addr,
218
+
int len, int flags)
219
219
{
220
220
struct sock *sk = sock->sk;
221
221
struct pn_sock *pn = pn_sk(sk);
+2
-2
net/qrtr/af_qrtr.c
+2
-2
net/qrtr/af_qrtr.c
···
824
824
}
825
825
826
826
/* Bind socket to specified sockaddr. */
827
-
static int qrtr_bind(struct socket *sock, struct sockaddr *saddr, int len)
827
+
static int qrtr_bind(struct socket *sock, struct sockaddr_unsized *saddr, int len)
828
828
{
829
829
DECLARE_SOCKADDR(struct sockaddr_qrtr *, addr, saddr);
830
830
struct qrtr_sock *ipc = qrtr_sk(sock->sk);
···
1084
1084
return rc;
1085
1085
}
1086
1086
1087
-
static int qrtr_connect(struct socket *sock, struct sockaddr *saddr,
1087
+
static int qrtr_connect(struct socket *sock, struct sockaddr_unsized *saddr,
1088
1088
int len, int flags)
1089
1089
{
1090
1090
DECLARE_SOCKADDR(struct sockaddr_qrtr *, addr, saddr);
+1
-1
net/qrtr/ns.c
+1
-1
net/qrtr/ns.c
···
714
714
sq.sq_port = QRTR_PORT_CTRL;
715
715
qrtr_ns.local_node = sq.sq_node;
716
716
717
-
ret = kernel_bind(qrtr_ns.sock, (struct sockaddr *)&sq, sizeof(sq));
717
+
ret = kernel_bind(qrtr_ns.sock, (struct sockaddr_unsized *)&sq, sizeof(sq));
718
718
if (ret < 0) {
719
719
pr_err("failed to bind to socket\n");
720
720
goto err_wq;
+1
-1
net/rds/af_rds.c
+1
-1
net/rds/af_rds.c
+1
-1
net/rds/bind.c
+1
-1
net/rds/bind.c
···
160
160
rs->rs_bound_addr = in6addr_any;
161
161
}
162
162
163
-
int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
163
+
int rds_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
164
164
{
165
165
struct sock *sk = sock->sk;
166
166
struct rds_sock *rs = rds_sk_to_rs(sk);
+1
-1
net/rds/rds.h
+1
-1
net/rds/rds.h
···
735
735
736
736
737
737
/* bind.c */
738
-
int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len);
738
+
int rds_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len);
739
739
void rds_remove_bound(struct rds_sock *rs);
740
740
struct rds_sock *rds_find_bound(const struct in6_addr *addr, __be16 port,
741
741
__u32 scope_id);
+2
-2
net/rds/tcp_connect.c
+2
-2
net/rds/tcp_connect.c
···
145
145
addrlen = sizeof(sin);
146
146
}
147
147
148
-
ret = kernel_bind(sock, addr, addrlen);
148
+
ret = kernel_bind(sock, (struct sockaddr_unsized *)addr, addrlen);
149
149
if (ret) {
150
150
rdsdebug("bind failed with %d at address %pI6c\n",
151
151
ret, &conn->c_laddr);
···
173
173
* own the socket
174
174
*/
175
175
rds_tcp_set_callbacks(sock, cp);
176
-
ret = kernel_connect(sock, addr, addrlen, O_NONBLOCK);
176
+
ret = kernel_connect(sock, (struct sockaddr_unsized *)addr, addrlen, O_NONBLOCK);
177
177
178
178
rdsdebug("connect to address %pI6c returned %d\n", &conn->c_faddr, ret);
179
179
if (ret == -EINPROGRESS)
+1
-1
net/rds/tcp_listen.c
+1
-1
net/rds/tcp_listen.c
···
290
290
addr_len = sizeof(*sin);
291
291
}
292
292
293
-
ret = kernel_bind(sock, (struct sockaddr *)&ss, addr_len);
293
+
ret = kernel_bind(sock, (struct sockaddr_unsized *)&ss, addr_len);
294
294
if (ret < 0) {
295
295
rdsdebug("could not bind %s listener socket: %d\n",
296
296
isv6 ? "IPv6" : "IPv4", ret);
+3
-2
net/rose/af_rose.c
+3
-2
net/rose/af_rose.c
···
693
693
return 0;
694
694
}
695
695
696
-
static int rose_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
696
+
static int rose_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
697
697
{
698
698
struct sock *sk = sock->sk;
699
699
struct rose_sock *rose = rose_sk(sk);
···
765
765
return err;
766
766
}
767
767
768
-
static int rose_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags)
768
+
static int rose_connect(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len,
769
+
int flags)
769
770
{
770
771
struct sock *sk = sock->sk;
771
772
struct rose_sock *rose = rose_sk(sk);
+2
-2
net/rxrpc/af_rxrpc.c
+2
-2
net/rxrpc/af_rxrpc.c
···
127
127
/*
128
128
* bind a local address to an RxRPC socket
129
129
*/
130
-
static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len)
130
+
static int rxrpc_bind(struct socket *sock, struct sockaddr_unsized *saddr, int len)
131
131
{
132
132
struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)saddr;
133
133
struct rxrpc_local *local;
···
481
481
* - this just targets it at a specific destination; no actual connection
482
482
* negotiation takes place
483
483
*/
484
-
static int rxrpc_connect(struct socket *sock, struct sockaddr *addr,
484
+
static int rxrpc_connect(struct socket *sock, struct sockaddr_unsized *addr,
485
485
int addr_len, int flags)
486
486
{
487
487
struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)addr;
+1
-1
net/rxrpc/rxperf.c
+1
-1
net/rxrpc/rxperf.c
+7
-6
net/sctp/socket.c
+7
-6
net/sctp/socket.c
···
306
306
* sockaddr_in6 [RFC 2553]),
307
307
* addr_len - the size of the address structure.
308
308
*/
309
-
static int sctp_bind(struct sock *sk, struct sockaddr *addr, int addr_len)
309
+
static int sctp_bind(struct sock *sk, struct sockaddr_unsized *addr,
310
+
int addr_len)
310
311
{
311
312
int retval = 0;
312
313
···
1054
1053
}
1055
1054
}
1056
1055
1057
-
static int sctp_bind_add(struct sock *sk, struct sockaddr *addrs,
1058
-
int addrlen)
1056
+
static int sctp_bind_add(struct sock *sk, struct sockaddr_unsized *addrs,
1057
+
int addrlen)
1059
1058
{
1060
1059
int err;
1061
1060
1062
1061
lock_sock(sk);
1063
-
err = sctp_setsockopt_bindx(sk, addrs, addrlen, SCTP_BINDX_ADD_ADDR);
1062
+
err = sctp_setsockopt_bindx(sk, (struct sockaddr *)addrs, addrlen, SCTP_BINDX_ADD_ADDR);
1064
1063
release_sock(sk);
1065
1064
return err;
1066
1065
}
···
4821
4820
return err;
4822
4821
}
4823
4822
4824
-
int sctp_inet_connect(struct socket *sock, struct sockaddr *uaddr,
4823
+
int sctp_inet_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
4825
4824
int addr_len, int flags)
4826
4825
{
4827
4826
if (addr_len < sizeof(uaddr->sa_family))
···
4830
4829
if (uaddr->sa_family == AF_UNSPEC)
4831
4830
return -EOPNOTSUPP;
4832
4831
4833
-
return sctp_connect(sock->sk, uaddr, addr_len, flags);
4832
+
return sctp_connect(sock->sk, (struct sockaddr *)uaddr, addr_len, flags);
4834
4833
}
4835
4834
4836
4835
/* Only called when shutdown a listening SCTP socket. */
+3
-3
net/smc/af_smc.c
+3
-3
net/smc/af_smc.c
···
421
421
return sk;
422
422
}
423
423
424
-
int smc_bind(struct socket *sock, struct sockaddr *uaddr,
424
+
int smc_bind(struct socket *sock, struct sockaddr_unsized *uaddr,
425
425
int addr_len)
426
426
{
427
427
struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
···
1642
1642
release_sock(&smc->sk);
1643
1643
}
1644
1644
1645
-
int smc_connect(struct socket *sock, struct sockaddr *addr,
1645
+
int smc_connect(struct socket *sock, struct sockaddr_unsized *addr,
1646
1646
int alen, int flags)
1647
1647
{
1648
1648
struct sock *sk = sock->sk;
···
1694
1694
rc = -EALREADY;
1695
1695
goto out;
1696
1696
}
1697
-
rc = kernel_connect(smc->clcsock, addr, alen, flags);
1697
+
rc = kernel_connect(smc->clcsock, (struct sockaddr_unsized *)addr, alen, flags);
1698
1698
if (rc && rc != -EINPROGRESS)
1699
1699
goto out;
1700
1700
+2
-2
net/smc/smc.h
+2
-2
net/smc/smc.h
···
42
42
void smc_release_cb(struct sock *sk);
43
43
44
44
int smc_release(struct socket *sock);
45
-
int smc_bind(struct socket *sock, struct sockaddr *uaddr,
45
+
int smc_bind(struct socket *sock, struct sockaddr_unsized *uaddr,
46
46
int addr_len);
47
-
int smc_connect(struct socket *sock, struct sockaddr *addr,
47
+
int smc_connect(struct socket *sock, struct sockaddr_unsized *addr,
48
48
int alen, int flags);
49
49
int smc_accept(struct socket *sock, struct socket *new_sock,
50
50
struct proto_accept_arg *arg);
+7
-7
net/socket.c
+7
-7
net/socket.c
···
1872
1872
addrlen);
1873
1873
if (!err)
1874
1874
err = READ_ONCE(sock->ops)->bind(sock,
1875
-
(struct sockaddr *)address,
1875
+
(struct sockaddr_unsized *)address,
1876
1876
addrlen);
1877
1877
return err;
1878
1878
}
···
2099
2099
if (err)
2100
2100
goto out;
2101
2101
2102
-
err = READ_ONCE(sock->ops)->connect(sock, (struct sockaddr *)address,
2103
-
addrlen, sock->file->f_flags | file_flags);
2102
+
err = READ_ONCE(sock->ops)->connect(sock, (struct sockaddr_unsized *)address,
2103
+
addrlen, sock->file->f_flags | file_flags);
2104
2104
out:
2105
2105
return err;
2106
2106
}
···
3583
3583
* Returns 0 or an error.
3584
3584
*/
3585
3585
3586
-
int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
3586
+
int kernel_bind(struct socket *sock, struct sockaddr_unsized *addr, int addrlen)
3587
3587
{
3588
3588
struct sockaddr_storage address;
3589
3589
3590
3590
memcpy(&address, addr, addrlen);
3591
3591
3592
-
return READ_ONCE(sock->ops)->bind(sock, (struct sockaddr *)&address,
3592
+
return READ_ONCE(sock->ops)->bind(sock, (struct sockaddr_unsized *)&address,
3593
3593
addrlen);
3594
3594
}
3595
3595
EXPORT_SYMBOL(kernel_bind);
···
3662
3662
* Returns 0 or an error code.
3663
3663
*/
3664
3664
3665
-
int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
3665
+
int kernel_connect(struct socket *sock, struct sockaddr_unsized *addr, int addrlen,
3666
3666
int flags)
3667
3667
{
3668
3668
struct sockaddr_storage address;
3669
3669
3670
3670
memcpy(&address, addr, addrlen);
3671
3671
3672
-
return READ_ONCE(sock->ops)->connect(sock, (struct sockaddr *)&address,
3672
+
return READ_ONCE(sock->ops)->connect(sock, (struct sockaddr_unsized *)&address,
3673
3673
addrlen, flags);
3674
3674
}
3675
3675
EXPORT_SYMBOL(kernel_connect);
+3
-3
net/sunrpc/clnt.c
+3
-3
net/sunrpc/clnt.c
···
1457
1457
switch (sap->sa_family) {
1458
1458
case AF_INET:
1459
1459
err = kernel_bind(sock,
1460
-
(struct sockaddr *)&rpc_inaddr_loopback,
1460
+
(struct sockaddr_unsized *)&rpc_inaddr_loopback,
1461
1461
sizeof(rpc_inaddr_loopback));
1462
1462
break;
1463
1463
case AF_INET6:
1464
1464
err = kernel_bind(sock,
1465
-
(struct sockaddr *)&rpc_in6addr_loopback,
1465
+
(struct sockaddr_unsized *)&rpc_in6addr_loopback,
1466
1466
sizeof(rpc_in6addr_loopback));
1467
1467
break;
1468
1468
default:
···
1474
1474
goto out_release;
1475
1475
}
1476
1476
1477
-
err = kernel_connect(sock, sap, salen, 0);
1477
+
err = kernel_connect(sock, (struct sockaddr_unsized *)sap, salen, 0);
1478
1478
if (err < 0) {
1479
1479
dprintk("RPC: can't connect UDP socket (%d)\n", err);
1480
1480
goto out_release;
+1
-1
net/sunrpc/svcsock.c
+1
-1
net/sunrpc/svcsock.c
···
1557
1557
ip6_sock_set_v6only(sock->sk);
1558
1558
if (type == SOCK_STREAM)
1559
1559
sock->sk->sk_reuse = SK_CAN_REUSE; /* allow address reuse */
1560
-
error = kernel_bind(sock, sin, len);
1560
+
error = kernel_bind(sock, (struct sockaddr_unsized *)sin, len);
1561
1561
if (error < 0)
1562
1562
goto bummer;
1563
1563
+5
-4
net/sunrpc/xprtsock.c
+5
-4
net/sunrpc/xprtsock.c
···
1845
1845
memcpy(&myaddr, &transport->srcaddr, transport->xprt.addrlen);
1846
1846
do {
1847
1847
rpc_set_port((struct sockaddr *)&myaddr, port);
1848
-
err = kernel_bind(sock, (struct sockaddr *)&myaddr,
1849
-
transport->xprt.addrlen);
1848
+
err = kernel_bind(sock, (struct sockaddr_unsized *)&myaddr,
1849
+
transport->xprt.addrlen);
1850
1850
if (err == 0) {
1851
1851
if (transport->xprt.reuseport)
1852
1852
transport->srcport = port;
···
2005
2005
2006
2006
xs_stream_start_connect(transport);
2007
2007
2008
-
return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, 0);
2008
+
return kernel_connect(sock, (struct sockaddr_unsized *)xs_addr(xprt), xprt->addrlen, 0);
2009
2009
}
2010
2010
2011
2011
/**
···
2405
2405
2406
2406
/* Tell the socket layer to start connecting... */
2407
2407
set_bit(XPRT_SOCK_CONNECTING, &transport->sock_state);
2408
-
return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
2408
+
return kernel_connect(sock, (struct sockaddr_unsized *)xs_addr(xprt),
2409
+
xprt->addrlen, O_NONBLOCK);
2409
2410
}
2410
2411
2411
2412
/**
+3
-3
net/tipc/socket.c
+3
-3
net/tipc/socket.c
···
710
710
return res;
711
711
}
712
712
713
-
static int tipc_bind(struct socket *sock, struct sockaddr *skaddr, int alen)
713
+
static int tipc_bind(struct socket *sock, struct sockaddr_unsized *skaddr, int alen)
714
714
{
715
715
struct tipc_uaddr *ua = (struct tipc_uaddr *)skaddr;
716
716
u32 atype = ua->addrtype;
···
726
726
return -EACCES;
727
727
}
728
728
}
729
-
return tipc_sk_bind(sock, skaddr, alen);
729
+
return tipc_sk_bind(sock, (struct sockaddr *)skaddr, alen);
730
730
}
731
731
732
732
/**
···
2565
2565
*
2566
2566
* Return: 0 on success, errno otherwise
2567
2567
*/
2568
-
static int tipc_connect(struct socket *sock, struct sockaddr *dest,
2568
+
static int tipc_connect(struct socket *sock, struct sockaddr_unsized *dest,
2569
2569
int destlen, int flags)
2570
2570
{
2571
2571
struct sock *sk = sock->sk;
+6
-6
net/unix/af_unix.c
+6
-6
net/unix/af_unix.c
···
843
843
}
844
844
845
845
static int unix_release(struct socket *);
846
-
static int unix_bind(struct socket *, struct sockaddr *, int);
847
-
static int unix_stream_connect(struct socket *, struct sockaddr *,
846
+
static int unix_bind(struct socket *, struct sockaddr_unsized *, int);
847
+
static int unix_stream_connect(struct socket *, struct sockaddr_unsized *,
848
848
int addr_len, int flags);
849
849
static int unix_socketpair(struct socket *, struct socket *);
850
850
static int unix_accept(struct socket *, struct socket *, struct proto_accept_arg *arg);
···
866
866
static int unix_dgram_recvmsg(struct socket *, struct msghdr *, size_t, int);
867
867
static int unix_read_skb(struct sock *sk, skb_read_actor_t recv_actor);
868
868
static int unix_stream_read_skb(struct sock *sk, skb_read_actor_t recv_actor);
869
-
static int unix_dgram_connect(struct socket *, struct sockaddr *,
869
+
static int unix_dgram_connect(struct socket *, struct sockaddr_unsized *,
870
870
int, int);
871
871
static int unix_seqpacket_sendmsg(struct socket *, struct msghdr *, size_t);
872
872
static int unix_seqpacket_recvmsg(struct socket *, struct msghdr *, size_t,
···
1466
1466
return err;
1467
1467
}
1468
1468
1469
-
static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1469
+
static int unix_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
1470
1470
{
1471
1471
struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
1472
1472
struct sock *sk = sock->sk;
···
1512
1512
unix_state_unlock(sk2);
1513
1513
}
1514
1514
1515
-
static int unix_dgram_connect(struct socket *sock, struct sockaddr *addr,
1515
+
static int unix_dgram_connect(struct socket *sock, struct sockaddr_unsized *addr,
1516
1516
int alen, int flags)
1517
1517
{
1518
1518
struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
···
1631
1631
return timeo;
1632
1632
}
1633
1633
1634
-
static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr,
1634
+
static int unix_stream_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
1635
1635
int addr_len, int flags)
1636
1636
{
1637
1637
struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
+3
-3
net/vmw_vsock/af_vsock.c
+3
-3
net/vmw_vsock/af_vsock.c
···
987
987
}
988
988
989
989
static int
990
-
vsock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
990
+
vsock_bind(struct socket *sock, struct sockaddr_unsized *addr, int addr_len)
991
991
{
992
992
int err;
993
993
struct sock *sk;
···
1328
1328
}
1329
1329
1330
1330
static int vsock_dgram_connect(struct socket *sock,
1331
-
struct sockaddr *addr, int addr_len, int flags)
1331
+
struct sockaddr_unsized *addr, int addr_len, int flags)
1332
1332
{
1333
1333
int err;
1334
1334
struct sock *sk;
···
1528
1528
sock_put(sk);
1529
1529
}
1530
1530
1531
-
static int vsock_connect(struct socket *sock, struct sockaddr *addr,
1531
+
static int vsock_connect(struct socket *sock, struct sockaddr_unsized *addr,
1532
1532
int addr_len, int flags)
1533
1533
{
1534
1534
int err;
+1
-1
net/vmw_vsock/vsock_addr.c
+1
-1
net/vmw_vsock/vsock_addr.c
+2
-2
net/x25/af_x25.c
+2
-2
net/x25/af_x25.c
···
670
670
return 0;
671
671
}
672
672
673
-
static int x25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
673
+
static int x25_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int addr_len)
674
674
{
675
675
struct sock *sk = sock->sk;
676
676
struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr;
···
743
743
return rc;
744
744
}
745
745
746
-
static int x25_connect(struct socket *sock, struct sockaddr *uaddr,
746
+
static int x25_connect(struct socket *sock, struct sockaddr_unsized *uaddr,
747
747
int addr_len, int flags)
748
748
{
749
749
struct sock *sk = sock->sk;
+1
-1
net/xdp/xsk.c
+1
-1
net/xdp/xsk.c
···
1238
1238
return xs->fq_tmp && xs->cq_tmp;
1239
1239
}
1240
1240
1241
-
static int xsk_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
1241
+
static int xsk_bind(struct socket *sock, struct sockaddr_unsized *addr, int addr_len)
1242
1242
{
1243
1243
struct sockaddr_xdp *sxdp = (struct sockaddr_xdp *)addr;
1244
1244
struct sock *sk = sock->sk;
+1
-1
samples/qmi/qmi_sample_client.c
+1
-1
samples/qmi/qmi_sample_client.c
···
468
468
return ret;
469
469
470
470
sq = dev_get_platdata(&pdev->dev);
471
-
ret = kernel_connect(sample->qmi.sock, (struct sockaddr *)sq,
471
+
ret = kernel_connect(sample->qmi.sock, (struct sockaddr_unsized *)sq,
472
472
sizeof(*sq), 0);
473
473
if (ret < 0) {
474
474
pr_err("failed to connect to remote service port\n");
+1
-4
tools/perf/trace/beauty/include/linux/socket.h
+1
-4
tools/perf/trace/beauty/include/linux/socket.h
···
34
34
35
35
struct sockaddr {
36
36
sa_family_t sa_family; /* address family, AF_xxx */
37
-
union {
38
-
char sa_data_min[14]; /* Minimum 14 bytes of protocol address */
39
-
DECLARE_FLEX_ARRAY(char, sa_data);
40
-
};
37
+
char sa_data[14]; /* 14 bytes of protocol address */
41
38
};
42
39
43
40
struct linger {
+2
-2
tools/testing/selftests/bpf/test_kmods/bpf_testmod.c
+2
-2
tools/testing/selftests/bpf/test_kmods/bpf_testmod.c
···
900
900
goto out;
901
901
}
902
902
903
-
err = kernel_connect(sock, (struct sockaddr *)&args->addr,
903
+
err = kernel_connect(sock, (struct sockaddr_unsized *)&args->addr,
904
904
args->addrlen, 0);
905
905
out:
906
906
mutex_unlock(&sock_lock);
···
923
923
goto out;
924
924
}
925
925
926
-
err = kernel_bind(sock, (struct sockaddr *)&args->addr, args->addrlen);
926
+
err = kernel_bind(sock, (struct sockaddr_unsized *)&args->addr, args->addrlen);
927
927
out:
928
928
mutex_unlock(&sock_lock);
929
929