forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
193 lines
4.6 KiB
193 lines
4.6 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
#include <linux/ceph/ceph_debug.h> |
|
|
|
#include <linux/inet.h> |
|
|
|
#include <linux/ceph/decode.h> |
|
#include <linux/ceph/messenger.h> /* for ceph_pr_addr() */ |
|
|
|
static int |
|
ceph_decode_entity_addr_versioned(void **p, void *end, |
|
struct ceph_entity_addr *addr) |
|
{ |
|
int ret; |
|
u8 struct_v; |
|
u32 struct_len, addr_len; |
|
void *struct_end; |
|
|
|
ret = ceph_start_decoding(p, end, 1, "entity_addr_t", &struct_v, |
|
&struct_len); |
|
if (ret) |
|
goto bad; |
|
|
|
ret = -EINVAL; |
|
struct_end = *p + struct_len; |
|
|
|
ceph_decode_copy_safe(p, end, &addr->type, sizeof(addr->type), bad); |
|
|
|
ceph_decode_copy_safe(p, end, &addr->nonce, sizeof(addr->nonce), bad); |
|
|
|
ceph_decode_32_safe(p, end, addr_len, bad); |
|
if (addr_len > sizeof(addr->in_addr)) |
|
goto bad; |
|
|
|
memset(&addr->in_addr, 0, sizeof(addr->in_addr)); |
|
if (addr_len) { |
|
ceph_decode_copy_safe(p, end, &addr->in_addr, addr_len, bad); |
|
|
|
addr->in_addr.ss_family = |
|
le16_to_cpu((__force __le16)addr->in_addr.ss_family); |
|
} |
|
|
|
/* Advance past anything the client doesn't yet understand */ |
|
*p = struct_end; |
|
ret = 0; |
|
bad: |
|
return ret; |
|
} |
|
|
|
static int |
|
ceph_decode_entity_addr_legacy(void **p, void *end, |
|
struct ceph_entity_addr *addr) |
|
{ |
|
int ret = -EINVAL; |
|
|
|
/* Skip rest of type field */ |
|
ceph_decode_skip_n(p, end, 3, bad); |
|
|
|
/* |
|
* Clients that don't support ADDR2 always send TYPE_NONE, change it |
|
* to TYPE_LEGACY for forward compatibility. |
|
*/ |
|
addr->type = CEPH_ENTITY_ADDR_TYPE_LEGACY; |
|
ceph_decode_copy_safe(p, end, &addr->nonce, sizeof(addr->nonce), bad); |
|
memset(&addr->in_addr, 0, sizeof(addr->in_addr)); |
|
ceph_decode_copy_safe(p, end, &addr->in_addr, |
|
sizeof(addr->in_addr), bad); |
|
addr->in_addr.ss_family = |
|
be16_to_cpu((__force __be16)addr->in_addr.ss_family); |
|
ret = 0; |
|
bad: |
|
return ret; |
|
} |
|
|
|
int |
|
ceph_decode_entity_addr(void **p, void *end, struct ceph_entity_addr *addr) |
|
{ |
|
u8 marker; |
|
|
|
ceph_decode_8_safe(p, end, marker, bad); |
|
if (marker == 1) |
|
return ceph_decode_entity_addr_versioned(p, end, addr); |
|
else if (marker == 0) |
|
return ceph_decode_entity_addr_legacy(p, end, addr); |
|
bad: |
|
return -EINVAL; |
|
} |
|
EXPORT_SYMBOL(ceph_decode_entity_addr); |
|
|
|
/* |
|
* Return addr of desired type (MSGR2 or LEGACY) or error. |
|
* Make sure there is only one match. |
|
* |
|
* Assume encoding with MSG_ADDR2. |
|
*/ |
|
int ceph_decode_entity_addrvec(void **p, void *end, bool msgr2, |
|
struct ceph_entity_addr *addr) |
|
{ |
|
__le32 my_type = msgr2 ? CEPH_ENTITY_ADDR_TYPE_MSGR2 : |
|
CEPH_ENTITY_ADDR_TYPE_LEGACY; |
|
struct ceph_entity_addr tmp_addr; |
|
int addr_cnt; |
|
bool found; |
|
u8 marker; |
|
int ret; |
|
int i; |
|
|
|
ceph_decode_8_safe(p, end, marker, e_inval); |
|
if (marker != 2) { |
|
pr_err("bad addrvec marker %d\n", marker); |
|
return -EINVAL; |
|
} |
|
|
|
ceph_decode_32_safe(p, end, addr_cnt, e_inval); |
|
dout("%s addr_cnt %d\n", __func__, addr_cnt); |
|
|
|
found = false; |
|
for (i = 0; i < addr_cnt; i++) { |
|
ret = ceph_decode_entity_addr(p, end, &tmp_addr); |
|
if (ret) |
|
return ret; |
|
|
|
dout("%s i %d addr %s\n", __func__, i, ceph_pr_addr(&tmp_addr)); |
|
if (tmp_addr.type == my_type) { |
|
if (found) { |
|
pr_err("another match of type %d in addrvec\n", |
|
le32_to_cpu(my_type)); |
|
return -EINVAL; |
|
} |
|
|
|
memcpy(addr, &tmp_addr, sizeof(*addr)); |
|
found = true; |
|
} |
|
} |
|
|
|
if (found) |
|
return 0; |
|
|
|
if (!addr_cnt) |
|
return 0; /* normal -- e.g. unused OSD id/slot */ |
|
|
|
if (addr_cnt == 1 && !memchr_inv(&tmp_addr, 0, sizeof(tmp_addr))) |
|
return 0; /* weird but effectively the same as !addr_cnt */ |
|
|
|
pr_err("no match of type %d in addrvec\n", le32_to_cpu(my_type)); |
|
return -ENOENT; |
|
|
|
e_inval: |
|
return -EINVAL; |
|
} |
|
EXPORT_SYMBOL(ceph_decode_entity_addrvec); |
|
|
|
static int get_sockaddr_encoding_len(sa_family_t family) |
|
{ |
|
union { |
|
struct sockaddr sa; |
|
struct sockaddr_in sin; |
|
struct sockaddr_in6 sin6; |
|
} u; |
|
|
|
switch (family) { |
|
case AF_INET: |
|
return sizeof(u.sin); |
|
case AF_INET6: |
|
return sizeof(u.sin6); |
|
default: |
|
return sizeof(u); |
|
} |
|
} |
|
|
|
int ceph_entity_addr_encoding_len(const struct ceph_entity_addr *addr) |
|
{ |
|
sa_family_t family = get_unaligned(&addr->in_addr.ss_family); |
|
int addr_len = get_sockaddr_encoding_len(family); |
|
|
|
return 1 + CEPH_ENCODING_START_BLK_LEN + 4 + 4 + 4 + addr_len; |
|
} |
|
|
|
void ceph_encode_entity_addr(void **p, const struct ceph_entity_addr *addr) |
|
{ |
|
sa_family_t family = get_unaligned(&addr->in_addr.ss_family); |
|
int addr_len = get_sockaddr_encoding_len(family); |
|
|
|
ceph_encode_8(p, 1); /* marker */ |
|
ceph_start_encoding(p, 1, 1, sizeof(addr->type) + |
|
sizeof(addr->nonce) + |
|
sizeof(u32) + addr_len); |
|
ceph_encode_copy(p, &addr->type, sizeof(addr->type)); |
|
ceph_encode_copy(p, &addr->nonce, sizeof(addr->nonce)); |
|
|
|
ceph_encode_32(p, addr_len); |
|
ceph_encode_16(p, family); |
|
ceph_encode_copy(p, addr->in_addr.__data, addr_len - sizeof(family)); |
|
}
|
|
|