bintools.c

Open DMT Client C Source code

// ----------------------------------------------------------------------------
// Copyright 2006-2007, Martin D. Flynn
// All rights reserved
// ----------------------------------------------------------------------------
//
// 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.
//
// ----------------------------------------------------------------------------
// Description:
//  Binary encoding/decoding. 
//  Tools to encode/decode binary data.
// ---
// Change History:
//  2006/01/04  Martin D. Flynn
//     -Initial release
//  2007/01/28  Martin D. Flynn
//     -WindowsCE port.
//     -Added 'p' format to support "padded" strings.
// ----------------------------------------------------------------------------

#include "stdafx.h" // TARGET_WINCE
#define SKIP_TRANSPORT_MEDIA_CHECK // only if TRANSPORT_MEDIA not used in this file 
#include "custom/defaults.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>

#include "custom/log.h"

#include "tools/stdtypes.h"
#include "tools/strtools.h"
#include "tools/gpstools.h"
#include "tools/bintools.h"

// ----------------------------------------------------------------------------

/* initialize buffer */
Buffer_t *binBuffer(Buffer_t *bf, UInt8 *data, UInt16 dataSize, BufferType_t type)
{
    if (bf) {
        BUFFER_TYPE(bf)         = type;
        BUFFER_PTR(bf)          = data;
        BUFFER_PTR_SIZE(bf)     = dataSize;
        BUFFER_DATA_SIZE(bf)    = dataSize;
        BUFFER_DATA_LENGTH(bf)  = (type == BUFFER_SOURCE)? dataSize : 0;
        BUFFER_DATA(bf)         = data;
    }
    return bf;
}

/* reset buffer to initial state */
void binResetBuffer(Buffer_t *bf)
{
    if (bf) {
        BUFFER_DATA(bf)= BUFFER_PTR(bf);
        if (BUFFER_TYPE(bf) == BUFFER_SOURCE) {
            BUFFER_DATA_LENGTH(bf) = (UInt16)BUFFER_PTR_SIZE(bf);
            BUFFER_DATA_SIZE(bf)   = (UInt16)BUFFER_PTR_SIZE(bf);
        } else
        if (BUFFER_TYPE(bf) == BUFFER_DESTINATION) {
            BUFFER_DATA_LENGTH(bf) = (UInt16)0;
            BUFFER_DATA_SIZE(bf)   = (UInt16)BUFFER_PTR_SIZE(bf);
        }
    }
}

/* advance buffer pointer by 'len' bytes */
void binAdvanceBuffer(Buffer_t *bf, int len)
{
    // data is being removed from this buffer
    if (bf && (len > 0)) {
        BUFFER_DATA(bf) += len; // move pointer to next field
        if (BUFFER_TYPE(bf) == BUFFER_SOURCE) {
            // data is being removed from this buffer
            // 'dataLen' is the number of bytes still available in buffer
            if (len > BUFFER_DATA_LENGTH(bf)) { len = BUFFER_DATA_LENGTH(bf); }
            BUFFER_DATA_LENGTH(bf) -= len; // remaining length is being decreased
        } else
        if (BUFFER_TYPE(bf) == BUFFER_DESTINATION) {
            // data is being added to this buffer
            // 'dataLen' is the number of bytes we've placed in the buffer
            // 'dataSize' is the number of bytes we have left to place data
            if (len > BUFFER_DATA_SIZE(bf)) { len = BUFFER_DATA_SIZE(bf); }
            BUFFER_DATA_LENGTH(bf) += len; // length is being increased
            BUFFER_DATA_SIZE(bf)   -= len; // remaining size is being decreased
        }
    }
}

// ----------------------------------------------------------------------------

/* initialize buffer */
FmtBuffer_t *binFmtBuffer(FmtBuffer_t *fb, UInt8 *data, UInt16 dataSize, char *fmt, UInt16 fmtSize)
{
    if (fb) {
        binBuffer((Buffer_t*)fb, data, dataSize, BUFFER_DESTINATION); // always destination
        fb->fmtSize  = fmtSize;
        fb->fmtLen   = 0;
        fb->fmtPtr   = (UInt8*)fmt;
        fb->fmt      = fmt;
    }
    return fb;
}

// ----------------------------------------------------------------------------

void binAppendFmtField(FmtBuffer_t *fb, UInt16 len, char ch)
{
    if (fb && fb->fmt && (fb->fmtSize >= 6)) {
        sprintf(fb->fmt, "%%%d%c", len, ch);
        int slen     = strlen(fb->fmt);
        fb->fmt     += slen;
        fb->fmtLen  += slen;
        fb->fmtSize -= slen;
    }
}

void binAppendFmt(FmtBuffer_t *fb, const char *fmt)
{
    int fmtLen = strlen(fmt);
    if (fb && fb->fmt && (fb->fmtSize >= fmtLen)) {
        strcpy(fb->fmt, fmt);
        fb->fmt     += fmtLen;
        fb->fmtLen  += fmtLen;
        fb->fmtSize -= fmtLen;
    }
}

// ----------------------------------------------------------------------------

