Commit 6878eb59 authored by Jakub Kicinski's avatar Jakub Kicinski
Browse files

Merge branch 'tools-ynl-generate-code-for-the-handshake-family' 

Jakub Kicinski says:

====================
tools: ynl: generate code for the handshake family

Add necessary features and generate user space C code for serializing
/ deserializing messages of the handshake family.

In addition to basics already present in netdev and fou, handshake
has nested attrs and multi-attr u32.
====================

Link: https://lore.kernel.org/r/20230606194302.919343-1-kuba@kernel.org


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parents e7214663 7a11f70c

tools/net/ynl/generated/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ endif 


TOOL:=../ynl-gen-c.py



GENS:=fou netdev

GENS:=handshake fou netdev

SRCS=$(patsubst %,%-user.c,${GENS})

HDRS=$(patsubst %,%-user.h,${GENS})

OBJS=$(patsubst %,%-user.o,${GENS})

tools/net/ynl/generated/handshake-user.c

0 → 100644
+385 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)

/* Do not edit directly, auto-generated from: */

/*	Documentation/netlink/specs/handshake.yaml */

/* YNL-GEN user source */



#include <stdlib.h>

#include "handshake-user.h"

#include "ynl.h"

#include <linux/handshake.h>



#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <libmnl/libmnl.h>

#include <linux/genetlink.h>



/* Enums */

static const char * const handshake_op_strmap[] = {

	[HANDSHAKE_CMD_READY] = "ready",

	[HANDSHAKE_CMD_ACCEPT] = "accept",

	[HANDSHAKE_CMD_DONE] = "done",

};



const char *handshake_op_str(int op)

{

	if (op < 0 || op >= (int)MNL_ARRAY_SIZE(handshake_op_strmap))

		return NULL;

	return handshake_op_strmap[op];

}



static const char * const handshake_handler_class_strmap[] = {

	[0] = "none",

	[1] = "tlshd",

	[2] = "max",

};



const char *handshake_handler_class_str(enum handshake_handler_class value)

{

	if (value < 0 || value >= (int)MNL_ARRAY_SIZE(handshake_handler_class_strmap))

		return NULL;

	return handshake_handler_class_strmap[value];

}



static const char * const handshake_msg_type_strmap[] = {

	[0] = "unspec",

	[1] = "clienthello",

	[2] = "serverhello",

};



const char *handshake_msg_type_str(enum handshake_msg_type value)

{

	if (value < 0 || value >= (int)MNL_ARRAY_SIZE(handshake_msg_type_strmap))

		return NULL;

	return handshake_msg_type_strmap[value];

}



static const char * const handshake_auth_strmap[] = {

	[0] = "unspec",

	[1] = "unauth",

	[2] = "psk",

	[3] = "x509",

};



const char *handshake_auth_str(enum handshake_auth value)

{

	if (value < 0 || value >= (int)MNL_ARRAY_SIZE(handshake_auth_strmap))

		return NULL;

	return handshake_auth_strmap[value];

}



/* Policies */

extern struct ynl_policy_nest handshake_x509_nest;

extern struct ynl_policy_nest handshake_accept_nest;

extern struct ynl_policy_nest handshake_done_nest;



struct ynl_policy_attr handshake_x509_policy[HANDSHAKE_A_X509_MAX + 1] = {

	[HANDSHAKE_A_X509_CERT] = { .name = "cert", .type = YNL_PT_U32, },

	[HANDSHAKE_A_X509_PRIVKEY] = { .name = "privkey", .type = YNL_PT_U32, },

};



struct ynl_policy_nest handshake_x509_nest = {

	.max_attr = HANDSHAKE_A_X509_MAX,

	.table = handshake_x509_policy,

};



struct ynl_policy_attr handshake_accept_policy[HANDSHAKE_A_ACCEPT_MAX + 1] = {

	[HANDSHAKE_A_ACCEPT_SOCKFD] = { .name = "sockfd", .type = YNL_PT_U32, },

	[HANDSHAKE_A_ACCEPT_HANDLER_CLASS] = { .name = "handler-class", .type = YNL_PT_U32, },

	[HANDSHAKE_A_ACCEPT_MESSAGE_TYPE] = { .name = "message-type", .type = YNL_PT_U32, },

	[HANDSHAKE_A_ACCEPT_TIMEOUT] = { .name = "timeout", .type = YNL_PT_U32, },

	[HANDSHAKE_A_ACCEPT_AUTH_MODE] = { .name = "auth-mode", .type = YNL_PT_U32, },

