summaryrefslogtreecommitdiffstats
path: root/hicn-light/src/core/forwarder.h
blob: 6bc8232949c47b2ec3f2828bcb97c8181b158af6 (plain)
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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
/*
 * Copyright (c) 2017-2019 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.
 */

/*
 * The methods in this header are for the non-threaded forwarder.  They should
 * only be called within the forwarders thread of execution.
 */

#ifndef forwarder_h
#define forwarder_h

#ifndef _WIN32
#include <sys/time.h>
#endif
#include <stdlib.h>

#include <src/core/connectionTable.h>
#include <src/core/dispatcher.h>
#include <src/messenger/messenger.h>

#include <src/core/message.h>

#include <src/config/configuration.h>

#ifdef WITH_MAPME
#include <src/processor/fib.h>
#endif /* WITH_MAPME */

#include <src/core/logger.h>
#include <src/core/ticks.h>
#include <src/io/listenerSet.h>

#include <src/processor/fibEntryList.h>

#include <parc/algol/parc_Clock.h>

#include <src/socket/api.h>

#define PORT_NUMBER 9695
#define PORT_NUMBER_AS_STRING "9695"

#include <src/utils/commands.h>

// ==============================================

struct forwarder;
typedef struct forwarder Forwarder;

/**
 * @function forwarder_Create
 * @abstract Create the forwarder and use the provided logger for diagnostic
 * output
 * @discussion
 *   If the logger is null, hicn-light will create a STDOUT logger.
 *
 * @param logger may be NULL
 */
Forwarder *forwarder_Create(Logger *logger);

/**
 * @function forwarder_Destroy
 * @abstract Destroys the forwarder, stopping all traffic and freeing all memory
 */
void forwarder_Destroy(Forwarder **ptr);

/**
 * @function forwarder_SetupAllListeners
 * @abstract Setup all listeners (tcp, udp, local, ether, ip multicast) on all
 * interfaces
 * @discussion
 *   Sets up all listeners on all running interfaces.  This provides a quick and
 * easy startup, rather than providing a configuration file or programmatic
 * commands.
 *
 * @param port is used by TCP and UDP listeners, in host byte order
 * @param localPath is the AF_UNIX path to use, if NULL no AF_UNIX listener is
 * setup
 */
void forwarder_SetupAllListeners(Forwarder *forwarder, uint16_t port,
                                 const char *localPath);

/**
 * Configure hicn-light via a configuration file
 *
 * The configuration file is a set of lines, just like used in hicnLightControl.
 * You need to have "add listener" lines in the file to receive connections.  No
 * default listeners are configured.
 *
 * @param [in] forwarder An alloated Forwarder
 * @param [in] filename The path to the configuration file
 */
void forwarder_SetupFromConfigFile(Forwarder *forwarder, const char *filename);

/**
 * Returns the logger used by this forwarder
 *
 * If you will store the logger, you should acquire a reference to it.
 *
 * @param [in] forwarder An allocated hicn-light forwarder
 *
 * @retval non-null The logger used by hicn-light
 * @retval null An error
 */
Logger *forwarder_GetLogger(const Forwarder *forwarder);

/**
 * @function forwarder_SetLogLevel
 * @abstract Sets the minimum level to log
 */
void forwarder_SetLogLevel(Forwarder *forwarder, PARCLogLevel level);

/**
 * @function forwarder_GetNextConnectionId
 * @abstract Get the next identifier for a new connection
 */
unsigned forwarder_GetNextConnectionId(Forwarder *forwarder);

Messenger *forwarder_GetMessenger(Forwarder *forwarder);

Dispatcher *forwarder_GetDispatcher(Forwarder *forwarder);

/**
 * Returns the set of currently active listeners
 *
 * @param [in] forwarder An allocated hicn-light forwarder
 *
 * @retval non-null The set of active listeners
 * @retval null An error
 */
ListenerSet *forwarder_GetListenerSet(Forwarder *forwarder);

/**
 * Returns the forwrder's connection table
 *
 * @param [in] forwarder An allocated hicn-light forwarder
 *
 * @retval non-null The connection tabler
 * @retval null An error
 *
 */
ConnectionTable *forwarder_GetConnectionTable(Forwarder *forwarder);

/**
 * Returns a Tick-based clock
 *
 * Runs at approximately 1 msec per tick (see HZ in forwarder.c).
 * Do not Release this clock.  If you save a copy of it, create your own
 * reference to it with parcClock_Acquire().
 *
 * @param [in] forwarder An allocated hicn-light forwarder
 *
 * @retval non-null An allocated hicn-light Clock based on the Tick counter
 * @retval null An error
 */
