// 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 intceph_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 intceph_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;} intceph_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));}