	[HANDSHAKE_A_ACCEPT_PEER_IDENTITY] = { .name = "peer-identity", .type = YNL_PT_U32, },

	[HANDSHAKE_A_ACCEPT_CERTIFICATE] = { .name = "certificate", .type = YNL_PT_NEST, .nest = &handshake_x509_nest, },

	[HANDSHAKE_A_ACCEPT_PEERNAME] = { .name = "peername", .type = YNL_PT_NUL_STR, },

};



struct ynl_policy_nest handshake_accept_nest = {

	.max_attr = HANDSHAKE_A_ACCEPT_MAX,

	.table = handshake_accept_policy,

};



struct ynl_policy_attr handshake_done_policy[HANDSHAKE_A_DONE_MAX + 1] = {

	[HANDSHAKE_A_DONE_STATUS] = { .name = "status", .type = YNL_PT_U32, },

	[HANDSHAKE_A_DONE_SOCKFD] = { .name = "sockfd", .type = YNL_PT_U32, },

	[HANDSHAKE_A_DONE_REMOTE_AUTH] = { .name = "remote-auth", .type = YNL_PT_U32, },

};



struct ynl_policy_nest handshake_done_nest = {

	.max_attr = HANDSHAKE_A_DONE_MAX,

	.table = handshake_done_policy,

};



/* Common nested types */

void handshake_x509_free(struct handshake_x509 *obj)

{

}



int handshake_x509_parse(struct ynl_parse_arg *yarg,

			 const struct nlattr *nested)

{

	struct handshake_x509 *dst = yarg->data;

	const struct nlattr *attr;



	mnl_attr_for_each_nested(attr, nested) {

		if (mnl_attr_get_type(attr) == HANDSHAKE_A_X509_CERT) {

			if (ynl_attr_validate(yarg, attr))

				return MNL_CB_ERROR;

			dst->_present.cert = 1;

			dst->cert = mnl_attr_get_u32(attr);

		}

		else if (mnl_attr_get_type(attr) == HANDSHAKE_A_X509_PRIVKEY) {

			if (ynl_attr_validate(yarg, attr))

				return MNL_CB_ERROR;

			dst->_present.privkey = 1;

			dst->privkey = mnl_attr_get_u32(attr);

		}

	}



	return 0;

}



/* ============== HANDSHAKE_CMD_ACCEPT ============== */

/* HANDSHAKE_CMD_ACCEPT - do */

void handshake_accept_req_free(struct handshake_accept_req *req)

{

	free(req);

}



void handshake_accept_rsp_free(struct handshake_accept_rsp *rsp)

{

	unsigned int i;



	free(rsp->peer_identity);

	for (i = 0; i < rsp->n_certificate; i++)

		handshake_x509_free(&rsp->certificate[i]);

	free(rsp->certificate);

	free(rsp->peername);

	free(rsp);

}



int handshake_accept_rsp_parse(const struct nlmsghdr *nlh, void *data)

{

	struct ynl_parse_arg *yarg = data;

	struct handshake_accept_rsp *dst;

	unsigned int n_peer_identity = 0;

	unsigned int n_certificate = 0;

	const struct nlattr *attr;

	struct ynl_parse_arg parg;

	int i;



	dst = yarg->data;

	parg.ys = yarg->ys;



	if (dst->certificate)

		return ynl_error_parse(yarg, "attribute already present (accept.certificate)");

	if (dst->peer_identity)

		return ynl_error_parse(yarg, "attribute already present (accept.peer-identity)");



	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {

		if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_SOCKFD) {

			if (ynl_attr_validate(yarg, attr))

				return MNL_CB_ERROR;

			dst->_present.sockfd = 1;

			dst->sockfd = mnl_attr_get_u32(attr);

		}

		else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_MESSAGE_TYPE) {

			if (ynl_attr_validate(yarg, attr))

				return MNL_CB_ERROR;

			dst->_present.message_type = 1;

			dst->message_type = mnl_attr_get_u32(attr);

		}

		else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_TIMEOUT) {

			if (ynl_attr_validate(yarg, attr))

				return MNL_CB_ERROR;

			dst->_present.timeout = 1;

			dst->timeout = mnl_attr_get_u32(attr);

		}

		else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_AUTH_MODE) {

			if (ynl_attr_validate(yarg, attr))

				return MNL_CB_ERROR;

			dst->_present.auth_mode = 1;

			dst->auth_mode = mnl_attr_get_u32(attr);

		}

		else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_PEER_IDENTITY) {

			n_peer_identity++;

		}

		else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_CERTIFICATE) {

			n_certificate++;

		}

		else if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_PEERNAME) {

			unsigned int len;



			if (ynl_attr_validate(yarg, attr))

				return MNL_CB_ERROR;



			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));

			dst->_present.peername_len = len;

			dst->peername = malloc(len + 1);

			memcpy(dst->peername, mnl_attr_get_str(attr), len);

			dst->peername[len] = 0;

		}

	}



	if (n_certificate) {

		dst->certificate = calloc(n_certificate, sizeof(*dst->certificate));

		dst->n_certificate = n_certificate;

		i = 0;

		parg.rsp_policy = &handshake_x509_nest;

		mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {

			if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_CERTIFICATE) {

				parg.data = &dst->certificate[i];

				if (handshake_x509_parse(&parg, attr))

					return MNL_CB_ERROR;

				i++;

			}

		}

	}

	if (n_peer_identity) {

		dst->peer_identity = calloc(n_peer_identity, sizeof(*dst->peer_identity));

		dst->n_peer_identity = n_peer_identity;

		i = 0;

		mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {

			if (mnl_attr_get_type(attr) == HANDSHAKE_A_ACCEPT_PEER_IDENTITY) {

				dst->peer_identity[i] = mnl_attr_get_u32(attr);

				i++;

			}

		}

	}



	return MNL_CB_OK;

}



