1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
/*
* Copyright (c) 2021-2023 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* \file modules.h
* \brief hicn-light module interface.
*/
#ifndef HICNCTRL_MODULE_H
#define HICNCTRL_MODULE_H
#include <stdint.h>
#include <hicn/ctrl/data.h>
#include <hicn/ctrl/object.h>
#include <hicn/ctrl/socket.h>
#include "request.h"
/*
* execute is used for sync code (eg. in VPP), while serialize/parse for
* sync/async code (eg. in hicn-light).
*/
typedef int (*hc_execute_t)(hc_sock_t *, hc_object_t *, hc_data_t *);
typedef int (*hc_serialize_t)(const hc_object_t *, uint8_t *);
typedef struct {
int (*parse)(const uint8_t *buffer, size_t size, hc_object_t *object);
size_t serialized_size;
hc_serialize_t serialize[ACTION_N];
hc_execute_t execute[ACTION_N];
} hc_module_object_ops_t;
#define HC_MODULE_OBJECT_OPS_EMPTY \
(hc_module_object_ops_t) { \
.parse = NULL, .serialized_size = 0, \
.execute = \
{ \
[ACTION_CREATE] = NULL, \
[ACTION_DELETE] = NULL, \
[ACTION_LIST] = NULL, \
[ACTION_SET] = NULL, \
}, \
.serialize = { \
[ACTION_CREATE] = NULL, \
[ACTION_DELETE] = NULL, \
[ACTION_LIST] = NULL, \
[ACTION_SET] = NULL, \
}, \
}
#define DECLARE_MODULE_OBJECT_OPS_H(PREFIX, NAME) \
extern const hc_module_object_ops_t PREFIX##_##NAME##_module_ops;
/* Underscore'd functions take a hc_object_t as a parameter */
#define HC_MODULE_OBJECT_OPS(PREFIX, NAME) \
(hc_module_object_ops_t) { \
.parse = _##PREFIX##_##NAME##_parse, \
.serialized_size = sizeof(cmd_##NAME##_list_item_t), \
.execute = \
{ \
[ACTION_CREATE] = NULL, \
[ACTION_DELETE] = NULL, \
[ACTION_LIST] = NULL, \
[ACTION_SET] = NULL, \
}, \
.serialize = { \
[ACTION_CREATE] = PREFIX##_##NAME##_serialize_create, \
[ACTION_DELETE] = PREFIX##_##NAME##_serialize_delete, \
[ACTION_LIST] = PREFIX##_##NAME##_serialize_list, \
[ACTION_SET] = PREFIX##_##NAME##_serialize_set, \
} \
}
#define DECLARE_MODULE_OBJECT_OPS(PREFIX, NAME) \
const hc_module_object_ops_t PREFIX##_##NAME##_module_ops = { \
.parse = _##PREFIX##_##NAME##_parse, \
.serialized_size = sizeof(cmd_##NAME##_list_item_t), \
.execute = \
{ \
[ACTION_CREATE] = NULL, \
[ACTION_DELETE] = NULL, \
[ACTION_LIST] = NULL, \
[ACTION_SET] = NULL, \
}, \
.serialize = { \
[ACTION_CREATE] = PREFIX##_##NAME##_serialize_create, \
[ACTION_DELETE] = PREFIX##_##NAME##_serialize_delete, \
[ACTION_LIST] = PREFIX##_##NAME##_serialize_list, \
[ACTION_SET] = PREFIX##_##NAME##_serialize_set, \
}};
#define DECLARE_VPP_MODULE_OBJECT_OPS(PREFIX, NAME) \
const hc_module_object_ops_t PREFIX##_##NAME##_module_ops = { \
.execute = \
{ \
[ACTION_CREATE] = PREFIX##_##NAME##_create, \
[ACTION_DELETE] = PREFIX##_##NAME##_delete, \
[ACTION_LIST] = PREFIX##_##NAME##_list, \
[ACTION_SET] = PREFIX##_##NAME##_set, \
}, \
.serialize = \
{ \
[ACTION_CREATE] = NULL, \
[ACTION_DELETE] = NULL, \
[ACTION_LIST] = NULL, \
[ACTION_SET] = NULL, \
}, \
};
typedef struct {
/** Create module-specific data storage */
void *(*create_data)(const char *);
/** Release module-specific data storage */
void (*free_data)(void *);
/** Retrieve underlying file descriptor */
int (*get_fd)(hc_sock_t *);
/** Retrieve underlying receive buffer */
int (*get_recv_buffer)(hc_sock_t *, uint8_t **buffer, size_t *size);
/** Connect control socket to the forwarder */
int (*connect)(hc_sock_t *);
/** Disconnect control socket from forwarder */
int (*disconnect)(hc_sock_t *);
/** Populate the TX buffer with the serialization of the next request to be
* sent */
ssize_t (*prepare)(hc_sock_t *, hc_request_t *, uint8_t **buffer);
/** Send the content of the TX buffer */
int (*send)(hc_sock_t *, uint8_t *buffer, size_t size);
/** Receive responses in the RX buffer */
int (*recv)(hc_sock_t *);
/** Process the content of the RX buffer to populate result data */
int (*process)(hc_sock_t *, size_t count);
hc_module_object_ops_t object_vft[OBJECT_TYPE_N];
} hc_sock_ops_t;
#endif /* HICNCTRL_MODULE_H */
|