PARCClock *forwarder_GetClock(const Forwarder *forwarder);

/**
 * Direct call to get the Tick clock
 *
 * Runs at approximately 1 msec per tick (see HZ in forwarder.c)
 *
 * @param [in] forwarder An allocated hicn-light forwarder
 */
Ticks forwarder_GetTicks(const Forwarder *forwarder);

/**
 * Convert nano seconds to Ticks
 *
 * Converts nano seconds to Ticks, based on HZ (in forwarder.c)
 */
Ticks forwarder_NanosToTicks(uint64_t nanos);

uint64_t forwarder_TicksToNanos(Ticks ticks);

void forwarder_ReceiveCommand(Forwarder *forwarder, command_id command,
                              struct iovec *message, unsigned ingressId);

void forwarder_Receive(Forwarder *forwarder, Message *mesage);

/**
 * @function forwarder_AddOrUpdateRoute
 * @abstract Adds or updates a route on all the message processors
 */
bool forwarder_AddOrUpdateRoute(Forwarder *forwarder,
                                add_route_command *control, unsigned ifidx);

/**
 * @function forwarder_RemoveRoute
 * @abstract Removes a route from all the message processors
 */
bool forwarder_RemoveRoute(Forwarder *forwarder, remove_route_command *control,
                           unsigned ifidx);

/**
 * Removes a connection id from all routes
 */
void forwarder_RemoveConnectionIdFromRoutes(Forwarder *forwarder,
                                            unsigned connectionId);

/**
 * @function forwarder_GetConfiguration
 * @abstract The configuration object
 * @discussion
 *   The configuration contains all user-issued commands.  It does not include
 * dynamic state.
 */
Configuration *forwarder_GetConfiguration(Forwarder *forwarder);

FibEntryList *forwarder_GetFibEntries(Forwarder *forwarder);

/**
 * Sets the maximum number of content objects in the content store
 *
 * Implementation dependent - may wipe the cache.
 */
void forwarder_SetContentObjectStoreSize(Forwarder *forwarder,
                                         size_t maximumContentStoreSize);

void forwarder_SetChacheStoreFlag(Forwarder *forwarder, bool val);

bool forwarder_GetChacheStoreFlag(Forwarder *forwarder);

void forwarder_SetChacheServeFlag(Forwarder *forwarder, bool val);

bool forwarder_GetChacheServeFlag(Forwarder *forwarder);

void forwarder_ClearCache(Forwarder *forwarder);

void forwarder_SetStrategy(Forwarder *forwarder, Name *prefix,
                           strategy_type strategy);

hicn_socket_helper_t *forwarder_GetHicnSocketHelper(Forwarder *forwarder);

#ifdef WITH_MAPME

/**
 * @function forwarder_getFib
 * @abstract Returns the hICN forwarder's FIB.
 * @param [in] forwarder - Pointer to the hICN forwarder.
 * @returns Pointer to the hICN FIB.
 */
FIB *forwarder_getFib(Forwarder *forwarder);

/**
 * @function forwarder_onConnectionAdded
 * @abstract Callback fired upon addition of a new connection through the
 *   control protocol.
 * @param [in] forwarder - Pointer to the hICN forwarder.
 * @param [in] conn - Pointer to the newly added connection.
 */
void forwarder_onConnectionAdded(Forwarder *forwarder, const Connection *conn);

/**
 * @function forwarder_onConnectionRemoved
 * @abstract Callback fired upon removal of a connection through the control
 *   protocol.
 * @param [in] forwarder - Pointer to the hICN forwarder.
 * @param [in] conn - Pointer to the removed connection.
 */
void forwarder_onConnectionRemoved(Forwarder *forwarder,
                                   const Connection *conn);

/**
 * @function forwarder_ProcessMapMe
 * @abstract Callback fired by an hICN listener upon reception of a MAP-Me
 *      message.
 * @param [in] forwarder - Pointer to the hICN forwarder.
 * @param [in] msgBuffer - MAP-Me buffer
 * @param [in] conn_id - Ingress connection id
 */
void forwarder_ProcessMapMe(Forwarder *forwarder, uint8_t *msgBuffer,
                            unsigned conn_id);

#endif /* WITH_MAPME */

#endif  // forwarder_h