struct handshake_accept_rsp *

handshake_accept(struct ynl_sock *ys, struct handshake_accept_req *req)

{

	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };

	struct handshake_accept_rsp *rsp;

	struct nlmsghdr *nlh;

	int err;



	nlh = ynl_gemsg_start_req(ys, ys->family_id, HANDSHAKE_CMD_ACCEPT, 1);

	ys->req_policy = &handshake_accept_nest;

	yrs.yarg.rsp_policy = &handshake_accept_nest;



	if (req->_present.handler_class)

		mnl_attr_put_u32(nlh, HANDSHAKE_A_ACCEPT_HANDLER_CLASS, req->handler_class);



	rsp = calloc(1, sizeof(*rsp));

	yrs.yarg.data = rsp;

	yrs.cb = handshake_accept_rsp_parse;

	yrs.rsp_cmd = HANDSHAKE_CMD_ACCEPT;



	err = ynl_exec(ys, nlh, &yrs);

	if (err < 0)

		goto err_free;



	return rsp;



err_free:

	handshake_accept_rsp_free(rsp);

	return NULL;

}



/* HANDSHAKE_CMD_ACCEPT - notify */

void handshake_accept_ntf_free(struct handshake_accept_ntf *rsp)

{

	unsigned int i;



	free(rsp->obj.peer_identity);

	for (i = 0; i < rsp->obj.n_certificate; i++)

		handshake_x509_free(&rsp->obj.certificate[i]);

	free(rsp->obj.certificate);

	free(rsp->obj.peername);

	free(rsp);

}



/* ============== HANDSHAKE_CMD_DONE ============== */

/* HANDSHAKE_CMD_DONE - do */

void handshake_done_req_free(struct handshake_done_req *req)

{

	free(req->remote_auth);

	free(req);

}



int handshake_done(struct ynl_sock *ys, struct handshake_done_req *req)

{

	struct nlmsghdr *nlh;

	int err;



	nlh = ynl_gemsg_start_req(ys, ys->family_id, HANDSHAKE_CMD_DONE, 1);

	ys->req_policy = &handshake_done_nest;



	if (req->_present.status)

		mnl_attr_put_u32(nlh, HANDSHAKE_A_DONE_STATUS, req->status);

	if (req->_present.sockfd)

		mnl_attr_put_u32(nlh, HANDSHAKE_A_DONE_SOCKFD, req->sockfd);

	for (unsigned int i = 0; i < req->n_remote_auth; i++)

		mnl_attr_put_u32(nlh, HANDSHAKE_A_DONE_REMOTE_AUTH, req->remote_auth[i]);



	err = ynl_exec(ys, nlh, NULL);

	if (err < 0)

		return -1;



	return 0;

}



/* --------------- Common notification parsing --------------- */

struct ynl_ntf_base_type *handshake_ntf_parse(struct ynl_sock *ys)

{

	struct ynl_parse_arg yarg = { .ys = ys, };

	struct ynl_ntf_base_type *rsp;

	struct genlmsghdr *genlh;

	struct nlmsghdr *nlh;

