--- libelwix/inc/elwix/apack.h 2013/06/28 08:39:41 1.1.2.1 +++ libelwix/inc/elwix/apack.h 2022/09/26 19:39:23 1.11 @@ -1,6 +1,321 @@ +/************************************************************************* +* (C) 2013 AITNET ltd - Sofia/Bulgaria - +* by Michael Pounov +* +* $Author: misho $ +* $Id: apack.h,v 1.11 2022/09/26 19:39:23 misho Exp $ +* +************************************************************************** +The ELWIX and AITNET software is distributed under the following +terms: + +All of the documentation and software included in the ELWIX and AITNET +Releases is copyrighted by ELWIX - Sofia/Bulgaria + +Copyright 2004 - 2022 + by Michael Pounov . All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. All advertising materials mentioning features or use of this software + must display the following acknowledgement: +This product includes software developed by Michael Pounov +ELWIX - Embedded LightWeight unIX and its contributors. +4. Neither the name of AITNET nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. +*/ #ifndef __APACK_H #define __APACK_H + +typedef struct tagRawPacket { + size_t r_len; + uint8_t *r_buf; + uint8_t *r_next; +} rpack_t; + +#define RPACK_INITIALIZER { .r_len = 0, .r_buf = NULL, .r_next = NULL } +#define RPACK_FREE(x) (assert((x)), memset((x), 0, sizeof(rpack_t))) +#define RPACK_INIT(x, b, l) do { assert((x)); RPACK_FREE(x); \ + (x)->r_buf = (b); \ + (x)->r_len = (l); \ + (x)->r_next = (x)->r_buf; \ + } while (0) +#define RPACK_SANITY(x) ((x) && (x)->r_buf && (x)->r_next && (x)->r_next >= (x)->r_buf) +#define RPACK_BUF(x) (assert((x)), (x)->r_buf) +#define RPACK_NEXT(x) (assert((x)), (x)->r_next) +#define RPACK_LEN(x) (assert((x)), (x)->r_len) +#define RPACK_REWIND(x) (assert((x)), (x)->r_next = (x)->r_buf) +#define RPACK_OFF(x) (assert((x)), (x)->r_next - (x)->r_buf) +#define RPACK_REMAIN(x) (assert((x)), (x)->r_len - ((x)->r_next - (x)->r_buf)) +#define RPACK_ISEND(x) (assert((x)), (size_t) ((x)->r_next - (x)->r_buf) >= (x)->r_len) +#define RPACK_WHEREAMI(x, nx) (assert((x)), (size_t) (((uint8_t*)(nx)) - (x)->r_buf)) + +#define RPACK_SET_16(x, n) do { assert((x)); \ + *((uint8_t *) (x) + 1) = *((const uint8_t *) (n) + 1); \ + *((uint8_t *) (x) + 0) = *((const uint8_t *) (n) + 0); \ + } while (0) +#define RPACK_SET_24(x, n) do { assert((x)); \ + *((uint8_t *) (x) + 2) = *((const uint8_t *) (n) + 2); \ + *((uint8_t *) (x) + 1) = *((const uint8_t *) (n) + 1); \ + *((uint8_t *) (x) + 0) = *((const uint8_t *) (n) + 0); \ + } while (0) +#define RPACK_SET_32(x, n) do { assert((x)); \ + *((uint8_t *) (x) + 3) = *((const uint8_t *) (n) + 3); \ + *((uint8_t *) (x) + 2) = *((const uint8_t *) (n) + 2); \ + *((uint8_t *) (x) + 1) = *((const uint8_t *) (n) + 1); \ + *((uint8_t *) (x) + 0) = *((const uint8_t *) (n) + 0); \ + } while (0) +#define RPACK_SET_64(x, n) do { assert((x)); \ + *((uint8_t *) (x) + 7) = *((const uint8_t *) (n) + 7); \ + *((uint8_t *) (x) + 6) = *((const uint8_t *) (n) + 6); \ + *((uint8_t *) (x) + 5) = *((const uint8_t *) (n) + 5); \ + *((uint8_t *) (x) + 4) = *((const uint8_t *) (n) + 4); \ + *((uint8_t *) (x) + 3) = *((const uint8_t *) (n) + 3); \ + *((uint8_t *) (x) + 2) = *((const uint8_t *) (n) + 2); \ + *((uint8_t *) (x) + 1) = *((const uint8_t *) (n) + 1); \ + *((uint8_t *) (x) + 0) = *((const uint8_t *) (n) + 0); \ + } while (0) + +#define EXTRACT_LE_8(x) (assert((x)), *(x)) +#define EXTRACT_LE_16(x) (assert((x)), (u_int16_t) ( \ + (uint16_t) *((const uint8_t *) (x) + 1) << 8 | \ + (uint16_t) *((const uint8_t *) (x) + 0) \ + )) +#define EXTRACT_LE_24(x) (assert((x)), (u_int32_t) ( \ + (uint32_t) *((const uint8_t *) (x) + 2) << 16 | \ + (uint32_t) *((const uint8_t *) (x) + 1) << 8 | \ + (uint32_t) *((const uint8_t *) (x) + 0) \ + )) +#define EXTRACT_LE_32(x) (assert((x)), (u_int32_t) ( \ + (uint32_t) *((const uint8_t *) (x) + 3) << 24 | \ + (uint32_t) *((const uint8_t *) (x) + 2) << 16 | \ + (uint32_t) *((const uint8_t *) (x) + 1) << 8 | \ + (uint32_t) *((const uint8_t *) (x) + 0) \ + )) +#define EXTRACT_LE_64(x) (assert((x)), (u_int64_t) ( \ + (uint64_t) *((const uint8_t *) (x) + 7) << 56 | \ + (uint64_t) *((const uint8_t *) (x) + 6) << 48 | \ + (uint64_t) *((const uint8_t *) (x) + 5) << 40 | \ + (uint64_t) *((const uint8_t *) (x) + 4) << 32 | \ + (uint64_t) *((const uint8_t *) (x) + 3) << 24 | \ + (uint64_t) *((const uint8_t *) (x) + 2) << 16 | \ + (uint64_t) *((const uint8_t *) (x) + 1) << 8 | \ + (uint64_t) *((const uint8_t *) (x) + 0) \ + )) + +#define EXTRACT_BE_8(x) (assert((x)), *(x)) +#define EXTRACT_BE_16(x) (assert((x)), (u_int16_t) ( \ + (uint16_t) *((const uint8_t *) (x) + 0) << 8 | \ + (uint16_t) *((const uint8_t *) (x) + 1) \ + )) +#define EXTRACT_BE_24(x) (assert((x)), (u_int32_t) ( \ + (uint32_t) *((const uint8_t *) (x) + 0) << 16 | \ + (uint32_t) *((const uint8_t *) (x) + 1) << 8 | \ + (uint32_t) *((const uint8_t *) (x) + 2) \ + )) +#define EXTRACT_BE_32(x) (assert((x)), (u_int32_t) ( \ + (uint32_t) *((const uint8_t *) (x) + 0) << 24 | \ + (uint32_t) *((const uint8_t *) (x) + 1) << 16 | \ + (uint32_t) *((const uint8_t *) (x) + 2) << 8 | \ + (uint32_t) *((const uint8_t *) (x) + 3) \ + )) +#define EXTRACT_BE_64(x) (assert((x)), (u_int64_t) ( \ + (uint64_t) *((const uint8_t *) (x) + 0) << 56 | \ + (uint64_t) *((const uint8_t *) (x) + 1) << 48 | \ + (uint64_t) *((const uint8_t *) (x) + 2) << 40 | \ + (uint64_t) *((const uint8_t *) (x) + 3) << 32 | \ + (uint64_t) *((const uint8_t *) (x) + 4) << 24 | \ + (uint64_t) *((const uint8_t *) (x) + 5) << 16 | \ + (uint64_t) *((const uint8_t *) (x) + 6) << 8 | \ + (uint64_t) *((const uint8_t *) (x) + 7) \ + )) + + +/* + * rpack_align_and_reserve() - Align & reserve space + * + * @rp = raw buffer + * @siz = need size + * return: NULL error or not enough space, !=NULL next position + */ +uint8_t *rpack_align_and_reserve(rpack_t * __restrict rp, size_t siz); +/* + * rpack_next() - Get and set current position + * + * @rp = raw packet + * @after_len = move aligned current position after length + * return: NULL error or current position + */ +uint8_t *rpack_next(rpack_t * __restrict rp, size_t after_len); +/* + * rpack_rnext() - Get and set raw current position + * + * @rp = raw packet + * @after_len = !=0 move current position after length + * return: NULL error or raw current position + */ +uint8_t *rpack_rnext(rpack_t * __restrict rp, size_t after_len); + +/* + * rpack_create() - Allocate & init raw packet structure + * + * @buf = buffer + * @buflen = length of buffer + * return: NULL error or !=NULL raw packet, should be freed by rpack_destroy() + */ +rpack_t *rpack_create(void * __restrict buf, size_t buflen); +/* + * rpack_destroy() - Release & free raw packet structure + * + * @rp = raw packet + * return: none + */ +void rpack_destroy(rpack_t ** __restrict rp); + +/* + * rpack_attach() - Attach dynamic allocating buffer at packet + * + * @rp = raw packet; + * @len = allocate bytes + * return: -1 error or 0 ok, should be detached with rpack_detach() + * before call rpack_destroy() after use! + */ +int rpack_attach(rpack_t * __restrict rp, size_t len); +/* + * rpack_resize() - Resize dynamic allocated buffer at packet + * + * @rp = raw packet + * @newlen = resize buffer to bytes + * return: -1 error or 0 ok, should be detached with rpack_detach() + * before call rpack_destroy() after use! + */ +int rpack_resize(rpack_t * __restrict rp, size_t newlen); +/* + * rpack_detach() - Detach and free dynamic allocated buffer from packet + * + * @rp = raw packet + * return: none + */ +void rpack_detach(rpack_t * __restrict rp); + +/* + * rpack_uint8() - Pack/Unpack 8bit value + * + * @rp = raw buffer + * @n = set value if !=NULL + * return: -1 error or get value + */ +uint8_t rpack_uint8(rpack_t * __restrict rp, uint8_t * __restrict n); +/* + * rpack_uint16() - Pack/Unpack 16bit value + * + * @rp = raw buffer + * @n = set value if !=NULL + * @be = byte order [-1 little endian, 1 big endian and 0 host order] + * return: -1 error or get value + */ +uint16_t rpack_uint16(rpack_t * __restrict rp, uint16_t * __restrict n, int be); +/* + * rpack_ruint16() - Pack/Unpack raw 16bit value + * + * @rp = raw buffer + * @n = set value if !=NULL + * @be = byte order [-1 little endian, 1 big endian and 0 host order] + * return: -1 error or get value + */ +uint16_t rpack_ruint16(rpack_t * __restrict rp, uint16_t * __restrict n, int be); +/* + * rpack_uint24() - Pack/Unpack 24bit value + * + * @rp = raw buffer + * @n = set value if !=NULL + * @be = byte order [-1 little endian, 1 big endian and 0 host order] + * return: -1 error or get value + */ +uint32_t rpack_uint24(rpack_t * __restrict rp, uint32_t * __restrict n, int be); +/* + * rpack_ruint24() - Pack/Unpack raw 24bit value + * + * @rp = raw buffer + * @n = set value if !=NULL + * @be = byte order [-1 little endian, 1 big endian and 0 host order] + * return: -1 error or get value + */ +uint32_t rpack_ruint24(rpack_t * __restrict rp, uint32_t * __restrict n, int be); +/* + * rpack_uint32() - Pack/Unpack 32bit value + * + * @rp = raw buffer + * @n = set value if !=NULL + * @be = byte order [-1 little endian, 1 big endian and 0 host order] + * return: -1 error or get value + */ +uint32_t rpack_uint32(rpack_t * __restrict rp, uint32_t * __restrict n, int be); +/* + * rpack_ruint32() - Pack/Unpack raw 32bit value + * + * @rp = raw buffer + * @n = set value if !=NULL + * @be = byte order [-1 little endian, 1 big endian and 0 host order] + * return: -1 error or get value + */ +uint32_t rpack_ruint32(rpack_t * __restrict rp, uint32_t * __restrict n, int be); +/* + * rpack_uint64() - Pack/Unpack 64bit value + * + * @rp = raw buffer + * @n = set value if !=NULL + * @be = byte order [-1 little endian, 1 big endian and 0 host order] + * return: -1 error or get value + */ +uint64_t rpack_uint64(rpack_t * __restrict rp, uint64_t * __restrict n, int be); +/* + * rpack_ruint64() - Pack/Unpack raw 64bit value + * + * @rp = raw buffer + * @n = set value if !=NULL + * @be = byte order [-1 little endian, 1 big endian and 0 host order] + * return: -1 error or get value + */ +uint64_t rpack_ruint64(rpack_t * __restrict rp, uint64_t * __restrict n, int be); +/* + * rpack_data() - Pack/Unpack align data + * + * @rp = raw buffer + * @dat = data + * @datlen = data length + * return: NULL error or != NULL get data, must be e_free() after use! + */ +void *rpack_data(rpack_t * __restrict rp, void * __restrict dat, size_t datlen); +/* + * rpack_rdata() - Pack/Unpack raw data + * + * @rp = raw buffer + * @dat = data + * @datlen = data length + * return: NULL error or != NULL get data, must be e_free() after use! + */ +void *rpack_rdata(rpack_t * __restrict rp, void * __restrict dat, size_t datlen); #endif