ose_util.h

Go to the documentation of this file.

/*
  Copyright (c) 2019-23 John MacCallum Permission is hereby granted,
  free of charge, to any person obtaining a copy of this software
  and associated documentation files (the "Software"), to deal in
  the Software without restriction, including without limitation the
  rights to use, copy, modify, merge, publish, distribute,
  sublicense, and/or sell copies of the Software, and to permit
  persons to whom the Software is furnished to do so, subject to the
  following conditions:
 
  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  DEALINGS IN THE SOFTWARE.
*/
 
#ifndef OSE_UTIL_H
#define OSE_UTIL_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <inttypes.h>
#include <stdarg.h>
#include "ose.h"
 
#define ose_pnbytes(n) (((n) + 4) & 0xfffffffc)
 
int32_t ose_pstrlen(const char * const s);
 
bool ose_isAddressChar(char c);
 
bool ose_isKnownTypetag(char typetag);
 
bool ose_isStringType(char typetag);
 
bool ose_isIntegerType(char typetag);
 
bool ose_isFloatType(char typetag);
 
bool ose_isNumericType(char typetag);
 
bool ose_isUnitType(char typetag);
 
bool ose_isBoolType(char typetag);
 
bool ose_isBundle(ose_constbundle B);
 
bool ose_blobContainsBundleAtOffset(ose_constbundle B,
                                    const int32_t offset);
bool ose_blobContainsBundle(ose_constbundle B);
 
bool ose_bundleIsEmpty(ose_constbundle B);
 
int32_t ose_getBundleElemCount(ose_constbundle B);
 
int32_t ose_getBundleElemElemCount(ose_constbundle B,
                                   int32_t offset);
 
bool ose_bundleHasAtLeastNElems(ose_constbundle B,
                                int32_t n);
 
char ose_getBundleElemType(ose_constbundle B, int32_t offset);
 
 
char ose_readByte(ose_constbundle B, int32_t offset);
 
 
int32_t ose_writeByte(ose_bundle B, int32_t offset, char i);
 
 
int32_t ose_readInt32(ose_constbundle B, int32_t offset);
 
 
int32_t ose_writeInt32(ose_bundle B, int32_t offset, int32_t i);
 
 
float ose_readFloat(ose_constbundle B, int32_t offset);
 
int32_t ose_writeFloat(ose_bundle B, int32_t offset, float f);
 
 
const char *ose_readString(ose_constbundle B, int32_t offset);
 
 
int32_t ose_getStringLen(ose_constbundle B, int32_t offset);
 
 
int32_t ose_getPaddedStringLen(ose_constbundle B,
                               int32_t offset);
 
 
int32_t ose_writeString(ose_bundle B,
                        int32_t offset,
                        const char * const s,
                        int32_t slen,
                        int32_t slen_padded);
 
int32_t ose_processEscapes(char *s);
 
const char *ose_readBlob(ose_constbundle B, int32_t offset);
 
 
int32_t ose_readBlobSize(ose_constbundle B, int32_t offset);
 
 
#define ose_addToInt32(b, offset, amt)                      \
    ose_writeInt32((b),                                     \
                   (offset),                                \
                   ose_readInt32((b), (offset)) + (amt))
 
 
 
int32_t ose_getBlobPaddingForNBytes(int32_t n);
 
int32_t ose_getPaddedBlobSize(ose_constbundle B,
                              int32_t offset);
 
const char *ose_readBlobPayload(ose_constbundle B,
                                int32_t offset);
 
int32_t ose_writeBlob(ose_bundle B,
                      int32_t offset,
                      int32_t blobsize,
                      const char * const blob);
 
#ifdef OSE_PROVIDE_TYPE_SYMBOL
#define ose_readSymbol(b, o) ose_readString((b), (o))
#define ose_writeSymbol(b, o, s) ose_writeString((b), (o), (s))
#endif
#ifdef OSE_PROVIDE_TYPE_DOUBLE
double ose_readDouble(ose_constbundle B, int32_t offset);
int32_t ose_writeDouble(ose_bundle B, int32_t offset, double f);
#endif
#ifdef OSE_PROVIDE_TYPE_INT8
#define ose_readInt8(b, o) ose_readInt32((b), (o))
#define ose_writeInt8(b, o, i) ose_writeInt32((b), (o), (i))
#endif
#ifdef OSE_PROVIDE_TYPE_UINT8
#define ose_readUInt8(b, o) ose_readInt32((b), (o))
#define ose_writeUInt8(b, o, i) ose_writeInt32((b), (o), (i))
#endif
#ifdef OSE_PROVIDE_TYPE_INT16
int16_t ose_readInt16(ose_constbundle B, int32_t offset);
int32_t ose_writeInt16(ose_bundle B, int32_t offset, int16_t i);
#endif
#ifdef OSE_PROVIDE_TYPE_UINT16
uint16_t ose_readUInt16(ose_constbundle B, int32_t offset);
int32_t ose_writeUInt16(ose_bundle B,
                        int32_t offset,
                        uint16_t i);