	mnl_cb_t parse;

	int len, err;



	len = mnl_socket_recvfrom(ys->sock, ys->rx_buf, MNL_SOCKET_BUFFER_SIZE);

	if (len < (ssize_t)(sizeof(*nlh) + sizeof(*genlh)))

		return NULL;



	nlh = (struct nlmsghdr *)ys->rx_buf;

	genlh = mnl_nlmsg_get_payload(nlh);



	switch (genlh->cmd) {

	case HANDSHAKE_CMD_READY:

		rsp = calloc(1, sizeof(struct handshake_accept_ntf));

		parse = handshake_accept_rsp_parse;

		yarg.rsp_policy = &handshake_accept_nest;

		rsp->free = (void *)handshake_accept_ntf_free;

		break;

	default:

		ynl_error_unknown_notification(ys, genlh->cmd);

		return NULL;

	}



	yarg.data = rsp->data;



	err = mnl_cb_run2(ys->rx_buf, len, 0, 0, parse, &yarg,

			 ynl_cb_array, NLMSG_MIN_TYPE);

	if (err < 0)

		goto err_free;



	rsp->family = nlh->nlmsg_type;

	rsp->cmd = genlh->cmd;

	return rsp;



err_free:

	free(rsp);

	return NULL;

}



static const struct ynl_ntf_info handshake_ntf_info[] =  {

	[HANDSHAKE_CMD_READY] =  {

		.alloc_sz	= sizeof(struct handshake_accept_ntf),

		.cb		= handshake_accept_rsp_parse,

		.policy		= &handshake_accept_nest,

		.free		= (void *)handshake_accept_ntf_free,

	},

};



const struct ynl_family ynl_handshake_family =  {

	.name		= "handshake",

	.ntf_info	= handshake_ntf_info,

	.ntf_info_size	= MNL_ARRAY_SIZE(handshake_ntf_info),

};

tools/net/ynl/generated/handshake-user.h

0 → 100644
+148 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */

/* Do not edit directly, auto-generated from: */

/*	Documentation/netlink/specs/handshake.yaml */

/* YNL-GEN user header */



#ifndef _LINUX_HANDSHAKE_GEN_H

#define _LINUX_HANDSHAKE_GEN_H



#include <stdlib.h>

#include <string.h>

#include <linux/types.h>

#include <linux/handshake.h>



struct ynl_sock;



extern const struct ynl_family ynl_handshake_family;



/* Enums */

const char *handshake_op_str(int op);

const char *handshake_handler_class_str(enum handshake_handler_class value);

const char *handshake_msg_type_str(enum handshake_msg_type value);

const char *handshake_auth_str(enum handshake_auth value);



/* Common nested types */

struct handshake_x509 {

	struct {

		__u32 cert:1;

		__u32 privkey:1;

	} _present;



	__u32 cert;

	__u32 privkey;

};



/* ============== HANDSHAKE_CMD_ACCEPT ============== */

/* HANDSHAKE_CMD_ACCEPT - do */

struct handshake_accept_req {

	struct {

		__u32 handler_class:1;

	} _present;



	enum handshake_handler_class handler_class;

};



static inline struct handshake_accept_req *handshake_accept_req_alloc(void)

{

	return calloc(1, sizeof(struct handshake_accept_req));

}

void handshake_accept_req_free(struct handshake_accept_req *req);



static inline void

handshake_accept_req_set_handler_class(struct handshake_accept_req *req,

				       enum handshake_handler_class handler_class)

{

	req->_present.handler_class = 1;

	req->handler_class = handler_class;

}



struct handshake_accept_rsp {

	struct {

		__u32 sockfd:1;

		__u32 message_type:1;

		__u32 timeout:1;

		__u32 auth_mode:1;

		__u32 peername_len;

	} _present;



	__u32 sockfd;

	enum handshake_msg_type message_type;

	__u32 timeout;

	enum handshake_auth auth_mode;

	unsigned int n_peer_identity;

	__u32 *peer_identity;

	unsigned int n_certificate;

	struct handshake_x509 *certificate;

	char *peername;

};



void handshake_accept_rsp_free(struct handshake_accept_rsp *rsp);



/*

 * Handler retrieves next queued handshake request

 */

struct handshake_accept_rsp *

handshake_accept(struct ynl_sock *ys, struct handshake_accept_req *req);



/* HANDSHAKE_CMD_ACCEPT - notify */

struct handshake_accept_ntf {

	__u16 family;

	__u8 cmd;

