diff --git a/home/nipa/nipa_out/978314/ynl/new-code/psp-user.c b/home/nipa/nipa_out/978314/ynl/new-code/psp-user.c new file mode 100644 index 000000000000..1f568b35870a --- /dev/null +++ b/home/nipa/nipa_out/978314/ynl/new-code/psp-user.c @@ -0,0 +1,560 @@ +// SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) +/* Do not edit directly, auto-generated from: */ +/* Documentation/netlink/specs/psp.yaml */ +/* YNL-GEN user source */ + +#include +#include +#include "psp-user.h" +#include "ynl.h" +#include + +#include + +/* Enums */ +static const char * const psp_op_strmap[] = { + [PSP_CMD_DEV_GET] = "dev-get", + [PSP_CMD_DEV_ADD_NTF] = "dev-add-ntf", + [PSP_CMD_DEV_DEL_NTF] = "dev-del-ntf", + [PSP_CMD_DEV_SET] = "dev-set", + [PSP_CMD_DEV_CHANGE_NTF] = "dev-change-ntf", + [PSP_CMD_KEY_ROTATE] = "key-rotate", + [PSP_CMD_KEY_ROTATE_NTF] = "key-rotate-ntf", + [PSP_CMD_RX_ASSOC] = "rx-assoc", + [PSP_CMD_TX_ASSOC] = "tx-assoc", +}; + +const char *psp_op_str(int op) +{ + if (op < 0 || op >= (int)YNL_ARRAY_SIZE(psp_op_strmap)) + return NULL; + return psp_op_strmap[op]; +} + +static const char * const psp_version_strmap[] = { + [0] = "hdr0-aes-gcm-128", + [1] = "hdr0-aes-gcm-256", + [2] = "hdr0-aes-gmac-128", + [3] = "hdr0-aes-gmac-256", +}; + +const char *psp_version_str(enum psp_version value) +{ + if (value < 0 || value >= (int)YNL_ARRAY_SIZE(psp_version_strmap)) + return NULL; + return psp_version_strmap[value]; +} + +/* Policies */ +const struct ynl_policy_attr psp_keys_policy[PSP_A_KEYS_MAX + 1] = { + [PSP_A_KEYS_KEY] = { .name = "key", .type = YNL_PT_BINARY,}, + [PSP_A_KEYS_SPI] = { .name = "spi", .type = YNL_PT_U32, }, +}; + +const struct ynl_policy_nest psp_keys_nest = { + .max_attr = PSP_A_KEYS_MAX, + .table = psp_keys_policy, +}; + +const struct ynl_policy_attr psp_dev_policy[PSP_A_DEV_MAX + 1] = { + [PSP_A_DEV_ID] = { .name = "id", .type = YNL_PT_U32, }, + [PSP_A_DEV_IFINDEX] = { .name = "ifindex", .type = YNL_PT_U32, }, + [PSP_A_DEV_PSP_VERSIONS_CAP] = { .name = "psp-versions-cap", .type = YNL_PT_U32, }, + [PSP_A_DEV_PSP_VERSIONS_ENA] = { .name = "psp-versions-ena", .type = YNL_PT_U32, }, +}; + +const struct ynl_policy_nest psp_dev_nest = { + .max_attr = PSP_A_DEV_MAX, + .table = psp_dev_policy, +}; + +const struct ynl_policy_attr psp_assoc_policy[PSP_A_ASSOC_MAX + 1] = { + [PSP_A_ASSOC_DEV_ID] = { .name = "dev-id", .type = YNL_PT_U32, }, + [PSP_A_ASSOC_VERSION] = { .name = "version", .type = YNL_PT_U32, }, + [PSP_A_ASSOC_RX_KEY] = { .name = "rx-key", .type = YNL_PT_NEST, .nest = &psp_keys_nest, }, + [PSP_A_ASSOC_TX_KEY] = { .name = "tx-key", .type = YNL_PT_NEST, .nest = &psp_keys_nest, }, + [PSP_A_ASSOC_SOCK_FD] = { .name = "sock-fd", .type = YNL_PT_U32, }, +}; + +const struct ynl_policy_nest psp_assoc_nest = { + .max_attr = PSP_A_ASSOC_MAX, + .table = psp_assoc_policy, +}; + +/* Common nested types */ +void psp_keys_free(struct psp_keys *obj) +{ + free(obj->key); +} + +int psp_keys_put(struct nlmsghdr *nlh, unsigned int attr_type, + struct psp_keys *obj) +{ + struct nlattr *nest; + + nest = ynl_attr_nest_start(nlh, attr_type); + if (obj->_len.key) + ynl_attr_put(nlh, PSP_A_KEYS_KEY, obj->key, obj->_len.key); + if (obj->_present.spi) + ynl_attr_put_u32(nlh, PSP_A_KEYS_SPI, obj->spi); + ynl_attr_nest_end(nlh, nest); + + return 0; +} + +int psp_keys_parse(struct ynl_parse_arg *yarg, const struct nlattr *nested) +{ + struct psp_keys *dst = yarg->data; + const struct nlattr *attr; + + ynl_attr_for_each_nested(attr, nested) { + unsigned int type = ynl_attr_type(attr); + + if (type == PSP_A_KEYS_KEY) { + unsigned int len; + + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + + len = ynl_attr_data_len(attr); + dst->_len.key = len; + dst->key = malloc(len); + memcpy(dst->key, ynl_attr_data(attr), len); + } else if (type == PSP_A_KEYS_SPI) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.spi = 1; + dst->spi = ynl_attr_get_u32(attr); + } + } + + return 0; +} + +/* ============== PSP_CMD_DEV_GET ============== */ +/* PSP_CMD_DEV_GET - do */ +void psp_dev_get_req_free(struct psp_dev_get_req *req) +{ + free(req); +} + +void psp_dev_get_rsp_free(struct psp_dev_get_rsp *rsp) +{ + free(rsp); +} + +int psp_dev_get_rsp_parse(const struct nlmsghdr *nlh, + struct ynl_parse_arg *yarg) +{ + struct psp_dev_get_rsp *dst; + const struct nlattr *attr; + + dst = yarg->data; + + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + unsigned int type = ynl_attr_type(attr); + + if (type == PSP_A_DEV_ID) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.id = 1; + dst->id = ynl_attr_get_u32(attr); + } else if (type == PSP_A_DEV_IFINDEX) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.ifindex = 1; + dst->ifindex = ynl_attr_get_u32(attr); + } else if (type == PSP_A_DEV_PSP_VERSIONS_CAP) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.psp_versions_cap = 1; + dst->psp_versions_cap = ynl_attr_get_u32(attr); + } else if (type == PSP_A_DEV_PSP_VERSIONS_ENA) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.psp_versions_ena = 1; + dst->psp_versions_ena = ynl_attr_get_u32(attr); + } + } + + return YNL_PARSE_CB_OK; +} + +struct psp_dev_get_rsp * +psp_dev_get(struct ynl_sock *ys, struct psp_dev_get_req *req) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct psp_dev_get_rsp *rsp; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, PSP_CMD_DEV_GET, 1); + ys->req_policy = &psp_dev_nest; + ys->req_hdr_len = ys->family->hdr_len; + yrs.yarg.rsp_policy = &psp_dev_nest; + + if (req->_present.id) + ynl_attr_put_u32(nlh, PSP_A_DEV_ID, req->id); + + rsp = calloc(1, sizeof(*rsp)); + yrs.yarg.data = rsp; + yrs.cb = psp_dev_get_rsp_parse; + yrs.rsp_cmd = PSP_CMD_DEV_GET; + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + goto err_free; + + return rsp; + +err_free: + psp_dev_get_rsp_free(rsp); + return NULL; +} + +/* PSP_CMD_DEV_GET - dump */ +void psp_dev_get_list_free(struct psp_dev_get_list *rsp) +{ + struct psp_dev_get_list *next = rsp; + + while ((void *)next != YNL_LIST_END) { + rsp = next; + next = rsp->next; + + free(rsp); + } +} + +struct psp_dev_get_list *psp_dev_get_dump(struct ynl_sock *ys) +{ + struct ynl_dump_state yds = {}; + struct nlmsghdr *nlh; + int err; + + yds.yarg.ys = ys; + yds.yarg.rsp_policy = &psp_dev_nest; + yds.yarg.data = NULL; + yds.alloc_sz = sizeof(struct psp_dev_get_list); + yds.cb = psp_dev_get_rsp_parse; + yds.rsp_cmd = PSP_CMD_DEV_GET; + + nlh = ynl_gemsg_start_dump(ys, ys->family_id, PSP_CMD_DEV_GET, 1); + + err = ynl_exec_dump(ys, nlh, &yds); + if (err < 0) + goto free_list; + + return yds.first; + +free_list: + psp_dev_get_list_free(yds.first); + return NULL; +} + +/* PSP_CMD_DEV_GET - notify */ +void psp_dev_get_ntf_free(struct psp_dev_get_ntf *rsp) +{ + free(rsp); +} + +/* ============== PSP_CMD_DEV_SET ============== */ +/* PSP_CMD_DEV_SET - do */ +void psp_dev_set_req_free(struct psp_dev_set_req *req) +{ + free(req); +} + +void psp_dev_set_rsp_free(struct psp_dev_set_rsp *rsp) +{ + free(rsp); +} + +int psp_dev_set_rsp_parse(const struct nlmsghdr *nlh, + struct ynl_parse_arg *yarg) +{ + return YNL_PARSE_CB_OK; +} + +struct psp_dev_set_rsp * +psp_dev_set(struct ynl_sock *ys, struct psp_dev_set_req *req) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct psp_dev_set_rsp *rsp; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, PSP_CMD_DEV_SET, 1); + ys->req_policy = &psp_dev_nest; + ys->req_hdr_len = ys->family->hdr_len; + yrs.yarg.rsp_policy = &psp_dev_nest; + + if (req->_present.id) + ynl_attr_put_u32(nlh, PSP_A_DEV_ID, req->id); + if (req->_present.psp_versions_ena) + ynl_attr_put_u32(nlh, PSP_A_DEV_PSP_VERSIONS_ENA, req->psp_versions_ena); + + rsp = calloc(1, sizeof(*rsp)); + yrs.yarg.data = rsp; + yrs.cb = psp_dev_set_rsp_parse; + yrs.rsp_cmd = PSP_CMD_DEV_SET; + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + goto err_free; + + return rsp; + +err_free: + psp_dev_set_rsp_free(rsp); + return NULL; +} + +/* ============== PSP_CMD_KEY_ROTATE ============== */ +/* PSP_CMD_KEY_ROTATE - do */ +void psp_key_rotate_req_free(struct psp_key_rotate_req *req) +{ + free(req); +} + +void psp_key_rotate_rsp_free(struct psp_key_rotate_rsp *rsp) +{ + free(rsp); +} + +int psp_key_rotate_rsp_parse(const struct nlmsghdr *nlh, + struct ynl_parse_arg *yarg) +{ + struct psp_key_rotate_rsp *dst; + const struct nlattr *attr; + + dst = yarg->data; + + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + unsigned int type = ynl_attr_type(attr); + + if (type == PSP_A_DEV_ID) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.id = 1; + dst->id = ynl_attr_get_u32(attr); + } + } + + return YNL_PARSE_CB_OK; +} + +struct psp_key_rotate_rsp * +psp_key_rotate(struct ynl_sock *ys, struct psp_key_rotate_req *req) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct psp_key_rotate_rsp *rsp; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, PSP_CMD_KEY_ROTATE, 1); + ys->req_policy = &psp_dev_nest; + ys->req_hdr_len = ys->family->hdr_len; + yrs.yarg.rsp_policy = &psp_dev_nest; + + if (req->_present.id) + ynl_attr_put_u32(nlh, PSP_A_DEV_ID, req->id); + + rsp = calloc(1, sizeof(*rsp)); + yrs.yarg.data = rsp; + yrs.cb = psp_key_rotate_rsp_parse; + yrs.rsp_cmd = PSP_CMD_KEY_ROTATE; + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + goto err_free; + + return rsp; + +err_free: + psp_key_rotate_rsp_free(rsp); + return NULL; +} + +/* PSP_CMD_KEY_ROTATE - notify */ +void psp_key_rotate_ntf_free(struct psp_key_rotate_ntf *rsp) +{ + free(rsp); +} + +/* ============== PSP_CMD_RX_ASSOC ============== */ +/* PSP_CMD_RX_ASSOC - do */ +void psp_rx_assoc_req_free(struct psp_rx_assoc_req *req) +{ + free(req); +} + +void psp_rx_assoc_rsp_free(struct psp_rx_assoc_rsp *rsp) +{ + psp_keys_free(&rsp->rx_key); + free(rsp); +} + +int psp_rx_assoc_rsp_parse(const struct nlmsghdr *nlh, + struct ynl_parse_arg *yarg) +{ + struct psp_rx_assoc_rsp *dst; + const struct nlattr *attr; + struct ynl_parse_arg parg; + + dst = yarg->data; + parg.ys = yarg->ys; + + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + unsigned int type = ynl_attr_type(attr); + + if (type == PSP_A_ASSOC_DEV_ID) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.dev_id = 1; + dst->dev_id = ynl_attr_get_u32(attr); + } else if (type == PSP_A_ASSOC_VERSION) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.version = 1; + dst->version = ynl_attr_get_u32(attr); + } else if (type == PSP_A_ASSOC_RX_KEY) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.rx_key = 1; + + parg.rsp_policy = &psp_keys_nest; + parg.data = &dst->rx_key; + if (psp_keys_parse(&parg, attr)) + return YNL_PARSE_CB_ERROR; + } + } + + return YNL_PARSE_CB_OK; +} + +struct psp_rx_assoc_rsp * +psp_rx_assoc(struct ynl_sock *ys, struct psp_rx_assoc_req *req) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct psp_rx_assoc_rsp *rsp; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, PSP_CMD_RX_ASSOC, 1); + ys->req_policy = &psp_assoc_nest; + ys->req_hdr_len = ys->family->hdr_len; + yrs.yarg.rsp_policy = &psp_assoc_nest; + + if (req->_present.dev_id) + ynl_attr_put_u32(nlh, PSP_A_ASSOC_DEV_ID, req->dev_id); + if (req->_present.version) + ynl_attr_put_u32(nlh, PSP_A_ASSOC_VERSION, req->version); + if (req->_present.sock_fd) + ynl_attr_put_u32(nlh, PSP_A_ASSOC_SOCK_FD, req->sock_fd); + + rsp = calloc(1, sizeof(*rsp)); + yrs.yarg.data = rsp; + yrs.cb = psp_rx_assoc_rsp_parse; + yrs.rsp_cmd = PSP_CMD_RX_ASSOC; + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + goto err_free; + + return rsp; + +err_free: + psp_rx_assoc_rsp_free(rsp); + return NULL; +} + +/* ============== PSP_CMD_TX_ASSOC ============== */ +/* PSP_CMD_TX_ASSOC - do */ +void psp_tx_assoc_req_free(struct psp_tx_assoc_req *req) +{ + psp_keys_free(&req->tx_key); + free(req); +} + +void psp_tx_assoc_rsp_free(struct psp_tx_assoc_rsp *rsp) +{ + free(rsp); +} + +int psp_tx_assoc_rsp_parse(const struct nlmsghdr *nlh, + struct ynl_parse_arg *yarg) +{ + return YNL_PARSE_CB_OK; +} + +struct psp_tx_assoc_rsp * +psp_tx_assoc(struct ynl_sock *ys, struct psp_tx_assoc_req *req) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct psp_tx_assoc_rsp *rsp; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, PSP_CMD_TX_ASSOC, 1); + ys->req_policy = &psp_assoc_nest; + ys->req_hdr_len = ys->family->hdr_len; + yrs.yarg.rsp_policy = &psp_assoc_nest; + + if (req->_present.dev_id) + ynl_attr_put_u32(nlh, PSP_A_ASSOC_DEV_ID, req->dev_id); + if (req->_present.version) + ynl_attr_put_u32(nlh, PSP_A_ASSOC_VERSION, req->version); + if (req->_present.tx_key) + psp_keys_put(nlh, PSP_A_ASSOC_TX_KEY, &req->tx_key); + if (req->_present.sock_fd) + ynl_attr_put_u32(nlh, PSP_A_ASSOC_SOCK_FD, req->sock_fd); + + rsp = calloc(1, sizeof(*rsp)); + yrs.yarg.data = rsp; + yrs.cb = psp_tx_assoc_rsp_parse; + yrs.rsp_cmd = PSP_CMD_TX_ASSOC; + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + goto err_free; + + return rsp; + +err_free: + psp_tx_assoc_rsp_free(rsp); + return NULL; +} + +static const struct ynl_ntf_info psp_ntf_info[] = { + [PSP_CMD_DEV_ADD_NTF] = { + .alloc_sz = sizeof(struct psp_dev_get_ntf), + .cb = psp_dev_get_rsp_parse, + .policy = &psp_dev_nest, + .free = (void *)psp_dev_get_ntf_free, + }, + [PSP_CMD_DEV_DEL_NTF] = { + .alloc_sz = sizeof(struct psp_dev_get_ntf), + .cb = psp_dev_get_rsp_parse, + .policy = &psp_dev_nest, + .free = (void *)psp_dev_get_ntf_free, + }, + [PSP_CMD_DEV_CHANGE_NTF] = { + .alloc_sz = sizeof(struct psp_dev_get_ntf), + .cb = psp_dev_get_rsp_parse, + .policy = &psp_dev_nest, + .free = (void *)psp_dev_get_ntf_free, + }, + [PSP_CMD_KEY_ROTATE_NTF] = { + .alloc_sz = sizeof(struct psp_key_rotate_ntf), + .cb = psp_key_rotate_rsp_parse, + .policy = &psp_dev_nest, + .free = (void *)psp_key_rotate_ntf_free, + }, +}; + +const struct ynl_family ynl_psp_family = { + .name = "psp", + .hdr_len = sizeof(struct genlmsghdr), + .ntf_info = psp_ntf_info, + .ntf_info_size = YNL_ARRAY_SIZE(psp_ntf_info), +}; diff --git a/home/nipa/nipa_out/978314/ynl/new-code/psp-user.h b/home/nipa/nipa_out/978314/ynl/new-code/psp-user.h new file mode 100644 index 000000000000..d4f606e02026 --- /dev/null +++ b/home/nipa/nipa_out/978314/ynl/new-code/psp-user.h @@ -0,0 +1,324 @@ +/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ +/* Do not edit directly, auto-generated from: */ +/* Documentation/netlink/specs/psp.yaml */ +/* YNL-GEN user header */ + +#ifndef _LINUX_PSP_GEN_H +#define _LINUX_PSP_GEN_H + +#include +#include +#include +#include + +struct ynl_sock; + +extern const struct ynl_family ynl_psp_family; + +/* Enums */ +const char *psp_op_str(int op); +const char *psp_version_str(enum psp_version value); + +/* Common nested types */ +struct psp_keys { + struct { + __u32 spi:1; + } _present; + struct { + __u32 key; + } _len; + + void *key; + __u32 spi; +}; + +/* ============== PSP_CMD_DEV_GET ============== */ +/* PSP_CMD_DEV_GET - do */ +struct psp_dev_get_req { + struct { + __u32 id:1; + } _present; + + __u32 id; +}; + +static inline struct psp_dev_get_req *psp_dev_get_req_alloc(void) +{ + return calloc(1, sizeof(struct psp_dev_get_req)); +} +void psp_dev_get_req_free(struct psp_dev_get_req *req); + +static inline void +psp_dev_get_req_set_id(struct psp_dev_get_req *req, __u32 id) +{ + req->_present.id = 1; + req->id = id; +} + +struct psp_dev_get_rsp { + struct { + __u32 id:1; + __u32 ifindex:1; + __u32 psp_versions_cap:1; + __u32 psp_versions_ena:1; + } _present; + + __u32 id; + __u32 ifindex; + __u32 psp_versions_cap; + __u32 psp_versions_ena; +}; + +void psp_dev_get_rsp_free(struct psp_dev_get_rsp *rsp); + +/* + * Get / dump information about PSP capable devices on the system. + */ +struct psp_dev_get_rsp * +psp_dev_get(struct ynl_sock *ys, struct psp_dev_get_req *req); + +/* PSP_CMD_DEV_GET - dump */ +struct psp_dev_get_list { + struct psp_dev_get_list *next; + struct psp_dev_get_rsp obj __attribute__((aligned(8))); +}; + +void psp_dev_get_list_free(struct psp_dev_get_list *rsp); + +struct psp_dev_get_list *psp_dev_get_dump(struct ynl_sock *ys); + +/* PSP_CMD_DEV_GET - notify */ +struct psp_dev_get_ntf { + __u16 family; + __u8 cmd; + struct ynl_ntf_base_type *next; + void (*free)(struct psp_dev_get_ntf *ntf); + struct psp_dev_get_rsp obj __attribute__((aligned(8))); +}; + +void psp_dev_get_ntf_free(struct psp_dev_get_ntf *rsp); + +/* ============== PSP_CMD_DEV_SET ============== */ +/* PSP_CMD_DEV_SET - do */ +struct psp_dev_set_req { + struct { + __u32 id:1; + __u32 psp_versions_ena:1; + } _present; + + __u32 id; + __u32 psp_versions_ena; +}; + +static inline struct psp_dev_set_req *psp_dev_set_req_alloc(void) +{ + return calloc(1, sizeof(struct psp_dev_set_req)); +} +void psp_dev_set_req_free(struct psp_dev_set_req *req); + +static inline void +psp_dev_set_req_set_id(struct psp_dev_set_req *req, __u32 id) +{ + req->_present.id = 1; + req->id = id; +} +static inline void +psp_dev_set_req_set_psp_versions_ena(struct psp_dev_set_req *req, + __u32 psp_versions_ena) +{ + req->_present.psp_versions_ena = 1; + req->psp_versions_ena = psp_versions_ena; +} + +struct psp_dev_set_rsp { +}; + +void psp_dev_set_rsp_free(struct psp_dev_set_rsp *rsp); + +/* + * Set the configuration of a PSP device. + */ +struct psp_dev_set_rsp * +psp_dev_set(struct ynl_sock *ys, struct psp_dev_set_req *req); + +/* ============== PSP_CMD_KEY_ROTATE ============== */ +/* PSP_CMD_KEY_ROTATE - do */ +struct psp_key_rotate_req { + struct { + __u32 id:1; + } _present; + + __u32 id; +}; + +static inline struct psp_key_rotate_req *psp_key_rotate_req_alloc(void) +{ + return calloc(1, sizeof(struct psp_key_rotate_req)); +} +void psp_key_rotate_req_free(struct psp_key_rotate_req *req); + +static inline void +psp_key_rotate_req_set_id(struct psp_key_rotate_req *req, __u32 id) +{ + req->_present.id = 1; + req->id = id; +} + +struct psp_key_rotate_rsp { + struct { + __u32 id:1; + } _present; + + __u32 id; +}; + +void psp_key_rotate_rsp_free(struct psp_key_rotate_rsp *rsp); + +/* + * Rotate the device key. + */ +struct psp_key_rotate_rsp * +psp_key_rotate(struct ynl_sock *ys, struct psp_key_rotate_req *req); + +/* PSP_CMD_KEY_ROTATE - notify */ +struct psp_key_rotate_ntf { + __u16 family; + __u8 cmd; + struct ynl_ntf_base_type *next; + void (*free)(struct psp_key_rotate_ntf *ntf); + struct psp_key_rotate_rsp obj __attribute__((aligned(8))); +}; + +void psp_key_rotate_ntf_free(struct psp_key_rotate_ntf *rsp); + +/* ============== PSP_CMD_RX_ASSOC ============== */ +/* PSP_CMD_RX_ASSOC - do */ +struct psp_rx_assoc_req { + struct { + __u32 dev_id:1; + __u32 version:1; + __u32 sock_fd:1; + } _present; + + __u32 dev_id; + enum psp_version version; + __u32 sock_fd; +}; + +static inline struct psp_rx_assoc_req *psp_rx_assoc_req_alloc(void) +{ + return calloc(1, sizeof(struct psp_rx_assoc_req)); +} +void psp_rx_assoc_req_free(struct psp_rx_assoc_req *req); + +static inline void +psp_rx_assoc_req_set_dev_id(struct psp_rx_assoc_req *req, __u32 dev_id) +{ + req->_present.dev_id = 1; + req->dev_id = dev_id; +} +static inline void +psp_rx_assoc_req_set_version(struct psp_rx_assoc_req *req, + enum psp_version version) +{ + req->_present.version = 1; + req->version = version; +} +static inline void +psp_rx_assoc_req_set_sock_fd(struct psp_rx_assoc_req *req, __u32 sock_fd) +{ + req->_present.sock_fd = 1; + req->sock_fd = sock_fd; +} + +struct psp_rx_assoc_rsp { + struct { + __u32 dev_id:1; + __u32 version:1; + __u32 rx_key:1; + } _present; + + __u32 dev_id; + enum psp_version version; + struct psp_keys rx_key; +}; + +void psp_rx_assoc_rsp_free(struct psp_rx_assoc_rsp *rsp); + +/* + * Allocate a new Rx key + SPI pair, associate it with a socket. + */ +struct psp_rx_assoc_rsp * +psp_rx_assoc(struct ynl_sock *ys, struct psp_rx_assoc_req *req); + +/* ============== PSP_CMD_TX_ASSOC ============== */ +/* PSP_CMD_TX_ASSOC - do */ +struct psp_tx_assoc_req { + struct { + __u32 dev_id:1; + __u32 version:1; + __u32 tx_key:1; + __u32 sock_fd:1; + } _present; + + __u32 dev_id; + enum psp_version version; + struct psp_keys tx_key; + __u32 sock_fd; +}; + +static inline struct psp_tx_assoc_req *psp_tx_assoc_req_alloc(void) +{ + return calloc(1, sizeof(struct psp_tx_assoc_req)); +} +void psp_tx_assoc_req_free(struct psp_tx_assoc_req *req); + +static inline void +psp_tx_assoc_req_set_dev_id(struct psp_tx_assoc_req *req, __u32 dev_id) +{ + req->_present.dev_id = 1; + req->dev_id = dev_id; +} +static inline void +psp_tx_assoc_req_set_version(struct psp_tx_assoc_req *req, + enum psp_version version) +{ + req->_present.version = 1; + req->version = version; +} +static inline void +psp_tx_assoc_req_set_tx_key_key(struct psp_tx_assoc_req *req, const void *key, + size_t len) +{ + req->_present.tx_key = 1; + free(req->tx_key.key); + req->tx_key._len.key = len; + req->tx_key.key = malloc(req->tx_key._len.key); + memcpy(req->tx_key.key, key, req->tx_key._len.key); +} +static inline void +psp_tx_assoc_req_set_tx_key_spi(struct psp_tx_assoc_req *req, __u32 spi) +{ + req->_present.tx_key = 1; + req->tx_key._present.spi = 1; + req->tx_key.spi = spi; +} +static inline void +psp_tx_assoc_req_set_sock_fd(struct psp_tx_assoc_req *req, __u32 sock_fd) +{ + req->_present.sock_fd = 1; + req->sock_fd = sock_fd; +} + +struct psp_tx_assoc_rsp { +}; + +void psp_tx_assoc_rsp_free(struct psp_tx_assoc_rsp *rsp); + +/* + * Add a PSP Tx association. + */ +struct psp_tx_assoc_rsp * +psp_tx_assoc(struct ynl_sock *ys, struct psp_tx_assoc_req *req); + +#endif /* _LINUX_PSP_GEN_H */