Loading...
Note: File does not exist in v5.4.
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * XFRM compat layer
4 * Author: Dmitry Safonov <dima@arista.com>
5 * Based on code and translator idea by: Florian Westphal <fw@strlen.de>
6 */
7#include <linux/compat.h>
8#include <linux/nospec.h>
9#include <linux/xfrm.h>
10#include <net/xfrm.h>
11
12struct compat_xfrm_lifetime_cfg {
13 compat_u64 soft_byte_limit, hard_byte_limit;
14 compat_u64 soft_packet_limit, hard_packet_limit;
15 compat_u64 soft_add_expires_seconds, hard_add_expires_seconds;
16 compat_u64 soft_use_expires_seconds, hard_use_expires_seconds;
17}; /* same size on 32bit, but only 4 byte alignment required */
18
19struct compat_xfrm_lifetime_cur {
20 compat_u64 bytes, packets, add_time, use_time;
21}; /* same size on 32bit, but only 4 byte alignment required */
22
23struct compat_xfrm_userpolicy_info {
24 struct xfrm_selector sel;
25 struct compat_xfrm_lifetime_cfg lft;
26 struct compat_xfrm_lifetime_cur curlft;
27 __u32 priority, index;
28 u8 dir, action, flags, share;
29 /* 4 bytes additional padding on 64bit */
30};
31
32struct compat_xfrm_usersa_info {
33 struct xfrm_selector sel;
34 struct xfrm_id id;
35 xfrm_address_t saddr;
36 struct compat_xfrm_lifetime_cfg lft;
37 struct compat_xfrm_lifetime_cur curlft;
38 struct xfrm_stats stats;
39 __u32 seq, reqid;
40 u16 family;
41 u8 mode, replay_window, flags;
42 /* 4 bytes additional padding on 64bit */
43};
44
45struct compat_xfrm_user_acquire {
46 struct xfrm_id id;
47 xfrm_address_t saddr;
48 struct xfrm_selector sel;
49 struct compat_xfrm_userpolicy_info policy;
50 /* 4 bytes additional padding on 64bit */
51 __u32 aalgos, ealgos, calgos, seq;
52};
53
54struct compat_xfrm_userspi_info {
55 struct compat_xfrm_usersa_info info;
56 /* 4 bytes additional padding on 64bit */
57 __u32 min, max;
58};
59
60struct compat_xfrm_user_expire {
61 struct compat_xfrm_usersa_info state;
62 /* 8 bytes additional padding on 64bit */
63 u8 hard;
64};
65
66struct compat_xfrm_user_polexpire {
67 struct compat_xfrm_userpolicy_info pol;
68 /* 8 bytes additional padding on 64bit */
69 u8 hard;
70};
71
72#define XMSGSIZE(type) sizeof(struct type)
73
74static const int compat_msg_min[XFRM_NR_MSGTYPES] = {
75 [XFRM_MSG_NEWSA - XFRM_MSG_BASE] = XMSGSIZE(compat_xfrm_usersa_info),
76 [XFRM_MSG_DELSA - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_id),
77 [XFRM_MSG_GETSA - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_id),
78 [XFRM_MSG_NEWPOLICY - XFRM_MSG_BASE] = XMSGSIZE(compat_xfrm_userpolicy_info),
79 [XFRM_MSG_DELPOLICY - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
80 [XFRM_MSG_GETPOLICY - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
81 [XFRM_MSG_ALLOCSPI - XFRM_MSG_BASE] = XMSGSIZE(compat_xfrm_userspi_info),
82 [XFRM_MSG_ACQUIRE - XFRM_MSG_BASE] = XMSGSIZE(compat_xfrm_user_acquire),
83 [XFRM_MSG_EXPIRE - XFRM_MSG_BASE] = XMSGSIZE(compat_xfrm_user_expire),
84 [XFRM_MSG_UPDPOLICY - XFRM_MSG_BASE] = XMSGSIZE(compat_xfrm_userpolicy_info),
85 [XFRM_MSG_UPDSA - XFRM_MSG_BASE] = XMSGSIZE(compat_xfrm_usersa_info),
86 [XFRM_MSG_POLEXPIRE - XFRM_MSG_BASE] = XMSGSIZE(compat_xfrm_user_polexpire),
87 [XFRM_MSG_FLUSHSA - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_flush),
88 [XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = 0,
89 [XFRM_MSG_NEWAE - XFRM_MSG_BASE] = XMSGSIZE(xfrm_aevent_id),
90 [XFRM_MSG_GETAE - XFRM_MSG_BASE] = XMSGSIZE(xfrm_aevent_id),
91 [XFRM_MSG_REPORT - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_report),
92 [XFRM_MSG_MIGRATE - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
93 [XFRM_MSG_NEWSADINFO - XFRM_MSG_BASE] = sizeof(u32),
94 [XFRM_MSG_GETSADINFO - XFRM_MSG_BASE] = sizeof(u32),
95 [XFRM_MSG_NEWSPDINFO - XFRM_MSG_BASE] = sizeof(u32),
96 [XFRM_MSG_GETSPDINFO - XFRM_MSG_BASE] = sizeof(u32),
97 [XFRM_MSG_MAPPING - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_mapping)
98};
99
100static const struct nla_policy compat_policy[XFRMA_MAX+1] = {
101 [XFRMA_UNSPEC] = { .strict_start_type = XFRMA_SA_DIR },
102 [XFRMA_SA] = { .len = XMSGSIZE(compat_xfrm_usersa_info)},
103 [XFRMA_POLICY] = { .len = XMSGSIZE(compat_xfrm_userpolicy_info)},
104 [XFRMA_LASTUSED] = { .type = NLA_U64},
105 [XFRMA_ALG_AUTH_TRUNC] = { .len = sizeof(struct xfrm_algo_auth)},
106 [XFRMA_ALG_AEAD] = { .len = sizeof(struct xfrm_algo_aead) },
107 [XFRMA_ALG_AUTH] = { .len = sizeof(struct xfrm_algo) },
108 [XFRMA_ALG_CRYPT] = { .len = sizeof(struct xfrm_algo) },
109 [XFRMA_ALG_COMP] = { .len = sizeof(struct xfrm_algo) },
110 [XFRMA_ENCAP] = { .len = sizeof(struct xfrm_encap_tmpl) },
111 [XFRMA_TMPL] = { .len = sizeof(struct xfrm_user_tmpl) },
112 [XFRMA_SEC_CTX] = { .len = sizeof(struct xfrm_user_sec_ctx) },
113 [XFRMA_LTIME_VAL] = { .len = sizeof(struct xfrm_lifetime_cur) },
114 [XFRMA_REPLAY_VAL] = { .len = sizeof(struct xfrm_replay_state) },
115 [XFRMA_REPLAY_THRESH] = { .type = NLA_U32 },
116 [XFRMA_ETIMER_THRESH] = { .type = NLA_U32 },
117 [XFRMA_SRCADDR] = { .len = sizeof(xfrm_address_t) },
118 [XFRMA_COADDR] = { .len = sizeof(xfrm_address_t) },
119 [XFRMA_POLICY_TYPE] = { .len = sizeof(struct xfrm_userpolicy_type)},
120 [XFRMA_MIGRATE] = { .len = sizeof(struct xfrm_user_migrate) },
121 [XFRMA_KMADDRESS] = { .len = sizeof(struct xfrm_user_kmaddress) },
122 [XFRMA_MARK] = { .len = sizeof(struct xfrm_mark) },
123 [XFRMA_TFCPAD] = { .type = NLA_U32 },
124 [XFRMA_REPLAY_ESN_VAL] = { .len = sizeof(struct xfrm_replay_state_esn) },
125 [XFRMA_SA_EXTRA_FLAGS] = { .type = NLA_U32 },
126 [XFRMA_PROTO] = { .type = NLA_U8 },
127 [XFRMA_ADDRESS_FILTER] = { .len = sizeof(struct xfrm_address_filter) },
128 [XFRMA_OFFLOAD_DEV] = { .len = sizeof(struct xfrm_user_offload) },
129 [XFRMA_SET_MARK] = { .type = NLA_U32 },
130 [XFRMA_SET_MARK_MASK] = { .type = NLA_U32 },
131 [XFRMA_IF_ID] = { .type = NLA_U32 },
132 [XFRMA_MTIMER_THRESH] = { .type = NLA_U32 },
133 [XFRMA_SA_DIR] = NLA_POLICY_RANGE(NLA_U8, XFRM_SA_DIR_IN, XFRM_SA_DIR_OUT),
134 [XFRMA_NAT_KEEPALIVE_INTERVAL] = { .type = NLA_U32 },
135 [XFRMA_SA_PCPU] = { .type = NLA_U32 },
136};
137
138static struct nlmsghdr *xfrm_nlmsg_put_compat(struct sk_buff *skb,
139 const struct nlmsghdr *nlh_src, u16 type)
140{
141 int payload = compat_msg_min[type];
142 int src_len = xfrm_msg_min[type];
143 struct nlmsghdr *nlh_dst;
144
145 /* Compat messages are shorter or equal to native (+padding) */
146 if (WARN_ON_ONCE(src_len < payload))
147 return ERR_PTR(-EMSGSIZE);
148
149 nlh_dst = nlmsg_put(skb, nlh_src->nlmsg_pid, nlh_src->nlmsg_seq,
150 nlh_src->nlmsg_type, payload, nlh_src->nlmsg_flags);
151 if (!nlh_dst)
152 return ERR_PTR(-EMSGSIZE);
153
154 memset(nlmsg_data(nlh_dst), 0, payload);
155
156 switch (nlh_src->nlmsg_type) {
157 /* Compat message has the same layout as native */
158 case XFRM_MSG_DELSA:
159 case XFRM_MSG_DELPOLICY:
160 case XFRM_MSG_FLUSHSA:
161 case XFRM_MSG_FLUSHPOLICY:
162 case XFRM_MSG_NEWAE:
163 case XFRM_MSG_REPORT:
164 case XFRM_MSG_MIGRATE:
165 case XFRM_MSG_NEWSADINFO:
166 case XFRM_MSG_NEWSPDINFO:
167 case XFRM_MSG_MAPPING:
168 WARN_ON_ONCE(src_len != payload);
169 memcpy(nlmsg_data(nlh_dst), nlmsg_data(nlh_src), src_len);
170 break;
171 /* 4 byte alignment for trailing u64 on native, but not on compat */
172 case XFRM_MSG_NEWSA:
173 case XFRM_MSG_NEWPOLICY:
174 case XFRM_MSG_UPDSA:
175 case XFRM_MSG_UPDPOLICY:
176 WARN_ON_ONCE(src_len != payload + 4);
177 memcpy(nlmsg_data(nlh_dst), nlmsg_data(nlh_src), payload);
178 break;
179 case XFRM_MSG_EXPIRE: {
180 const struct xfrm_user_expire *src_ue = nlmsg_data(nlh_src);
181 struct compat_xfrm_user_expire *dst_ue = nlmsg_data(nlh_dst);
182
183 /* compat_xfrm_user_expire has 4-byte smaller state */
184 memcpy(dst_ue, src_ue, sizeof(dst_ue->state));
185 dst_ue->hard = src_ue->hard;
186 break;
187 }
188 case XFRM_MSG_ACQUIRE: {
189 const struct xfrm_user_acquire *src_ua = nlmsg_data(nlh_src);
190 struct compat_xfrm_user_acquire *dst_ua = nlmsg_data(nlh_dst);
191
192 memcpy(dst_ua, src_ua, offsetof(struct compat_xfrm_user_acquire, aalgos));
193 dst_ua->aalgos = src_ua->aalgos;
194 dst_ua->ealgos = src_ua->ealgos;
195 dst_ua->calgos = src_ua->calgos;
196 dst_ua->seq = src_ua->seq;
197 break;
198 }
199 case XFRM_MSG_POLEXPIRE: {
200 const struct xfrm_user_polexpire *src_upe = nlmsg_data(nlh_src);
201 struct compat_xfrm_user_polexpire *dst_upe = nlmsg_data(nlh_dst);
202
203 /* compat_xfrm_user_polexpire has 4-byte smaller state */
204 memcpy(dst_upe, src_upe, sizeof(dst_upe->pol));
205 dst_upe->hard = src_upe->hard;
206 break;
207 }
208 case XFRM_MSG_ALLOCSPI: {
209 const struct xfrm_userspi_info *src_usi = nlmsg_data(nlh_src);
210 struct compat_xfrm_userspi_info *dst_usi = nlmsg_data(nlh_dst);
211
212 /* compat_xfrm_user_polexpire has 4-byte smaller state */
213 memcpy(dst_usi, src_usi, sizeof(src_usi->info));
214 dst_usi->min = src_usi->min;
215 dst_usi->max = src_usi->max;
216 break;
217 }
218 /* Not being sent by kernel */
219 case XFRM_MSG_GETSA:
220 case XFRM_MSG_GETPOLICY:
221 case XFRM_MSG_GETAE:
222 case XFRM_MSG_GETSADINFO:
223 case XFRM_MSG_GETSPDINFO:
224 default:
225 pr_warn_once("unsupported nlmsg_type %d\n", nlh_src->nlmsg_type);
226 return ERR_PTR(-EOPNOTSUPP);
227 }
228
229 return nlh_dst;
230}
231
232static int xfrm_nla_cpy(struct sk_buff *dst, const struct nlattr *src, int len)
233{
234 return nla_put(dst, src->nla_type, len, nla_data(src));
235}
236
237static int xfrm_xlate64_attr(struct sk_buff *dst, const struct nlattr *src)
238{
239 switch (src->nla_type) {
240 case XFRMA_PAD:
241 /* Ignore */
242 return 0;
243 case XFRMA_UNSPEC:
244 case XFRMA_ALG_AUTH:
245 case XFRMA_ALG_CRYPT:
246 case XFRMA_ALG_COMP:
247 case XFRMA_ENCAP:
248 case XFRMA_TMPL:
249 return xfrm_nla_cpy(dst, src, nla_len(src));
250 case XFRMA_SA:
251 return xfrm_nla_cpy(dst, src, XMSGSIZE(compat_xfrm_usersa_info));
252 case XFRMA_POLICY:
253 return xfrm_nla_cpy(dst, src, XMSGSIZE(compat_xfrm_userpolicy_info));
254 case XFRMA_SEC_CTX:
255 return xfrm_nla_cpy(dst, src, nla_len(src));
256 case XFRMA_LTIME_VAL:
257 return nla_put_64bit(dst, src->nla_type, nla_len(src),
258 nla_data(src), XFRMA_PAD);
259 case XFRMA_REPLAY_VAL:
260 case XFRMA_REPLAY_THRESH:
261 case XFRMA_ETIMER_THRESH:
262 case XFRMA_SRCADDR:
263 case XFRMA_COADDR:
264 return xfrm_nla_cpy(dst, src, nla_len(src));
265 case XFRMA_LASTUSED:
266 return nla_put_64bit(dst, src->nla_type, nla_len(src),
267 nla_data(src), XFRMA_PAD);
268 case XFRMA_POLICY_TYPE:
269 case XFRMA_MIGRATE:
270 case XFRMA_ALG_AEAD:
271 case XFRMA_KMADDRESS:
272 case XFRMA_ALG_AUTH_TRUNC:
273 case XFRMA_MARK:
274 case XFRMA_TFCPAD:
275 case XFRMA_REPLAY_ESN_VAL:
276 case XFRMA_SA_EXTRA_FLAGS:
277 case XFRMA_PROTO:
278 case XFRMA_ADDRESS_FILTER:
279 case XFRMA_OFFLOAD_DEV:
280 case XFRMA_SET_MARK:
281 case XFRMA_SET_MARK_MASK:
282 case XFRMA_IF_ID:
283 case XFRMA_MTIMER_THRESH:
284 case XFRMA_SA_DIR:
285 case XFRMA_NAT_KEEPALIVE_INTERVAL:
286 case XFRMA_SA_PCPU:
287 return xfrm_nla_cpy(dst, src, nla_len(src));
288 default:
289 BUILD_BUG_ON(XFRMA_MAX != XFRMA_SA_PCPU);
290 pr_warn_once("unsupported nla_type %d\n", src->nla_type);
291 return -EOPNOTSUPP;
292 }
293}
294
295/* Take kernel-built (64bit layout) and create 32bit layout for userspace */
296static int xfrm_xlate64(struct sk_buff *dst, const struct nlmsghdr *nlh_src)
297{
298 u16 type = nlh_src->nlmsg_type - XFRM_MSG_BASE;
299 const struct nlattr *nla, *attrs;
300 struct nlmsghdr *nlh_dst;
301 int len, remaining;
302
303 nlh_dst = xfrm_nlmsg_put_compat(dst, nlh_src, type);
304 if (IS_ERR(nlh_dst))
305 return PTR_ERR(nlh_dst);
306
307 attrs = nlmsg_attrdata(nlh_src, xfrm_msg_min[type]);
308 len = nlmsg_attrlen(nlh_src, xfrm_msg_min[type]);
309
310 nla_for_each_attr(nla, attrs, len, remaining) {
311 int err;
312
313 switch (nlh_src->nlmsg_type) {
314 case XFRM_MSG_NEWSPDINFO:
315 err = xfrm_nla_cpy(dst, nla, nla_len(nla));
316 break;
317 default:
318 err = xfrm_xlate64_attr(dst, nla);
319 break;
320 }
321 if (err)
322 return err;
323 }
324
325 nlmsg_end(dst, nlh_dst);
326
327 return 0;
328}
329
330static int xfrm_alloc_compat(struct sk_buff *skb, const struct nlmsghdr *nlh_src)
331{
332 u16 type = nlh_src->nlmsg_type - XFRM_MSG_BASE;
333 struct sk_buff *new = NULL;
334 int err;
335
336 if (type >= ARRAY_SIZE(xfrm_msg_min)) {
337 pr_warn_once("unsupported nlmsg_type %d\n", nlh_src->nlmsg_type);
338 return -EOPNOTSUPP;
339 }
340
341 if (skb_shinfo(skb)->frag_list == NULL) {
342 new = alloc_skb(skb->len + skb_tailroom(skb), GFP_ATOMIC);
343 if (!new)
344 return -ENOMEM;
345 skb_shinfo(skb)->frag_list = new;
346 }
347
348 err = xfrm_xlate64(skb_shinfo(skb)->frag_list, nlh_src);
349 if (err) {
350 if (new) {
351 kfree_skb(new);
352 skb_shinfo(skb)->frag_list = NULL;
353 }
354 return err;
355 }
356
357 return 0;
358}
359
360/* Calculates len of translated 64-bit message. */
361static size_t xfrm_user_rcv_calculate_len64(const struct nlmsghdr *src,
362 struct nlattr *attrs[XFRMA_MAX + 1],
363 int maxtype)
364{
365 size_t len = nlmsg_len(src);
366
367 switch (src->nlmsg_type) {
368 case XFRM_MSG_NEWSA:
369 case XFRM_MSG_NEWPOLICY:
370 case XFRM_MSG_ALLOCSPI:
371 case XFRM_MSG_ACQUIRE:
372 case XFRM_MSG_UPDPOLICY:
373 case XFRM_MSG_UPDSA:
374 len += 4;
375 break;
376 case XFRM_MSG_EXPIRE:
377 case XFRM_MSG_POLEXPIRE:
378 len += 8;
379 break;
380 case XFRM_MSG_NEWSPDINFO:
381 /* attirbutes are xfrm_spdattr_type_t, not xfrm_attr_type_t */
382 return len;
383 default:
384 break;
385 }
386
387 /* Unexpected for anything, but XFRM_MSG_NEWSPDINFO, please
388 * correct both 64=>32-bit and 32=>64-bit translators to copy
389 * new attributes.
390 */
391 if (WARN_ON_ONCE(maxtype))
392 return len;
393
394 if (attrs[XFRMA_SA])
395 len += 4;
396 if (attrs[XFRMA_POLICY])
397 len += 4;
398
399 /* XXX: some attrs may need to be realigned
400 * if !CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
401 */
402
403 return len;
404}
405
406static int xfrm_attr_cpy32(void *dst, size_t *pos, const struct nlattr *src,
407 size_t size, int copy_len, int payload)
408{
409 struct nlmsghdr *nlmsg = dst;
410 struct nlattr *nla;
411
412 /* xfrm_user_rcv_msg_compat() relies on fact that 32-bit messages
413 * have the same len or shorted than 64-bit ones.
414 * 32-bit translation that is bigger than 64-bit original is unexpected.
415 */
416 if (WARN_ON_ONCE(copy_len > payload))
417 copy_len = payload;
418
419 if (size - *pos < nla_attr_size(payload))
420 return -ENOBUFS;
421
422 nla = dst + *pos;
423
424 memcpy(nla, src, nla_attr_size(copy_len));
425 nla->nla_len = nla_attr_size(payload);
426 *pos += nla_attr_size(copy_len);
427 nlmsg->nlmsg_len += nla->nla_len;
428
429 memset(dst + *pos, 0, payload - copy_len);
430 *pos += payload - copy_len;
431
432 return 0;
433}
434
435static int xfrm_xlate32_attr(void *dst, const struct nlattr *nla,
436 size_t *pos, size_t size,
437 struct netlink_ext_ack *extack)
438{
439 int type = nla_type(nla);
440 u16 pol_len32, pol_len64;
441 int err;
442
443 if (type > XFRMA_MAX) {
444 BUILD_BUG_ON(XFRMA_MAX != XFRMA_SA_PCPU);
445 NL_SET_ERR_MSG(extack, "Bad attribute");
446 return -EOPNOTSUPP;
447 }
448 type = array_index_nospec(type, XFRMA_MAX + 1);
449 if (nla_len(nla) < compat_policy[type].len) {
450 NL_SET_ERR_MSG(extack, "Attribute bad length");
451 return -EOPNOTSUPP;
452 }
453
454 pol_len32 = compat_policy[type].len;
455 pol_len64 = xfrma_policy[type].len;
456
457 /* XFRMA_SA and XFRMA_POLICY - need to know how-to translate */
458 if (pol_len32 != pol_len64) {
459 if (nla_len(nla) != compat_policy[type].len) {
460 NL_SET_ERR_MSG(extack, "Attribute bad length");
461 return -EOPNOTSUPP;
462 }
463 err = xfrm_attr_cpy32(dst, pos, nla, size, pol_len32, pol_len64);
464 if (err)
465 return err;
466 }
467
468 return xfrm_attr_cpy32(dst, pos, nla, size, nla_len(nla), nla_len(nla));
469}
470
471static int xfrm_xlate32(struct nlmsghdr *dst, const struct nlmsghdr *src,
472 struct nlattr *attrs[XFRMA_MAX+1],
473 size_t size, u8 type, int maxtype,
474 struct netlink_ext_ack *extack)
475{
476 size_t pos;
477 int i;
478
479 memcpy(dst, src, NLMSG_HDRLEN);
480 dst->nlmsg_len = NLMSG_HDRLEN + xfrm_msg_min[type];
481 memset(nlmsg_data(dst), 0, xfrm_msg_min[type]);
482
483 switch (src->nlmsg_type) {
484 /* Compat message has the same layout as native */
485 case XFRM_MSG_DELSA:
486 case XFRM_MSG_GETSA:
487 case XFRM_MSG_DELPOLICY:
488 case XFRM_MSG_GETPOLICY:
489 case XFRM_MSG_FLUSHSA:
490 case XFRM_MSG_FLUSHPOLICY:
491 case XFRM_MSG_NEWAE:
492 case XFRM_MSG_GETAE:
493 case XFRM_MSG_REPORT:
494 case XFRM_MSG_MIGRATE:
495 case XFRM_MSG_NEWSADINFO:
496 case XFRM_MSG_GETSADINFO:
497 case XFRM_MSG_NEWSPDINFO:
498 case XFRM_MSG_GETSPDINFO:
499 case XFRM_MSG_MAPPING:
500 memcpy(nlmsg_data(dst), nlmsg_data(src), compat_msg_min[type]);
501 break;
502 /* 4 byte alignment for trailing u64 on native, but not on compat */
503 case XFRM_MSG_NEWSA:
504 case XFRM_MSG_NEWPOLICY:
505 case XFRM_MSG_UPDSA:
506 case XFRM_MSG_UPDPOLICY:
507 memcpy(nlmsg_data(dst), nlmsg_data(src), compat_msg_min[type]);
508 break;
509 case XFRM_MSG_EXPIRE: {
510 const struct compat_xfrm_user_expire *src_ue = nlmsg_data(src);
511 struct xfrm_user_expire *dst_ue = nlmsg_data(dst);
512
513 /* compat_xfrm_user_expire has 4-byte smaller state */
514 memcpy(dst_ue, src_ue, sizeof(src_ue->state));
515 dst_ue->hard = src_ue->hard;
516 break;
517 }
518 case XFRM_MSG_ACQUIRE: {
519 const struct compat_xfrm_user_acquire *src_ua = nlmsg_data(src);
520 struct xfrm_user_acquire *dst_ua = nlmsg_data(dst);
521
522 memcpy(dst_ua, src_ua, offsetof(struct compat_xfrm_user_acquire, aalgos));
523 dst_ua->aalgos = src_ua->aalgos;
524 dst_ua->ealgos = src_ua->ealgos;
525 dst_ua->calgos = src_ua->calgos;
526 dst_ua->seq = src_ua->seq;
527 break;
528 }
529 case XFRM_MSG_POLEXPIRE: {
530 const struct compat_xfrm_user_polexpire *src_upe = nlmsg_data(src);
531 struct xfrm_user_polexpire *dst_upe = nlmsg_data(dst);
532
533 /* compat_xfrm_user_polexpire has 4-byte smaller state */
534 memcpy(dst_upe, src_upe, sizeof(src_upe->pol));
535 dst_upe->hard = src_upe->hard;
536 break;
537 }
538 case XFRM_MSG_ALLOCSPI: {
539 const struct compat_xfrm_userspi_info *src_usi = nlmsg_data(src);
540 struct xfrm_userspi_info *dst_usi = nlmsg_data(dst);
541
542 /* compat_xfrm_user_polexpire has 4-byte smaller state */
543 memcpy(dst_usi, src_usi, sizeof(src_usi->info));
544 dst_usi->min = src_usi->min;
545 dst_usi->max = src_usi->max;
546 break;
547 }
548 default:
549 NL_SET_ERR_MSG(extack, "Unsupported message type");
550 return -EOPNOTSUPP;
551 }
552 pos = dst->nlmsg_len;
553
554 if (maxtype) {
555 /* attirbutes are xfrm_spdattr_type_t, not xfrm_attr_type_t */
556 WARN_ON_ONCE(src->nlmsg_type != XFRM_MSG_NEWSPDINFO);
557
558 for (i = 1; i <= maxtype; i++) {
559 int err;
560
561 if (!attrs[i])
562 continue;
563
564 /* just copy - no need for translation */
565 err = xfrm_attr_cpy32(dst, &pos, attrs[i], size,
566 nla_len(attrs[i]), nla_len(attrs[i]));
567 if (err)
568 return err;
569 }
570 return 0;
571 }
572
573 for (i = 1; i < XFRMA_MAX + 1; i++) {
574 int err;
575
576 if (i == XFRMA_PAD)
577 continue;
578
579 if (!attrs[i])
580 continue;
581
582 err = xfrm_xlate32_attr(dst, attrs[i], &pos, size, extack);
583 if (err)
584 return err;
585 }
586
587 return 0;
588}
589
590static struct nlmsghdr *xfrm_user_rcv_msg_compat(const struct nlmsghdr *h32,
591 int maxtype, const struct nla_policy *policy,
592 struct netlink_ext_ack *extack)
593{
594 /* netlink_rcv_skb() checks if a message has full (struct nlmsghdr) */
595 u16 type = h32->nlmsg_type - XFRM_MSG_BASE;
596 struct nlattr *attrs[XFRMA_MAX+1];
597 struct nlmsghdr *h64;
598 size_t len;
599 int err;
600
601 BUILD_BUG_ON(ARRAY_SIZE(xfrm_msg_min) != ARRAY_SIZE(compat_msg_min));
602
603 if (type >= ARRAY_SIZE(xfrm_msg_min))
604 return ERR_PTR(-EINVAL);
605
606 /* Don't call parse: the message might have only nlmsg header */
607 if ((h32->nlmsg_type == XFRM_MSG_GETSA ||
608 h32->nlmsg_type == XFRM_MSG_GETPOLICY) &&
609 (h32->nlmsg_flags & NLM_F_DUMP))
610 return NULL;
611
612 err = nlmsg_parse_deprecated(h32, compat_msg_min[type], attrs,
613 maxtype ? : XFRMA_MAX, policy ? : compat_policy, extack);
614 if (err < 0)
615 return ERR_PTR(err);
616
617 len = xfrm_user_rcv_calculate_len64(h32, attrs, maxtype);
618 /* The message doesn't need translation */
619 if (len == nlmsg_len(h32))
620 return NULL;
621
622 len += NLMSG_HDRLEN;
623 h64 = kvmalloc(len, GFP_KERNEL);
624 if (!h64)
625 return ERR_PTR(-ENOMEM);
626
627 err = xfrm_xlate32(h64, h32, attrs, len, type, maxtype, extack);
628 if (err < 0) {
629 kvfree(h64);
630 return ERR_PTR(err);
631 }
632
633 return h64;
634}
635
636static int xfrm_user_policy_compat(u8 **pdata32, int optlen)
637{
638 struct compat_xfrm_userpolicy_info *p = (void *)*pdata32;
639 u8 *src_templates, *dst_templates;
640 u8 *data64;
641
642 if (optlen < sizeof(*p))
643 return -EINVAL;
644
645 data64 = kmalloc_track_caller(optlen + 4, GFP_USER | __GFP_NOWARN);
646 if (!data64)
647 return -ENOMEM;
648
649 memcpy(data64, *pdata32, sizeof(*p));
650 memset(data64 + sizeof(*p), 0, 4);
651
652 src_templates = *pdata32 + sizeof(*p);
653 dst_templates = data64 + sizeof(*p) + 4;
654 memcpy(dst_templates, src_templates, optlen - sizeof(*p));
655
656 kfree(*pdata32);
657 *pdata32 = data64;
658 return 0;
659}
660
661static struct xfrm_translator xfrm_translator = {
662 .owner = THIS_MODULE,
663 .alloc_compat = xfrm_alloc_compat,
664 .rcv_msg_compat = xfrm_user_rcv_msg_compat,
665 .xlate_user_policy_sockptr = xfrm_user_policy_compat,
666};
667
668static int __init xfrm_compat_init(void)
669{
670 return xfrm_register_translator(&xfrm_translator);
671}
672
673static void __exit xfrm_compat_exit(void)
674{
675 xfrm_unregister_translator(&xfrm_translator);
676}
677
678module_init(xfrm_compat_init);
679module_exit(xfrm_compat_exit);
680MODULE_LICENSE("GPL");
681MODULE_AUTHOR("Dmitry Safonov");
682MODULE_DESCRIPTION("XFRM 32-bit compatibility layer");