	struct ynl_ntf_base_type *next;

	void (*free)(struct handshake_accept_ntf *ntf);

	struct handshake_accept_rsp obj __attribute__ ((aligned (8)));

};



void handshake_accept_ntf_free(struct handshake_accept_ntf *rsp);



/* ============== HANDSHAKE_CMD_DONE ============== */

/* HANDSHAKE_CMD_DONE - do */

struct handshake_done_req {

	struct {

		__u32 status:1;

		__u32 sockfd:1;

	} _present;



	__u32 status;

	__u32 sockfd;

	unsigned int n_remote_auth;

	__u32 *remote_auth;

};



static inline struct handshake_done_req *handshake_done_req_alloc(void)

{

	return calloc(1, sizeof(struct handshake_done_req));

}

void handshake_done_req_free(struct handshake_done_req *req);



static inline void

handshake_done_req_set_status(struct handshake_done_req *req, __u32 status)

{

	req->_present.status = 1;

	req->status = status;

}

static inline void

handshake_done_req_set_sockfd(struct handshake_done_req *req, __u32 sockfd)

{

	req->_present.sockfd = 1;

	req->sockfd = sockfd;

}

static inline void

__handshake_done_req_set_remote_auth(struct handshake_done_req *req,

				     __u32 *remote_auth,

				     unsigned int n_remote_auth)

{

	free(req->remote_auth);

	req->remote_auth = remote_auth;

	req->n_remote_auth = n_remote_auth;

}



/*

 * Handler reports handshake completion

 */

int handshake_done(struct ynl_sock *ys, struct handshake_done_req *req);



/* --------------- Common notification parsing --------------- */

struct ynl_ntf_base_type *handshake_ntf_parse(struct ynl_sock *ys);



#endif /* _LINUX_HANDSHAKE_GEN_H */

tools/net/ynl/ynl-gen-c.py

+59 −10
Original line number Diff line number Diff line
@@ -94,7 +94,10 @@ class Type(SpecAttr): 
    def arg_member(self, ri):

        member = self._complex_member_type(ri)

        if member:

            return [member + ' *' + self.c_name]

            arg = [member + ' *' + self.c_name]

            if self.presence_type() == 'count':

                arg += ['unsigned int n_' + self.c_name]

            return arg

        raise Exception(f"Struct member not implemented for class type {self.type}")



    def struct_member(self, ri):