#endif
#ifdef OSE_PROVIDE_TYPE_UINT32
uint32_t ose_readUInt32(ose_constbundle B, int32_t offset);
int32_t ose_writeUInt32(ose_bundle B,
                        int32_t offset,
                        uint32_t i);
#endif
#ifdef OSE_PROVIDE_TYPE_INT64
int64_t ose_readInt64(ose_constbundle B, int32_t offset);
int32_t ose_writeInt64(ose_bundle B, int32_t offset, int64_t i);
#endif
#ifdef OSE_PROVIDE_TYPE_UINT64
uint64_t ose_readUInt64(ose_constbundle B, int32_t offset);
int32_t ose_writeUInt64(ose_bundle B,
                        int32_t offset,
                        uint64_t i);
#endif
 
struct ose_timetag ose_readTimetag(ose_constbundle B,
                                   int32_t offset);
 
int32_t ose_writeTimetag(ose_bundle B,
                         int32_t offset,
                         uint32_t sec,
                         uint32_t fsec);
 
double ose_timetagToDouble(struct ose_timetag tt);
 
struct ose_timetag ose_doubleToTimetag(double d);
 
void * const ose_readAlignedPtr_impl(const char * const b);
 
void * const ose_readAlignedPtr(ose_constbundle B,
                                const int32_t offset);
 
int32_t ose_writeAlignedPtr_impl(char *b,
                                 const void * const ptr);
 
int32_t ose_writeAlignedPtr(ose_bundle B,
                            const int32_t offset,
                            const void * const ptr);
 
void ose_dropAtOffset(ose_bundle B, int32_t offset);
 
int32_t ose_getLastBundleElemOffset(ose_constbundle B);
 
int32_t ose_getBundleElemAddressOffset(ose_constbundle B,
                                       int32_t elemoffset);
 
int32_t ose_getBundleElemTTOffset(ose_constbundle B,
                                  int32_t elemoffset);
 
int32_t ose_getBundleElemPayloadOffset(ose_constbundle B,
                                       int32_t elemoffset);
 
int32_t ose_getFirstOffsetForMatch(ose_constbundle B,
                                   const char * const addr);
 
int32_t ose_getFirstOffsetForPMatch(ose_constbundle B,
                                    const char * const addr);
 
int32_t ose_getFirstOffsetForFullPMatch(ose_constbundle B,
                                        const char * const addr);
 
int32_t ose_getPayloadItemSize_hook(ose_constbundle B,
                                    const char typetag,
                                    const int32_t msg_offset,
                                    const int32_t item_offset);
 
int32_t ose_getPayloadItemSize(ose_constbundle B,
                               char typetag,
                               int32_t msg_offset,
                               int32_t item_offset);
 
int32_t ose_getPayloadItemLength_hook(ose_constbundle B,
                                      const char typetag,
                                      const int32_t msg_offset,
                                      const int32_t item_offset);
int32_t ose_getPayloadItemLength(ose_constbundle B,
                                 char typetag,
                                 int32_t msg_offset,
                                 int32_t item_offset);
 
void ose_getNthPayloadItem(ose_constbundle B,
                           int32_t n,
                           int32_t msg_offset,
                           int32_t *typetags_offset,
                           int32_t *num_typetags,
                           int32_t *last_typetag_offset,
                           int32_t *payload_offset,
                           int32_t *last_payload_item_offset);
 
#ifndef SWIGCSHARP
int32_t ose_writeMessage(ose_bundle B,
                         int32_t offset,
                         const char * const address,
                         int32_t addresslen,
                         int32_t n, ...);
#endif
 
#ifndef SWIGCSHARP
int32_t ose_vwriteMessage(ose_bundle B,
                          int32_t offset,
                          const char * const address,
                          int32_t addresslen,
                          int32_t n,
                          va_list ap);
#endif
 
#ifndef SWIGCSHARP
int32_t ose_computeMessageSize(ose_bundle B,
                               const char * const address,
                               const int32_t addresslen,
                               const int32_t n,
                               ...);
#endif
 
#ifndef SWIGCSHARP
int32_t ose_vcomputeMessageSize(ose_bundle B,
                                const char * const address,
                                const int32_t addresslen,
                                const int32_t n,
                                va_list ap);
#endif
 
int32_t ose_printTypeof0(ose_constbundle B,
                         const int32_t offset,
                         char *buf,
                         int32_t buflen);
int32_t ose_printTypeof1(ose_constbundle B,
                         const int32_t offset,
                         char *buf,
                         int32_t buflen);
int32_t ose_printTypeof2(ose_constbundle B,
                         const int32_t offset,
                         char *buf,
                         int32_t buflen);
 
int ose_typechk0(ose_constbundle B,
                 const char * const pattern);
 
int ose_typechk1(ose_constbundle B,
                 const char * const pattern);
 
int ose_typechk2(ose_constbundle B,
                 const char * const pattern);
 
