Mnemonic: mbuf_api.c
Abstract: These are common functions which work only on the mbuf and
thus (because they do not touch an endpoint or context)
- can be agnostic to the underlying transport.
+ can be agnostic to the underlying transport, or the transport
+ layer provides a transport specific function (e.g. payload
+ reallocation).
Author: E. Scott Daniels
Date: 8 February 2019
#include "rmr.h" // things the users see
#include "rmr_agnostic.h" // agnostic things (must be included before private)
+#include "rmr_logging.h"
+
+//#define BUF_TOOLS_ONLY 1
+#include "tools_static.c"
// ---------- some wrappers need explicit copy-in functions, also header field setters -----
EINVAL id poitner, buf or buf header are bad.
EOVERFLOW if the bytes given would have overrun
+ We have been told that the meid will be a string, so we enforce that even if
+ the user is copying in bytes. We will add a 0 byte at len+1 when len is less
+ than the field size, or as the last byte (doing damage to their string) if
+ the caller didn't play by the rules. If they pass a non-nil terminated set
+ of bytes which are the field length, we'll indicate truncation.
+
*/
extern int rmr_bytes2meid( rmr_mbuf_t* mbuf, unsigned char const* src, int len ) {
uta_mhdr_t* hdr;
hdr = (uta_mhdr_t *) mbuf->header;
memcpy( hdr->meid, src, len );
+ if( len == RMR_MAX_MEID ) {
+ if( *(hdr->meid+len-1) != 0 ) {
+ *(hdr->meid+len-1) = 0;
+ errno = EOVERFLOW;
+ }
+ } else {
+ *(hdr->meid+len) = 0;
+ }
+
return len;
}
}
/*
- Extracts the meid (managed equipment) from the header and copies the bytes
+ Extracts the meid (managed entity) from the header and copies the bytes
to the user supplied area. If the user supplied pointer is nil, then
a buffer will be allocated and it is the user's responsibilty to free.
A pointer is returned to the destination memory (allocated or not)
The return value is the number of bytes actually coppied. If 0 bytes are coppied
errno should indicate the reason. If 0 is returned and errno is 0, then size
passed was 0. The state in the message is left UNCHANGED.
+
+ Regardless of action taken (actual realloc or not) the caller's reference to mbuf
+ is still valid follwing the call and will point to the correct spot (same tp
+ buffer if no realloc needed, or the new one if there was).
*/
extern int rmr_set_trace( rmr_mbuf_t* msg, unsigned const char* data, int size ) {
uta_mhdr_t* hdr;
if( len != size ) { // different sized trace data, must realloc the buffer
nm = rmr_realloc_msg( msg, size ); // realloc with changed trace size
- old_tp_buf = msg->tp_buf;
+ old_tp_buf = msg->tp_buf; // hold to repoint new mbuf at small buffer
old_hdr = msg->header;
msg->tp_buf = nm->tp_buf; // reference the reallocated buffer
msg->xaction = nm->xaction;
msg->payload = nm->payload;
- nm->tp_buf = old_tp_buf; // set to free
+ nm->tp_buf = old_tp_buf; // set to free; point to the small buffer
nm->header = old_hdr; // nano frees on hdr, so must set both
rmr_free_msg( nm );
if( dest != NULL ) {
hdr = msg->header;
- strcpy( dest, hdr->src );
+ zt_buf_fill( dest, hdr->src, RMR_MAX_SRC );
}
return dest;
hdr = msg->header;
if( HDR_VERSION( msg->header ) > 2 ) { // src ip was not present in hdr until ver 3
errno = 0;
- strcpy( dest, hdr->srcip );
+ zt_buf_fill( dest, hdr->srcip, RMR_MAX_SRC );
rstr = dest;
} else {
errno = 0;
- strcpy( dest, hdr->src ); // reutrn the name:port for old messages
+ zt_buf_fill( dest, hdr->src, RMR_MAX_SRC ); // reutrn the name:port for old messages
rstr = dest;
}
}
return rstr;
}
+