@@ -188,9 +191,12 @@ class Type(SpecAttr): 
                code.append(presence + ' = 1;')

        code += self._setter_lines(ri, member, presence)



        ri.cw.write_func('static inline void',

                         f"{op_prefix(ri, direction, deref=deref)}_set_{'_'.join(ref)}",

                         body=code,

        func_name = f"{op_prefix(ri, direction, deref=deref)}_set_{'_'.join(ref)}"

        free = bool([x for x in code if 'free(' in x])

        alloc = bool([x for x in code if 'alloc(' in x])

        if free and not alloc:

            func_name = '__' + func_name

        ri.cw.write_func('static inline void', func_name, body=code,

                         args=[f'{type_name(ri, direction, deref=deref)} *{var}'] + self.arg_member(ri))
@@ -444,6 +450,13 @@ class TypeMultiAttr(Type): 
    def presence_type(self):

        return 'count'



    def _mnl_type(self):

        t = self.type

        # mnl does not have a helper for signed types

        if t[0] == 's':

            t = 'u' + t[1:]

        return t



    def _complex_member_type(self, ri):

        if 'type' not in self.attr or self.attr['type'] == 'nest':

            return f"struct {self.nested_render_name}"
@@ -457,9 +470,14 @@ class TypeMultiAttr(Type): 
        return 'type' not in self.attr or self.attr['type'] == 'nest'



    def free(self, ri, var, ref):

        if 'type' not in self.attr or self.attr['type'] == 'nest':

        if self.attr['type'] in scalars:

            ri.cw.p(f"free({var}->{ref}{self.c_name});")

        elif 'type' not in self.attr or self.attr['type'] == 'nest':

            ri.cw.p(f"for (i = 0; i < {var}->{ref}n_{self.c_name}; i++)")

            ri.cw.p(f'{self.nested_render_name}_free(&{var}->{ref}{self.c_name}[i]);')

            ri.cw.p(f"free({var}->{ref}{self.c_name});")

        else:

            raise Exception(f"Free of MultiAttr sub-type {self.attr['type']} not supported yet")



    def _attr_typol(self):

        if 'type' not in self.attr or self.attr['type'] == 'nest':
@@ -470,7 +488,26 @@ class TypeMultiAttr(Type): 
            raise Exception(f"Sub-type {self.attr['type']} not supported yet")



    def _attr_get(self, ri, var):

        return f'{var}->n_{self.c_name}++;', None, None

        return f'n_{self.c_name}++;', None, None



    def attr_put(self, ri, var):

        if self.attr['type'] in scalars:

            put_type = self._mnl_type()

            ri.cw.p(f"for (unsigned int i = 0; i < {var}->n_{self.c_name}; i++)")

            ri.cw.p(f"mnl_attr_put_{put_type}(nlh, {self.enum_name}, {var}->{self.c_name}[i]);")

        elif 'type' not in self.attr or self.attr['type'] == 'nest':

            ri.cw.p(f"for (unsigned int i = 0; i < {var}->n_{self.c_name}; i++)")

            self._attr_put_line(ri, var, f"{self.nested_render_name}_put(nlh, " +

                                f"{self.enum_name}, &{var}->{self.c_name}[i])")

        else:

            raise Exception(f"Put of MultiAttr sub-type {self.attr['type']} not supported yet")



    def _setter_lines(self, ri, member, presence):

        # For multi-attr we have a count, not presence, hack up the presence

        presence = presence[:-(len('_present.') + len(self.c_name))] + "n_" + self.c_name

        return [f"free({member});",

                f"{member} = {self.c_name};",

                f"{presence} = n_{self.c_name};"]





class TypeArrayNest(Type):
@@ -1269,6 +1306,11 @@ def _multi_parse(ri, struct, init_lines, local_vars): 
        local_vars.append('struct ynl_parse_arg parg;')

        init_lines.append('parg.ys = yarg->ys;')



    all_multi = array_nests | multi_attrs



    for anest in sorted(all_multi):

        local_vars.append(f"unsigned int n_{struct[anest].c_name} = 0;")



    ri.cw.block_start()

    ri.cw.write_func_lvar(local_vars)
@@ -1279,6 +1321,11 @@ def _multi_parse(ri, struct, init_lines, local_vars): 
    for arg in struct.inherited:

        ri.cw.p(f'dst->{arg} = {arg};')



    for anest in sorted(all_multi):

        aspec = struct[anest]

        ri.cw.p(f"if (dst->{aspec.c_name})")

        ri.cw.p(f'return ynl_error_parse(yarg, "attribute already present ({struct.attr_set.name}.{aspec.name})");')



    ri.cw.nl()

    ri.cw.block_start(line=iter_line)
@@ -1294,8 +1341,9 @@ def _multi_parse(ri, struct, init_lines, local_vars): 
    for anest in sorted(array_nests):

        aspec = struct[anest]



        ri.cw.block_start(line=f"if (dst->n_{aspec.c_name})")

        ri.cw.p(f"dst->{aspec.c_name} = calloc(dst->n_{aspec.c_name}, sizeof(*dst->{aspec.c_name}));")

        ri.cw.block_start(line=f"if (n_{aspec.c_name})")

        ri.cw.p(f"dst->{aspec.c_name} = calloc({aspec.c_name}, sizeof(*dst->{aspec.c_name}));")

        ri.cw.p(f"dst->n_{aspec.c_name} = n_{aspec.c_name};")

        ri.cw.p('i = 0;')

        ri.cw.p(f"parg.rsp_policy = &{aspec.nested_render_name}_nest;")

        ri.cw.block_start(line=f"mnl_attr_for_each_nested(attr, attr_{aspec.c_name})")
@@ -1309,8 +1357,9 @@ def _multi_parse(ri, struct, init_lines, local_vars): 


    for anest in sorted(multi_attrs):

        aspec = struct[anest]

        ri.cw.block_start(line=f"if (dst->n_{aspec.c_name})")

        ri.cw.p(f"dst->{aspec.c_name} = calloc(dst->n_{aspec.c_name}, sizeof(*dst->{aspec.c_name}));")

        ri.cw.block_start(line=f"if (n_{aspec.c_name})")

        ri.cw.p(f"dst->{aspec.c_name} = calloc(n_{aspec.c_name}, sizeof(*dst->{aspec.c_name}));")

        ri.cw.p(f"dst->n_{aspec.c_name} = n_{aspec.c_name};")

        ri.cw.p('i = 0;')

        if 'nested-attributes' in aspec:

            ri.cw.p(f"parg.rsp_policy = &{aspec.nested_render_name}_nest;")