int ose_typechk0_ex(ose_constbundle B,
                    const char * const pattern,
                    int32_t *elem,
                    int32_t *item);
 
int ose_typechk1_ex(ose_constbundle B,
                    const char * const pattern,
                    int32_t *elem,
                    int32_t *item);
 
int ose_typechk2_ex(ose_constbundle B,
                    const char * const pattern,
                    int32_t *elem,
                    int32_t *item);
int32_t ose_fromString_hook(ose_bundle bundle,
                            char typetag,
                            const char * const str);
 
void ose_registerType_hook(ose_bundle bundle,
                           char typetag,
                           const char * const getPayloadItemLength_addr,
                           ose_getPayloadItemLengthFn getPayloadItemLength,
                           const char * const getPayloadItemSize_addr,
                           ose_getPayloadItemSizeFn getPayloadItemSize,
                           const char * const pprintPayloadItem_addr,
                           ose_pprintPayloadItemFn pprintPayloadItem,
                           const char * const evalType_addr,
                           void (*evalType)(ose_bundle),
                           const char * const fromString_addr,
                           void (*fromString)(ose_bundle));
 
/* SLIP framing lives in ose_slip.h now. */
 
 
/* The extern "C" block used to close HERE, leaving the three validators
   below outside it. From C++ they took C++ linkage and did not resolve
   against the C definitions -- so ose_validateBundle(),
   ose_validateBundleInternal() and ose_validateMessage() were unusable from
   every C++ host.
 
   They are the boundary functions. Being unreachable from C++ meant the
   hosts most likely to be handed bytes off a socket were the ones that
   could not check them, and one such host's UDP read carried a
   "need to do a sanity check here!" comment where the call belongs. The
   block now closes at the end of the header, where it should have. */
 
int32_t ose_validateBundle(const char * const bytes, const int32_t size);
 
int32_t ose_validateBundleInternal(const char * const bytes,
                                   const int32_t size);
 
int32_t ose_validateMessage(const char * const bytes, const int32_t size);
 
#ifdef __cplusplus
}
#endif
 
 
 
/* INLINE IN A RELEASE BUILD: ose_readInt32, ose_readByte,
   ose_bundleIsEmpty, ose_getBundleElemType and ose_getLastBundleElemOffset.
 
   They are the most called functions in the VM and do almost nothing, and a
   call into another file cannot be inlined without link-time optimisation --
   which a host built as several libraries cannot have across them. Measured
   on one host's heaviest message path, seven of these inline took 20.7 to
   15.7 us; the whole of LTO took it to 13.2.
 
   The functions are still defined and exported, for anything that takes
   their address or calls them from another language. A debug build calls
   them, and gets their asserts. OSE_INLINE_ACCESSORS_OFF turns this off. */
#if !defined(OSE_CONF_DEBUG) && !defined(OSE_INLINE_ACCESSORS_OFF)
#include <string.h>
#include "ose_errno.h"
#include "ose_context.h"
static inline int32_t ose_readInt32_inline(ose_constbundle B, int32_t o)
{ return ose_ntohl(*((const int32_t *)(ose_getBundlePtr(B) + o))); }
static inline char ose_readByte_inline(ose_constbundle B, int32_t o)
{ return ose_getBundlePtr(B)[o]; }
#define ose_readInt32(B, o) ose_readInt32_inline((B), (o))
#define ose_readByte(B, o) ose_readByte_inline((B), (o))
static inline bool ose_bundleIsEmpty_inline(ose_constbundle B)
{ return ose_readSize(B) <= OSE_BUNDLE_HEADER_LEN; }
static inline char ose_getBundleElemType_inline(ose_constbundle B, int32_t o)
{
    const char * const b = ose_getBundlePtr(B) + o + 4;
    return (b[0] == OSE_BUNDLE_ID_[0] && !memcmp(b, OSE_BUNDLE_ID, 8))
        ? OSETT_BUNDLE : OSETT_MESSAGE;
}
static inline int32_t ose_getLastBundleElemOffset_inline(ose_constbundle B)
{
    const int32_t bs = ose_readSize(B);
    int32_t o = OSE_BUNDLE_HEADER_LEN, s;
    if(bs == OSE_BUNDLE_HEADER_LEN)
    {
        return OSE_BUNDLE_HEADER_LEN;
    }
    s = ose_readInt32(B, o);
    while(o + s + 4 < bs)
    {
        if(s <= 0)
        {
            ose_context_set_status((ose_bundle)B, OSE_ERR_MALFORMED);
            return o;
        }
        o += s + 4;
        s = ose_readInt32(B, o);
    }
    return o;
}
#define ose_bundleIsEmpty(B) ose_bundleIsEmpty_inline(B)
#define ose_getBundleElemType(B, o) ose_getBundleElemType_inline((B), (o))
#define ose_getLastBundleElemOffset(B) ose_getLastBundleElemOffset_inline(B)
#endif
 
#endif