Add alarm generation when application is slow
[ric-plt/lib/rmr.git] / src / rmr / common / src / mbuf_api.c
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:       mbuf_api.c
23         Abstract:       These are common functions which work only on the mbuf and
24                                 thus (because they do not touch an endpoint or context)
25                                 can be agnostic to the underlying transport, or the transport
26                                 layer provides a transport specific function (e.g. payload
27                                 reallocation).
28
29         Author:         E. Scott Daniels
30         Date:           8 February 2019
31 */
32
33 #include <stdlib.h>
34 #include <netdb.h>                      // uint* types
35 #include <errno.h>
36 #include <string.h>
37 #include <unistd.h>
38 #include <stdio.h>
39 #include <semaphore.h>
40
41 #include "rmr.h"                                // things the users see
42 #include "rmr_agnostic.h"               // agnostic things (must be included before private)
43 #include "rmr_logging.h"
44
45 //#define BUF_TOOLS_ONLY 1
46 #include "tools_static.c"
47
48
49 // ---------- some wrappers need explicit copy-in functions, also header field setters -----
50
51 /*
52         Allow the user programme to set the meid in the header.  The meid is a fixed
53         length buffer in the header and thus we must ensure it is not overrun. If
54         the  user gives a source buffer that is too large, we truncate. The return
55         value is the number of bytes copied, or -1 for absolute failure (bad pointer
56         etc.).  Errno is set:
57                 EINVAL id poitner, buf or buf header are bad.
58                 EOVERFLOW if the bytes given would have overrun
59
60         We have been told that the meid will be a string, so we enforce that even if
61         the user is copying in bytes.  We will add a 0 byte at len+1 when len is less
62         than the field size, or as the last byte (doing damage to their string) if
63         the caller didn't play by the rules. If they pass a non-nil terminated set
64         of bytes which are the field length, we'll indicate truncation.
65
66 */
67 extern int rmr_bytes2meid( rmr_mbuf_t* mbuf, unsigned char const* src, int len ) {
68         uta_mhdr_t* hdr;
69
70         if( src == NULL  ||  mbuf == NULL || mbuf->header == NULL ) {
71                 errno = EINVAL;
72                 return -1;
73         }
74
75         errno = 0;
76         if( len > RMR_MAX_MEID ) {
77                 len = RMR_MAX_MEID;
78                 errno = EOVERFLOW;
79         }
80
81         hdr = (uta_mhdr_t *) mbuf->header;
82         memcpy( hdr->meid, src, len );
83
84         if( len == RMR_MAX_MEID ) {
85                 if( *(hdr->meid+len-1) != 0 ) {
86                         *(hdr->meid+len-1) = 0;
87                         errno = EOVERFLOW;
88                 }
89         } else {
90                 *(hdr->meid+len) = 0;
91         }
92
93         return len;
94 }
95
96 /*
97         Allows the user programme to set the meid from a string. The end of string
98         (nil) will be included UNLESS the total length including the end of string
99         would exceed the size of the space in the header for the meid.  The return
100         value is RMR_OK for success and !RMR_OK on failure. Errno will be set
101         on error.
102 */
103 extern int rmr_str2meid( rmr_mbuf_t* mbuf, unsigned char const* str ) {
104         int len;                // len moved -- we do validate
105
106         if( str == NULL  ||  mbuf == NULL || mbuf->header == NULL ) {
107                 errno = EINVAL;
108                 return RMR_ERR_BADARG;
109         }
110
111         errno = 0;
112         if( (len = strlen( (char *) str )) > RMR_MAX_MEID-1 ) {
113                 errno = EOVERFLOW;
114                 return RMR_ERR_OVERFLOW;
115         }
116
117         rmr_bytes2meid( mbuf, str, len+1 );
118         return RMR_OK;
119 }
120
121
122
123 /*
124         This will copy n bytes from source into the payload. If len is larger than
125         the payload only the bytes which will fit are copied, The user should
126         check errno on return to determine success or failure.
127 */
128 extern void rmr_bytes2payload( rmr_mbuf_t* mbuf, unsigned char const* src, int len ) {
129         if( src == NULL  ||  mbuf == NULL || mbuf->payload == NULL ) {
130                 errno = EINVAL;
131                 return;
132         }
133
134         errno = 0;
135         mbuf->state = RMR_OK;
136         if( len > mbuf->alloc_len - sizeof( uta_mhdr_t ) ) {
137                 mbuf->state = RMR_ERR_OVERFLOW;
138                 errno = EMSGSIZE;
139                 len = mbuf->alloc_len - sizeof( uta_mhdr_t );
140         }
141
142         mbuf->len = len;
143         memcpy( mbuf->payload, src, len );
144 }
145
146 /*
147         This will copy a nil terminated string to the mbuf payload. The buffer length
148         is set to the string length.
149 */
150 extern void rmr_str2payload( rmr_mbuf_t* mbuf, unsigned char const* str ) {
151         rmr_bytes2payload( mbuf, str, strlen( (char *) str ) + 1 );
152 }
153
154
155 /*
156         Allow the user programme to set the xaction field in the header.  The xaction
157         is a fixed length buffer in the header and thus we must ensure it is not overrun.
158         If the  user gives a source buffer that is too large, we truncate. The return
159         value is the number of bytes copied, or -1 for absolute failure (bad pointer
160         etc.).  Errno is set:
161                 EINVAL id poitner, buf or buf header are bad.
162                 EOVERFLOW if the bytes given would have overrun
163
164 */
165 extern int rmr_bytes2xact( rmr_mbuf_t* mbuf, unsigned char const* src, int len ) {
166         uta_mhdr_t* hdr;
167
168         if( src == NULL  ||  mbuf == NULL || mbuf->header == NULL ) {
169                 errno = EINVAL;
170                 return -1;
171         }
172
173         errno = 0;
174         if( len > RMR_MAX_XID ) {
175                 len = RMR_MAX_XID;
176                 errno = EOVERFLOW;
177         }
178
179         hdr = (uta_mhdr_t *) mbuf->header;
180         memcpy( hdr->xid, src, len );
181
182         return len;
183 }
184
185
186
187 /*
188         Allows the user programme to set the xaction (xid) field from a string. The end
189         of string (nil) will be included UNLESS the total length including the end of string
190         would exceed the size of the space in the header for the xaction.  The return
191         value is RMR_OK for success and !RMR_OK on failure. Errno will be set
192         on error.
193 */
194 extern int rmr_str2xact( rmr_mbuf_t* mbuf, unsigned char const* str ) {
195         int len;                // len moved -- we do validate
196
197         if( str == NULL  ||  mbuf == NULL || mbuf->header == NULL ) {
198                 errno = EINVAL;
199                 return RMR_ERR_BADARG;
200         }
201
202         errno = 0;
203         if( (len = strlen( (char *) str )) > RMR_MAX_XID-1 ) {
204                 errno = EOVERFLOW;
205                 return RMR_ERR_OVERFLOW;
206         }
207
208         rmr_bytes2xact( mbuf, str, len+1 );
209         return RMR_OK;
210 }
211
212 /*
213         Extracts the transaction bytes from the header and places into a
214         user supplied buffer (dest). The buffer must be at least RMR_MAX_XID
215         bytes in length as this function will copy the entire field (even if
216         the sender saved a shorter "string." If the user supplies a nil poniter
217         as the destination, a buffer is allocated; the caller must free when
218         finished.  The buffer will be exactly RMR_MAX_XID bytes long.
219
220         The return value is a pointer to the buffer that was filled (to
221         the dest buffer provided, or the buffer we allocated). If there is an
222         error, a nil pointer is returned, and errno should suggest the root
223         cause of the issue (invalid message or no memory).
224 */
225 extern unsigned char*  rmr_get_xact( rmr_mbuf_t* mbuf, unsigned char* dest ) {
226         errno = 0;
227
228         if( mbuf == NULL || mbuf->xaction == NULL ) {
229                 errno = EINVAL;
230                 return NULL;
231         }
232
233         if( ! dest ) {
234                 if( (dest = (unsigned char *) malloc( sizeof( unsigned char ) * RMR_MAX_XID )) == NULL ) {
235                         errno = ENOMEM;
236                         return NULL;
237                 }
238         }
239
240         memcpy( dest, mbuf->xaction, RMR_MAX_XID );
241
242         return dest;
243 }
244
245 /*
246         Extracts the meid (managed entity) from the header and copies the bytes
247         to the user supplied area. If the user supplied pointer is nil, then
248         a buffer will be allocated and it is the user's responsibilty to free.
249         A pointer is returned to the destination memory (allocated or not)
250         for consistency. If the user programme supplies a destination it is
251         the responsibility of the programme to ensure that the space is large
252         enough.
253 */
254 extern unsigned char*  rmr_get_meid( rmr_mbuf_t* mbuf, unsigned char* dest ) {
255         uta_mhdr_t* hdr;
256
257         errno = 0;
258
259         if( mbuf == NULL || mbuf->header == NULL ) {
260                 errno = EINVAL;
261                 return NULL;
262         }
263
264         if( ! dest ) {
265                 if( (dest = (unsigned char *) malloc( sizeof( unsigned char ) * RMR_MAX_MEID )) == NULL ) {
266                         errno = ENOMEM;
267                         return NULL;
268                 }
269         }
270
271         hdr = (uta_mhdr_t *) mbuf->header;
272         memcpy( dest, hdr->meid, RMR_MAX_MEID );
273
274         return dest;
275 }
276
277 // ------------------- trace related access functions --------------------------------------
278 /*
279         The set_trace function will copy the supplied data for size bytes into the
280         header.  If the header trace area is not large enough, a new one will be allocated
281         which will cause a payload copy based on the msg->len value (if 0 no payload
282         data is copied).
283
284         The return value is the number of bytes actually coppied. If 0 bytes are coppied
285         errno should indicate the reason. If 0 is returned and errno is 0, then size
286         passed was 0.  The state in the message is left UNCHANGED.
287
288         Regardless of action taken (actual realloc or not) the caller's reference to mbuf
289         is still valid follwing the call and will point to the correct spot (same tp
290         buffer if no realloc needed, or the new one if there was).
291 */
292 extern int rmr_set_trace( rmr_mbuf_t* msg, unsigned const char* data, int size ) {
293         uta_mhdr_t*     hdr;
294         rmr_mbuf_t* nm;                 // new message if larger is needed
295         int             len;
296         void*   old_tp_buf;             // if we need to realloc, must hold old to free
297         void*   old_hdr;
298
299         if( msg == NULL ) {
300                 errno = EINVAL;
301                 return 0;
302         }
303
304         errno = 0;
305         if( size <= 0 ) {
306                 return 0;
307         }
308
309         hdr = (uta_mhdr_t *) msg->header;
310         if( !hdr ) {
311                 errno = EINVAL;
312                 return 0;
313         }
314
315         len = RMR_TR_LEN( hdr );
316
317         if( len != size ) {                                                     // different sized trace data, must realloc the buffer
318                 nm = rmr_realloc_msg( msg, size );              // realloc with changed trace size
319                 old_tp_buf = msg->tp_buf;                               // hold to repoint new mbuf at small buffer
320                 old_hdr = msg->header;
321
322                 msg->tp_buf = nm->tp_buf;                               // reference the reallocated buffer
323                 msg->header = nm->header;
324                 msg->id = NULL;                                                 // currently unused
325                 msg->xaction = nm->xaction;
326                 msg->payload = nm->payload;
327
328                 nm->tp_buf = old_tp_buf;                                // set to free; point to the small buffer
329                 nm->header = old_hdr;                                   // nano frees on hdr, so must set both
330                 rmr_free_msg( nm );
331
332                 hdr = (uta_mhdr_t *) msg->header;               // header WILL be different
333                 len = RMR_TR_LEN( hdr );
334         }
335
336         memcpy( TRACE_ADDR( hdr ), data, size );
337
338         return size;
339 }
340
341
342 /*
343         Returns a pointer (reference) to the trace data in the message. If sizeptr
344         is supplied, then the trace data size is assigned to the referenced
345         integer so that the caller doesn't need to make a second call to get the
346         value.
347
348         CAUTION:  user programmes should avoid writing to the referenced trace
349                         area (use rmr_set_trace() to avoid possible data overruns. This
350                         function is a convenience, and it is expected that users will
351                         use the trace data as read-only so as a copy is not necessary.
352 */
353 extern void* rmr_trace_ref( rmr_mbuf_t* msg, int* sizeptr ) {
354         uta_mhdr_t*     hdr = NULL;
355         int size = 0;
356
357         if( sizeptr != NULL ) {
358                 *sizeptr = 0;                                   // ensure reset if we bail
359         }
360
361         if( msg == NULL ) {
362                 return NULL;
363         }
364
365         hdr = msg->header;
366         if( (size = RMR_TR_LEN( hdr )) <= 0 ) {
367                 return NULL;
368         }
369
370         if( sizeptr != NULL ) {
371                 *sizeptr = size;
372         }
373
374         return (void *) TRACE_ADDR( hdr );
375 }
376
377 /*
378         Copies the trace bytes from the message header into the buffer provided by
379         the user. If the trace data in the header is less than size, then only
380         that number of bytes are copied, else exactly size bytes are copied. The
381         number actually copied is returned.
382 */
383 extern int rmr_get_trace( rmr_mbuf_t* msg, unsigned char* dest, int size ) {
384         uta_mhdr_t*     hdr = NULL;
385         int n2copy = 0;
386
387         if( msg == NULL ) {
388                 return 0;
389         }
390
391         if( size <= 0 || dest == NULL ) {
392                 return 0;
393         }
394
395         hdr = msg->header;
396         if( (n2copy = size < RMR_TR_LEN( hdr ) ? size : RMR_TR_LEN( hdr )) <= 0  ) {
397                 return 0;
398         }
399
400         memcpy( dest, TRACE_ADDR( hdr ), n2copy );
401
402         return n2copy;
403 }
404
405 /*
406         Returns the number of bytes currently allocated for trace data in the message
407         buffer.
408 */
409 extern int rmr_get_trlen( rmr_mbuf_t* msg ) {
410         uta_mhdr_t*     hdr;
411
412         if( msg == NULL ) {
413                 return 0;
414         }
415
416         hdr = msg->header;
417
418         return RMR_TR_LEN( hdr );
419 }
420
421 /*
422         Returns the string in the source portion of the header. This is assumed to be
423         something that can be used for direct sends (hostname:port). Regardless, it
424         will be a nil terminated, ascii string with max of 64 characters including
425         the final nil. So, the user must ensure that dest is at least 64 bytes.
426
427         As a convenience, the pointer to dest is returned on success; nil on failure
428         with errno set.
429 */
430 extern unsigned char* rmr_get_src( rmr_mbuf_t* msg, unsigned char* dest ) {
431         uta_mhdr_t*     hdr = NULL;
432
433         if( msg == NULL ) {
434                 errno = EINVAL;
435                 return NULL;
436         }
437
438         if( dest != NULL ) {
439                 hdr = msg->header;
440                 zt_buf_fill( dest, hdr->src, RMR_MAX_SRC );
441         }
442
443         return dest;
444 }
445
446 /*
447         Returns the string with the IP address as reported by the sender. This is
448         the IP address that the sender has sussed off of one of the interfaces
449         and cannot be guarenteed to be the acutal IP address which was used to
450         establish the connection.   The caller must provide a buffer of at least
451         64 bytes; the string will be nil terminated. A pointer to the user's buffer
452         is returned on success, nil on failure.
453 */
454 extern unsigned char* rmr_get_srcip( rmr_mbuf_t* msg, unsigned char* dest ) {
455         uta_mhdr_t*     hdr = NULL;
456         char*   rstr = NULL;
457
458         errno = EINVAL;
459
460         if( dest != NULL && msg != NULL ) {
461                 hdr = msg->header;
462                 if( HDR_VERSION( msg->header ) > 2 ) {          // src ip was not present in hdr until ver 3
463                         errno = 0;
464                         zt_buf_fill( dest, hdr->srcip, RMR_MAX_SRC );
465                         rstr = dest;
466                 } else  {
467                         errno = 0;
468                         zt_buf_fill( dest, hdr->src, RMR_MAX_SRC );                             // reutrn the name:port for old messages
469                         rstr = dest;
470                 }
471         }
472
473         return rstr;
474 }
475