Fix possible nil pointer deref in interface check
[ric-plt/lib/rmr.git] / src / rmr / common / include / rmr_agnostic.h
1 // : vi ts=4 sw=4 noet :
2 /*
3 ==================================================================================
4         Copyright (c) 2019 Nokia
5         Copyright (c) 2018-2019 AT&T Intellectual Property.
6
7    Licensed under the Apache License, Version 2.0 (the "License");
8    you may not use this file except in compliance with the License.
9    You may obtain a copy of the License at
10
11            http://www.apache.org/licenses/LICENSE-2.0
12
13    Unless required by applicable law or agreed to in writing, software
14    distributed under the License is distributed on an "AS IS" BASIS,
15    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16    See the License for the specific language governing permissions and
17    limitations under the License.
18 ==================================================================================
19 */
20
21 /*
22         Mnemonic:       rmr_agnostic.h
23         Abstract:       Header file for things that are agnostic to the underlying transport
24                                 mechanism.
25         Author:         E. Scott Daniels
26         Date:           28 February 2018
27 */
28
29 #ifndef _rmr_agnostic_h
30 #define _rmr_agnostic_h
31
32 #include <semaphore.h>                                  // needed to support some structs
33
34 typedef struct endpoint endpoint_t;             // place holder for structs defined in nano/nng private.h
35 typedef struct uta_ctx  uta_ctx_t;
36
37 // allow testing to override without changing this
38 #ifndef DEBUG
39 #define DEBUG 0
40 #endif
41
42 #define FALSE 0
43 #define TRUE  1
44
45 #define QUOTE(a) #a                             // allow a constant to be quoted
46 #define QUOTE_DEF(a) QUOTE(a)   // allow a #define value to be quoted (e.g. QUOTE(MAJOR_VERSION) )
47
48
49 #define RT_SIZE                 10009   // primary entries in route table (prime) meids hash through this so larger than expected # meids
50                                                                 // space deginations in the hash table
51 #define RT_MT_SPACE     0               // (integer) message type as the key
52 #define RT_NAME_SPACE   1               // enpoint name/address is the key
53 #define RT_ME_SPACE     2               // message id is the key
54
55 #define RMR_MSG_VER     3                       // message version this code was designed to handle
56
57                                                                                         // environment variable names we'll suss out
58 #define ENV_BIND_IF             "RMR_BIND_IF"           // the interface to bind to for both normal comma and RTG (0.0.0.0 if missing)
59 #define ENV_RTG_PORT    "RMR_RTG_SVC"           // the port we'll listen on for rtg connections (deprecated; see RTG_SVC and CTL_PORT)
60 #define ENV_RTG_ADDR    "RMR_RTG_SVC"           // the address we will connect to for route manager updates
61 #define ENV_SEED_RT             "RMR_SEED_RT"           // where we expect to find the name of the seed route table
62 #define ENV_SEED_MEMAP  "RMR_SEED_MEMAP"        // where we expect to find the name of the seed route table
63 #define ENV_RTG_RAW             "RMR_RTG_ISRAW"         // if > 0 we expect route table gen messages as raw (not sent from an RMr application)
64 #define ENV_VERBOSE_FILE "RMR_VCTL_FILE"        // file where vlevel may be managed for some (non-time critical) functions
65 #define ENV_NAME_ONLY   "RMR_SRC_NAMEONLY"      // src in message is name only
66 #define ENV_WARNINGS    "RMR_WARNINGS"          // if == 1 then we write some, non-performance impacting, warnings
67 #define ENV_SRC_ID              "RMR_SRC_ID"            // forces this string (adding :port, max 63 ch) into the source field; host name used if not set
68 #define ENV_LOG_HR              "RMR_HR_LOG"            // set to 0 to turn off human readable logging and write using some formatting
69 #define ENV_LOG_VLEVEL  "RMR_LOG_VLEVEL"        // set the verbosity level (0 == 0ff; 1 == crit .... 5 == debug )
70 #define ENV_CTL_PORT    "RMR_CTL_PORT"          // route collector will listen here for control messages (4561 default)
71
72 #define NO_FLAGS        0                               // no flags to pass to a function
73
74 #define FL_NOTHREAD     0x01                    // do not start an additional thread (must be 'user land' to support rtg
75 #define UFL_MASK                0xff            // mask applied to some flag parms passed by the user to remove any internal flags
76                                                                         // internal flags, must be > than UFLAG_MASK
77 //#define IFL_....
78
79 #define CFL_MTC_ENABLED 0x01            // multi-threaded call is enabled
80 #define CFL_NO_RTACK    0x02            // no route table ack needed when end received
81
82                                                                         // context flags
83 #define CTXFL_WARN              0x01            // ok to warn on stderr for some things that shouldn't happen
84
85                                                                         // msg buffer flags
86 #define MFL_ZEROCOPY    0x01            // the message is an allocated zero copy message and can be sent.
87 #define MFL_NOALLOC             0x02            // send should NOT allocate a new buffer before returning
88 #define MFL_ADDSRC              0x04            // source must be added on send
89 #define MFL_RAW                 0x08            // message is 'raw' and not from an RMr based sender (no header)
90
91 #define MAX_EP_GROUP    32                      // max number of endpoints in a group
92 #define MAX_RTG_MSG_SZ  2048            // max expected message size from route generator
93 #define MAX_CALL_ID             255                     // largest call ID that is supported
94
95 //#define DEF_RTG_MSGID ""                              // default to pick up all messages from rtg
96 #define DEF_CTL_PORT    "4561"                  // default control port that rtc listens on
97 #define DEF_RTG_PORT    "tcp:4561"              // default port that we accept rtg connections on (deprecated)
98 #define DEF_COMM_PORT   "tcp:4560"              // default port we use for normal communications
99 #define DEF_RTG_WK_ADDR "routemgr:4561" // well known address for the route manager
100 #define DEF_TR_LEN              (-1)                    // use default trace data len from context
101
102 #define UNSET_SUBID             (-1)                    // initial value on msg allocation indicating not set
103 #define UNSET_MSGTYPE   (-1)
104
105                                                                                 // index values into the send counters for an enpoint
106 #define EPSC_GOOD               0                               // successful send
107 #define EPSC_FAIL               1                               // hard failurs
108 #define EPSC_TRANS              2                               // transient/soft faiures
109 #define EPSC_SIZE               3                               // number of counters
110
111 // -- header length/offset macros must ensure network conversion ----
112 #define RMR_HDR_LEN(h)          (ntohl(((uta_mhdr_t *)h)->len0)+htonl(((uta_mhdr_t *)h)->len1)+htonl(((uta_mhdr_t *)h)->len2)+htonl(((uta_mhdr_t *)h)->len3)) // ALL things, not just formal struct
113 #define RMR_TR_LEN(h)           (ntohl(((uta_mhdr_t *)h)->len1))
114 #define RMR_D1_LEN(h)           (ntohl(((uta_mhdr_t *)h)->len2))
115 #define RMR_D2_LEN(h)           (ntohl(((uta_mhdr_t *)h)->len3))
116
117 // CAUTION:  if using an offset with a header pointer, the pointer MUST be cast to void* before adding the offset!
118 #define TRACE_OFFSET(h)         ((ntohl(((uta_mhdr_t *)h)->len0)))
119 #define DATA1_OFFSET(h)         (ntohl(((uta_mhdr_t *)h)->len0)+htonl(((uta_mhdr_t *)h)->len1))
120 #define DATA2_OFFSET(h)         (ntohl(((uta_mhdr_t *)h)->len0)+htonl(((uta_mhdr_t *)h)->len1)+htonl(((uta_mhdr_t *)h)->len2))
121 #define PAYLOAD_OFFSET(h)       (ntohl(((uta_mhdr_t *)h)->len0)+htonl(((uta_mhdr_t *)h)->len1)+htonl(((uta_mhdr_t *)h)->len2)+htonl(((uta_mhdr_t *)h)->len3))
122
123 #define TRACE_ADDR(h)           (((void *)h)+ntohl(((uta_mhdr_t *)h)->len0))
124 #define DATA1_ADDR(h)           (((void *)h)+ntohl(((uta_mhdr_t *)h)->len0)+htonl(((uta_mhdr_t *)h)->len1))
125 #define DATA2_ADDR(h)           (((void *)h)+ntohl(((uta_mhdr_t *)h)->len0)+htonl(((uta_mhdr_t *)h)->len1)+htonl(((uta_mhdr_t *)h)->len2))
126 #define PAYLOAD_ADDR(h)         (((void *)h)+ntohl(((uta_mhdr_t *)h)->len0)+htonl(((uta_mhdr_t *)h)->len1)+htonl(((uta_mhdr_t *)h)->len2)+htonl(((uta_mhdr_t *)h)->len3))
127
128 #define SET_HDR_LEN(h)          (((uta_mhdr_t *)h)->len0=htonl((int32_t)sizeof(uta_mhdr_t)))            // convert to network byte order on insert
129 #define SET_HDR_TR_LEN(h,l)     (((uta_mhdr_t *)h)->len1=htonl((int32_t)l))
130 #define SET_HDR_D1_LEN(h,l)     (((uta_mhdr_t *)h)->len2=htonl((int32_t)l))
131 #define SET_HDR_D2_LEN(h,l)     (((uta_mhdr_t *)h)->len3=htonl((int32_t)l))
132
133 #define HDR_VERSION(h)  htonl((((uta_mhdr_t *)h)->rmr_ver))
134
135                                                         // index of things in the d1 data space
136 #define D1_CALLID_IDX   0       // the call-id to match on return
137
138 #define NO_CALL_ID              0       // no call id associated with the message (normal queue)
139
140 #define V1_PAYLOAD_OFFSET(h)    (sizeof(uta_v1mhdr_t))
141
142                                                                                 // v2 header flags
143 #define HFL_HAS_TRACE   0x01                    // Trace data is populated
144 #define HFL_SUBID               0x02                    // subscription ID is populated
145 #define HFL_CALL_MSG    0x04                    // msg sent via blocking call
146
147 /*
148         Message header; interpreted by the other side, but never seen by
149         the user application.
150
151         DANGER: Add new fields AT THE END of the struct. Adding them any where else
152                         will break any code that is currently running.
153
154         The transport layer buffer allocated will be divided this way:
155                 | RMr header | Trace data | data1 | data2 | User paylaod |
156
157                 Len 0 is the length of the RMr header
158                 Len 1 is the length of the trace data
159                 Len 2 and 3 are lengths of data1 and data2 and are unused at the moment
160
161         To point at the payload, we take the address of the header and add all 4 lengths.
162 */
163 typedef struct {
164         int32_t mtype;                                          // message type  ("long" network integer)
165         int32_t plen;                                           // payload length (sender data length in payload)
166         int32_t rmr_ver;                                        // our internal message version number
167         unsigned char xid[RMR_MAX_XID];         // space for user transaction id or somesuch
168         unsigned char sid[RMR_MAX_SID];         // sender ID for return to sender needs
169         unsigned char src[RMR_MAX_SRC];         // name:port of the sender (source)
170         unsigned char meid[RMR_MAX_MEID];       // managed element id.
171         struct timespec ts;                                     // timestamp ???
172
173                                                                                 // V2 extension
174         int32_t flags;                                          // HFL_* constants
175         int32_t len0;                                           // length of the RMr header data
176         int32_t len1;                                           // length of the tracing data
177         int32_t len2;                                           // length of data 1 (d1)
178         int32_t len3;                                           // length of data 2 (d2)
179         int32_t sub_id;                                         // subscription id (-1 invalid)
180
181                                                                                 // v3 extension
182         unsigned char srcip[RMR_MAX_SRC];       // ip address and port of the source
183 } uta_mhdr_t;
184
185
186 typedef struct {                                                // old (inflexible) v1 header
187         int32_t mtype;                                          // message type  ("long" network integer)
188         int32_t plen;                                           // payload length
189         int32_t rmr_ver;                                        // our internal message version number
190         unsigned char xid[RMR_MAX_XID];         // space for user transaction id or somesuch
191         unsigned char sid[RMR_MAX_SID];         // misc sender info/data
192         unsigned char src[16];                          // name of the sender (source) (old size was 16)
193         unsigned char meid[RMR_MAX_MEID];       // managed element id.
194         struct timespec ts;                                     // timestamp ???
195 } uta_v1mhdr_t;
196
197 /*
198         Round robin group.
199 */
200 typedef struct {
201         uint16_t        ep_idx;         // next endpoint to send to
202         int nused;                              // number of endpoints in the list
203         int nendpts;                    // number allocated
204         endpoint_t **epts;              // the list of endpoints that we RR over
205 } rrgroup_t;
206
207 /*
208         Routing table entry. This is a list of endpoints that can be sent
209         messages of the given mtype.  If there is more than one, we will
210         round robin messags across the list.
211 */
212 typedef struct {
213         uint64_t key;                   // key used to reinsert this entry into a new symtab
214         int     refs;                           // number of symtabs which reference the entry
215         int mtype;                              // the message type for this list
216         int     nrrgroups;                      // number of rr groups to send to (if 0, the meid in a message determines endpoint)
217         rrgroup_t**     rrgroups;       // one or more set of endpoints to round robin messages to
218 } rtable_ent_t;
219
220 /*
221         The route table.
222 */
223 typedef struct {
224         void*   hash;                   // hash table.
225         int             updates;                // counter of update records received
226         int             mupdates;               // counter of meid update records received
227 } route_table_t;
228
229 /*
230         A wormhole is a direct connection between two endpoints that the user app can
231         send to without message type based routing.
232 */
233 typedef struct {
234         int     nalloc;                         // number of ep pointers allocated
235         endpoint_t** eps;               // end points directly referenced
236 } wh_mgt_t;
237
238
239 /*
240         This manages an array of pointers to IP addresses that are associated with one of our interfaces.
241         For now, we don't need to map the addr to a specific interface, just know that it is one of ours.
242 */
243 typedef struct {
244         char**  addrs;                  // all ip addresses we found
245         int             naddrs;                 // num actually used
246 } if_addrs_t;
247
248
249 // --------------- ring things  -------------------------------------------------
250 #define RING_NONE       0                       // no options
251 #define RING_RLOCK      0x01            // create/destroy the read lock on the ring
252 #define RING_WLOCK      0x02            // create/destroy the write lockk on the ring
253
254 typedef struct ring {
255         uint16_t head;                          // index of the head of the ring (insert point)
256         uint16_t tail;                          // index of the tail (extract point)
257         uint16_t nelements;                     // number of elements in the ring
258         void**  data;                           // the ring data (pointers to blobs of stuff)
259         int             pfd;                            // event fd for the ring for epoll
260         pthread_mutex_t*        rgate;  // read lock if used
261         pthread_mutex_t*        wgate;  // write lock if used
262 } ring_t;
263
264
265 // --------- multi-threaded call things -----------------------------------------
266 /*
267         A chute provides a return path for a received message that a thread has blocked
268         on.  The receive thread will set the mbuf pointer and tickler the barrier to
269         signal to the call thread that data is ready.
270 */
271 typedef struct chute {
272         rmr_mbuf_t*     mbuf;                                           // pointer to message buffer received
273         sem_t   barrier;                                                // semaphore that the thread is waiting on
274         unsigned char   expect[RMR_MAX_XID];    // the expected transaction ID
275 } chute_t;
276
277
278 // -------------- common static prototypes --------------------------------------
279
280 //---- tools ----------------------------------
281 static int has_myip( char const* buf, if_addrs_t* list, char sep, int max );
282 static int uta_tokenise( char* buf, char** tokens, int max, char sep );
283 static int uta_rmip_tokenise( char* buf, if_addrs_t* iplist, char** toks, int max, char sep );
284 static char* uta_h2ip( char const* hname );
285 static int uta_lookup_rtg( uta_ctx_t* ctx );
286 static int uta_has_str( char const* buf, char const* str, char sep, int max );
287 static char* get_default_ip( if_addrs_t* iplist );
288
289 // --- message ring --------------------------
290 static void* uta_mk_ring( int size );
291 static int uta_ring_config( void* vr, int options );
292 static void uta_ring_free( void* vr );
293 static inline void* uta_ring_extract( void* vr );
294 static inline int uta_ring_insert( void* vr, void* new_data );
295
296 // --- message and context management --------
297 static int ie_test( void* r, int i_factor, long inserts );
298
299
300 // ----- route table generic static things ---------
301 static inline uint64_t build_rt_key( int32_t sub_id, int32_t mtype );
302 static void collect_things( void* st, void* entry, char const* name, void* thing, void* vthing_list );
303 static void del_rte( void* st, void* entry, char const* name, void* thing, void* data );
304 static endpoint_t*  get_meid_owner( route_table_t *rt, char* meid );
305 static char* uta_fib( char* fname );
306 static route_table_t* uta_rt_init( );
307 static route_table_t* uta_rt_clone( route_table_t* srt );
308 static route_table_t* uta_rt_clone_all( route_table_t* srt );
309 static void uta_rt_drop( route_table_t* rt );
310 static endpoint_t*  uta_add_ep( route_table_t* rt, rtable_ent_t* rte, char* ep_name, int group  );
311 static rtable_ent_t* uta_add_rte( route_table_t* rt, uint64_t key, int nrrgroups );
312 static endpoint_t* uta_get_ep( route_table_t* rt, char const* ep_name );
313 static void read_static_rt( uta_ctx_t* ctx, int vlevel );
314 static void parse_rt_rec( uta_ctx_t* ctx,  uta_ctx_t* pctx, char* buf, int vlevel, rmr_mbuf_t* mbuf );
315 static rmr_mbuf_t* realloc_msg( rmr_mbuf_t* msg, int size );
316 static void* rtc( void* vctx );
317 static endpoint_t* rt_ensure_ep( route_table_t* rt, char const* ep_name );
318
319 // --------- route manager communications -----------------
320 static void send_rt_ack( uta_ctx_t* ctx, rmr_mbuf_t* mbuf, char* table_id, int state, char* reason );
321 static int send_update_req( uta_ctx_t* pctx, uta_ctx_t* ctx );
322
323 // -------- internal functions that can be referenced by common functions -------
324 static rmr_mbuf_t* mt_call( void* vctx, rmr_mbuf_t* mbuf, int call_id, int max_wait, endpoint_t* ep );
325
326
327 #endif