/* advance buffer pointer by 'len' bytes */
void binAdvanceFmtBuffer(FmtBuffer_t *fb, int len)
{
    binAdvanceBuffer((Buffer_t*)fb, len);
}

// ----------------------------------------------------------------------------

// return the minimum number of bytes that will accuately represent this value
// The return value will be at-least 1, and at most 4
int binGetMinimumInt32Size(UInt32 val, utBool isSigned)
{
    UInt8 mask = (isSigned && (val & 0x80000000L))? 0xFF : 0x00;
    int n;
    for (n = 3; n >= 1; n--) { // <-- only look at the 3 most-significant bytes
        UInt8 x = (UInt8)((val >> (n * 8)) & 0xFF);
        if (x != mask) { break; }
    }
    // 'n' will be '0' if no 'mismatch' was found, thus returning '1'
    return n + 1;
}

// ----------------------------------------------------------------------------

/* encode 32-bit value into byte array (Big-Endian) */
UInt8 *binEncodeInt32(UInt8 *buf, int cnt, UInt32 val, utBool signExtend)
{
    // - This function places the least-significant bytes of the value 'val' into the
    // byte array 'buf'. It is left to the developer to ensure that the size of the
    // buffer is large enough to accomodate the value stored in 'val'.
    // - 'signExtend' is needed only if 'cnt' is > 4.
    if (buf && (cnt > 0)) {
        
        /* fill excess space */
        if (cnt > 4) {
            UInt8 fill = (signExtend && (val & 0x80000000L))? 0xFF : 0x00;
            memset(buf, cnt - 4, fill);
            buf += cnt - 4;
            cnt = 4;
        }

        /* copy in value */
        int n;
        for (n = cnt - 1; n >= 0; n--) {
            buf[n] = (UInt8)(val & 0xFF);
            val >>= 8;
        }
        
    }
    
    return buf;
}

/* decode byte array into 32-bit value (Native-Endian) */
UInt32 binDecodeInt32(const UInt8 *buf, int cnt, utBool signExtend)
{
    // This function decodes the numeric value in 'buf' and returns the resulting
    // value as a 32-bit unsigned integer.  If 'signExtend' is true, then sign
    // extension will be performed and the returned value can be cast to a signed
    // integer to obtain a signed value.
    if (buf && (cnt > 0)) {
        UInt32 val = (signExtend && (buf[0] & 0x80))? -1L : 0L;
        int n;
        for (n = 0; n < cnt; n++) {
            val = (val << 8) | buf[n];
        }
        return val;
    } else {
        return 0L;
    }
}

// ----------------------------------------------------------------------------
// Binary format:
//      %<length><type>
// Length:
//      0..X - fixed field length specifier
//      *    - variable field length specifier (argument MUST be of type 'int')
// Valid types:
//      i - signed integer (argument MUST be of type UInt32 or Int32)
//      u - unsigned integer (argument MUST be of type UInt32 or Int32)
//      x - unsigned integer (argument MUST be of type UInt32 or Int32)
//      s - null terminated string (argument must be a pointer to a null-terminated string)
//      b - fixed length binary (argument must be a pointer to a byte array)
//      g - gps point (argument MUST be a pointer to a GPSShort_t structure)
//      z - zero-filled field (no argument)
// Example:
//      This will place the 2 LSBs of 'a', followed by at-most the first 5 bytes of 's'
//      into the specified buffer:
//          binPrintf(buf, sizeof(buf), "%2u%*s", (UInt32)a, 5, s);
// Notes:
//      - The compiler won't validate the format against the actual argument types as it
//      does with the 'printf' and 'scanf' functions, so special care must be taken to
//      insure that all numeric arguments are always specified as 32-bit variables, and 
//      lengths are specified as 16-bit variables.

int binPrintf(UInt8 *buf, int bufSize, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    FmtBuffer_t bb,*fb=binFmtBuffer(&bb,buf,bufSize,(char*)0,0); // BUFFER_DESTINATION
    int len = binFmtVPrintf(fb, fmt, ap);
    va_end(ap);
    return len;
}

int binBufPrintf(Buffer_t *buf, const char *fmt, ...)
{
    if (buf && (BUFFER_TYPE(buf) == BUFFER_DESTINATION)) {
        va_list ap;
        va_start(ap, fmt);
        FmtBuffer_t bb,*fb=binFmtBuffer(&bb,BUFFER_DATA(buf),BUFFER_DATA_SIZE(buf),(char*)0,0);
        int len = binFmtVPrintf(fb, fmt, ap);
        if (len >= 0) {
            binAdvanceBuffer(buf, len);
        }
        va_end(ap);
        return len;
    } else {
        logERROR(LOGSRC,"Buffer is not designated for BUFFER_DESTINATION\n");
        return -1;
    }
}

int binFmtPrintf(FmtBuffer_t *fb, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    int len = binFmtVPrintf(fb, fmt, ap);
    va_end(ap);
    return len;
}

int binVPrintf(UInt8 *buf, UInt16 bufSize, const char *fmt, va_list ap)
{
    FmtBuffer_t bb, *fb = binFmtBuffer(&bb, buf, bufSize, (char*)0, 0);