commit a31884d44375d99c1ac47e27150b3b05d42871ef Author: Peter McGoron Date: Mon Sep 26 13:17:04 2022 -0400 start unfinished code diff --git a/README.md b/README.md new file mode 100644 index 0000000..b49d07a --- /dev/null +++ b/README.md @@ -0,0 +1,8 @@ +# spyderta + +Spyderta is a shim program to allow programs designed for Sederta PCI devices +to communicate with a generic IEEE1394 FireWire card by interfacing over the +network to a Linux host. + +NOTE: 1394ethbridge uses a MODIFIED version of libraw1394 that modifies +how memory allocation works. See https://software.mcgoron.com/peter/libraw1394 diff --git a/common/msg.c b/common/msg.c new file mode 100644 index 0000000..d072c7d --- /dev/null +++ b/common/msg.c @@ -0,0 +1,190 @@ +#include +#include "msg.h" + +/* + * send async [1] + * [10: bus][6: node][48 : address][8: tcode][8 : tlabel][16 : len][data ...] + */ +#define SEND_ASYNC_LEN (10 + 6 + 48 + 8 + 8 + 16)/8 + +/* + * send iso [2] + * [8 : channel][8 : tag][8 : synch][16 : len][data ...] + */ +#define SEND_ISO_LEN (8 + 8 + 8 + 16)/8 + +/* + * allocate [3] + * [48: start] [48: len] + */ +#define ALLOCATE_LEN (48 + 48)/8 + +static bool parse_send_async(struct msg_state *st) { + const char *p = st->buf + 1; + const size_t l = sdslen(st->buf) - 1; + + if (l < SEND_ASYNC_LEN) + return false; + st->msg.send_async.len = p[10] << 8 | p[11]; + if (l < SEND_ASYNC_LEN + len) + return false; + + st->msg.send_async.bus = p[0] << 8 | p[1]; + st->msg.send_async.node = bus & 0x3F; + st->msg.send_async.bus >>= 6; + + st->msg.send_async.addr = p[2] << 40 | p[3] << 32 | p[4] << 24 | p[5] << 16 + | p[6] << 8 | p[7]; + st->msg.send_async.tcode = p[8]; + st->msg.send_async.tlabel = p[9]; + st->msg.send_async.buf = p + SEND_ASYNC_LEN; + + (*st->on_read[MSG_SEND_ASYNC])(&st->msg); + + sdsrange(st->buf, SEND_ASYNC_LEN + len, sdslen(st->buf)); + st->state = PARSE_VERSION_MESSAGE; + return true; +} + +static bool parse_version_message(struct msg_state *st) { + if (sdslen(st->buf) == 0) + return false; + + /* Unknown version: ignore byte and continue */ + if (st->buf[0] >> 6 != 0) + return true; + + st->msgtype = st->buf[0] & 0x3F; + switch (st->msgtype) { + case MSG_SEND_ASYNC: + st->state = PARSE_SEND_ASYNC; + break; + case MSG_SEND_ISO: + st->state = PARSE_SEND_ISO; + break; + case MSG_ALLOCATE: + st->state = PARSE_ALLOCATE; + /* Error or noop */ + default: + st->state = PARSE_VERSION_MESSAGE; + break; + } + + return true; +} + +static bool parse_allocate(struct msg_state *st) { + if (l < ALLOCATE_LEN) + return false; + st->msg.allocate.start = p[0] << 40 | p[1] << 32 | p[2] << 24 | p[3] << 16 + | p[4] << 8 | p[5]; + st->msg.allocate.len = p[6] << 40 | p[7] << 32 | p[8] << 24 | p[9] << 16 + | p[10] << 8 | p[11]; + + (*st->on_read[MSG_SEND_ALLOCATE])(&st->msg); + + return true; +} + +static bool parse_send_iso(struct msg_state *st) { + const char *p = st->buf + 1; + const size_t l = sdslen(st->buf) - 1; + + if (l < SEND_ISO_LEN) + return false; + st->msg.send_iso.len = p[3] << 8 | p[4]; + if (l < SEND_ISO_LEN + len) + return false; + + st->msg.send_iso.ch = p[0]; + st->msg.send_iso.tag = p[1]; + st->msg.send_iso.synch = p[2]; + st->msg.send_iso.buf = p + SEND_ISO_LEN; + + (*st->on_read[MSG_SEND_ASYNC])(&st->msg); + + sdsrange(st->buf, SEND_ISO_LEN + len, sdslen(st->buf)); + st->state = PARSE_VERSION_MESSAGE; + return true; +} + +bool parse_packet(struct msg_state *st) { + switch(st->state) { + case PARSE_VERSION_MESSAGE: + return parse_version_message(st); + case PARSE_SEND_ASYNC: + return parse_send_async(st); + case PARSE_ALLOCATE: + return parse_allocate(st); + case PARSE_SEND_ISO: + return parse_send_iso(st); + } +} + +static int sendall(SOCKET sck, unsigned char *msg, size_t msglen) { + int bytes_sent = 0; + do { + int n = send(sck, msg + bytes_sent, msglen - bytes_sent, 0); + if (n == SOCKET_ERROR) { + return 0; + } + + bytes_sent += n; + } while (bytes_sent < msglen); + return 1; +} +int msg_send_alloc(SOCKET sck, uint64_t start, uint64_t len) { + unsigned char *msg; + int r; + + msg = malloc(ALLOCATE_LEN); + msg[0] = MSG_ALLOCATE; + msg[1] = start >> 40 & 0xFF; + msg[2] = start >> 32 & 0xFF; + msg[3] = start >> 24 & 0xFF; + msg[4] = start >> 16 & 0xFF; + msg[5] = start >> 8 & 0xFF; + msg[6] = start & 0xFF; + + msg[7] = len >> 40 & 0xFF; + msg[8] = len >> 32 & 0xFF; + msg[9] = len >> 24 & 0xFF; + msg[10] = len >> 16 & 0xFF; + msg[11] = len >> 8 & 0xFF; + msg[12] = len & 0xFF; + + r = sendall(sck, msg, ALLOCATE_LEN); + free(msg); + return r; +} + +int msg_send_async(SOCKET sck, uint16_t bus, uint8_t node, uint64_t addr, + uint8_t tcode, uint8_t tag, uint16_t len, void *data) { + unsigned char *msg; + size_t msglen = SEND_ASYNC_LEN + 1 + len; + int r; + + msg = malloc(msglen); + msg[0] = MSG_SEND_ASYNC; + + msg[1] = buf >> 8; + msg[2] = (bus & 0x3F << 6) | node; + msg[3] = (addr >> 40) & 0xFF; + msg[4] = (addr >> 32) & 0xFF; + msg[5] = (addr >> 24) & 0xFF; + msg[6] = (addr >> 16) & 0xFF; + msg[7] = (addr >> 8) & 0xFF; + msg[8] = addr & 0xFF; + + msg[9] = tcode; + msg[10] = tag; + msg[11] = len >> 8; + msg[12] = len & 0xFF; + + if (data) + memcpy(msg + 13, data, len); + + r = sendall(sck, msg, msglen); + free(msg); + return r; +} diff --git a/common/msg.h b/common/msg.h new file mode 100644 index 0000000..c68f699 --- /dev/null +++ b/common/msg.h @@ -0,0 +1,72 @@ +#include "sds.h" + +#ifdef WINDOWS +# include +#else +# include +# include +typedef int SOCKET; +#endif + +union msg { + struct { + uint16_t bus; + uint8_t node; + uint64_t addr; + uint8_t tcode; + uint8_t tlabel; + uint8_t extcode; + uint16_t len; + char *buf; + } send_async; + + struct { + uint8_t ch; + uint8_t tag; + uint8_t synch; + uint16_t len; + char *buf; + } iso; + + struct { + uint64_t start; + uint64_t length; + } allocate; +}; + +enum { + MSG_SEND_INVALID = -1, + MSG_NOOP = 0, + MSG_SEND_ASYNC = 1, + MSG_SEND_ISO = 2, + MSG_ALLOCATE = 3, + MSG_TYPES_LEN +}; + +enum parsestate { + PARSE_VERSION_MESSAGE, + PARSE_SEND_ASYNC, + PARSE_SEND_ISO, + PARSE_ALLOCATE +} + +typedef void (*msg_exec)(int, union msg *); + +struct msg_state { + char *buf; + enum msgtype type; + + int msgtype; + union msg msg; + + enum parsestate state; + + msg_exec on_read[MSG_TYPES_LEN]; +}; + +/* Message Header: + [2 : version][6 : message] + + * noop [0] + * (none) + */ diff --git a/common/sds.c b/common/sds.c new file mode 100644 index 0000000..f60ce59 --- /dev/null +++ b/common/sds.c @@ -0,0 +1,1313 @@ +/* SDSLib 2.0 -- A C dynamic strings library + * + * Copyright (c) 2006-2015, Salvatore Sanfilippo + * Copyright (c) 2015, Oran Agra + * Copyright (c) 2015, Redis Labs, Inc + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Redis 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 THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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. + */ + +#include +#include +#include +#include +#include +#include +#include "sds.h" + +const char *SDS_NOINIT = "SDS_NOINIT"; + +static inline int sdsHdrSize(char type) { + switch(type&SDS_TYPE_MASK) { + case SDS_TYPE_5: + return sizeof(struct sdshdr5); + case SDS_TYPE_8: + return sizeof(struct sdshdr8); + case SDS_TYPE_16: + return sizeof(struct sdshdr16); + case SDS_TYPE_32: + return sizeof(struct sdshdr32); + case SDS_TYPE_64: + return sizeof(struct sdshdr64); + } + return 0; +} + +static inline char sdsReqType(size_t string_size) { + if (string_size < 1<<5) + return SDS_TYPE_5; + if (string_size < 1<<8) + return SDS_TYPE_8; + if (string_size < 1<<16) + return SDS_TYPE_16; +#if (LONG_MAX == LLONG_MAX) + if (string_size < 1ll<<32) + return SDS_TYPE_32; + return SDS_TYPE_64; +#else + return SDS_TYPE_32; +#endif +} + +/* Create a new sds string with the content specified by the 'init' pointer + * and 'initlen'. + * If NULL is used for 'init' the string is initialized with zero bytes. + * If SDS_NOINIT is used, the buffer is left uninitialized; + * + * The string is always null-termined (all the sds strings are, always) so + * even if you create an sds string with: + * + * mystring = sdsnewlen("abc",3); + * + * You can print the string with printf() as there is an implicit \0 at the + * end of the string. However the string is binary safe and can contain + * \0 characters in the middle, as the length is stored in the sds header. */ +sds sdsnewlen(const void *init, size_t initlen) { + void *sh; + sds s; + char type = sdsReqType(initlen); + /* Empty strings are usually created in order to append. Use type 8 + * since type 5 is not good at this. */ + if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8; + int hdrlen = sdsHdrSize(type); + unsigned char *fp; /* flags pointer. */ + + sh = s_malloc(hdrlen+initlen+1); + if (sh == NULL) return NULL; + if (init==SDS_NOINIT) + init = NULL; + else if (!init) + memset(sh, 0, hdrlen+initlen+1); + s = (char*)sh+hdrlen; + fp = ((unsigned char*)s)-1; + switch(type) { + case SDS_TYPE_5: { + *fp = type | (initlen << SDS_TYPE_BITS); + break; + } + case SDS_TYPE_8: { + SDS_HDR_VAR(8,s); + sh->len = initlen; + sh->alloc = initlen; + *fp = type; + break; + } + case SDS_TYPE_16: { + SDS_HDR_VAR(16,s); + sh->len = initlen; + sh->alloc = initlen; + *fp = type; + break; + } + case SDS_TYPE_32: { + SDS_HDR_VAR(32,s); + sh->len = initlen; + sh->alloc = initlen; + *fp = type; + break; + } + case SDS_TYPE_64: { + SDS_HDR_VAR(64,s); + sh->len = initlen; + sh->alloc = initlen; + *fp = type; + break; + } + } + if (initlen && init) + memcpy(s, init, initlen); + s[initlen] = '\0'; + return s; +} + +/* Create an empty (zero length) sds string. Even in this case the string + * always has an implicit null term. */ +sds sdsempty(void) { + return sdsnewlen("",0); +} + +/* Create a new sds string starting from a null terminated C string. */ +sds sdsnew(const char *init) { + size_t initlen = (init == NULL) ? 0 : strlen(init); + return sdsnewlen(init, initlen); +} + +/* Duplicate an sds string. */ +sds sdsdup(const sds s) { + return sdsnewlen(s, sdslen(s)); +} + +/* Free an sds string. No operation is performed if 's' is NULL. */ +void sdsfree(sds s) { + if (s == NULL) return; + s_free((char*)s-sdsHdrSize(s[-1])); +} + +/* Set the sds string length to the length as obtained with strlen(), so + * considering as content only up to the first null term character. + * + * This function is useful when the sds string is hacked manually in some + * way, like in the following example: + * + * s = sdsnew("foobar"); + * s[2] = '\0'; + * sdsupdatelen(s); + * printf("%d\n", sdslen(s)); + * + * The output will be "2", but if we comment out the call to sdsupdatelen() + * the output will be "6" as the string was modified but the logical length + * remains 6 bytes. */ +void sdsupdatelen(sds s) { + size_t reallen = strlen(s); + sdssetlen(s, reallen); +} + +/* Modify an sds string in-place to make it empty (zero length). + * However all the existing buffer is not discarded but set as free space + * so that next append operations will not require allocations up to the + * number of bytes previously available. */ +void sdsclear(sds s) { + sdssetlen(s, 0); + s[0] = '\0'; +} + +/* Enlarge the free space at the end of the sds string so that the caller + * is sure that after calling this function can overwrite up to addlen + * bytes after the end of the string, plus one more byte for nul term. + * + * Note: this does not change the *length* of the sds string as returned + * by sdslen(), but only the free buffer space we have. */ +sds sdsMakeRoomFor(sds s, size_t addlen) { + void *sh, *newsh; + size_t avail = sdsavail(s); + size_t len, newlen; + char type, oldtype = s[-1] & SDS_TYPE_MASK; + int hdrlen; + + /* Return ASAP if there is enough space left. */ + if (avail >= addlen) return s; + + len = sdslen(s); + sh = (char*)s-sdsHdrSize(oldtype); + newlen = (len+addlen); + if (newlen < SDS_MAX_PREALLOC) + newlen *= 2; + else + newlen += SDS_MAX_PREALLOC; + + type = sdsReqType(newlen); + + /* Don't use type 5: the user is appending to the string and type 5 is + * not able to remember empty space, so sdsMakeRoomFor() must be called + * at every appending operation. */ + if (type == SDS_TYPE_5) type = SDS_TYPE_8; + + hdrlen = sdsHdrSize(type); + if (oldtype==type) { + newsh = s_realloc(sh, hdrlen+newlen+1); + if (newsh == NULL) return NULL; + s = (char*)newsh+hdrlen; + } else { + /* Since the header size changes, need to move the string forward, + * and can't use realloc */ + newsh = s_malloc(hdrlen+newlen+1); + if (newsh == NULL) return NULL; + memcpy((char*)newsh+hdrlen, s, len+1); + s_free(sh); + s = (char*)newsh+hdrlen; + s[-1] = type; + sdssetlen(s, len); + } + sdssetalloc(s, newlen); + return s; +} + +/* Reallocate the sds string so that it has no free space at the end. The + * contained string remains not altered, but next concatenation operations + * will require a reallocation. + * + * After the call, the passed sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. */ +sds sdsRemoveFreeSpace(sds s) { + void *sh, *newsh; + char type, oldtype = s[-1] & SDS_TYPE_MASK; + int hdrlen, oldhdrlen = sdsHdrSize(oldtype); + size_t len = sdslen(s); + size_t avail = sdsavail(s); + sh = (char*)s-oldhdrlen; + + /* Return ASAP if there is no space left. */ + if (avail == 0) return s; + + /* Check what would be the minimum SDS header that is just good enough to + * fit this string. */ + type = sdsReqType(len); + hdrlen = sdsHdrSize(type); + + /* If the type is the same, or at least a large enough type is still + * required, we just realloc(), letting the allocator to do the copy + * only if really needed. Otherwise if the change is huge, we manually + * reallocate the string to use the different header type. */ + if (oldtype==type || type > SDS_TYPE_8) { + newsh = s_realloc(sh, oldhdrlen+len+1); + if (newsh == NULL) return NULL; + s = (char*)newsh+oldhdrlen; + } else { + newsh = s_malloc(hdrlen+len+1); + if (newsh == NULL) return NULL; + memcpy((char*)newsh+hdrlen, s, len+1); + s_free(sh); + s = (char*)newsh+hdrlen; + s[-1] = type; + sdssetlen(s, len); + } + sdssetalloc(s, len); + return s; +} + +/* Return the total size of the allocation of the specified sds string, + * including: + * 1) The sds header before the pointer. + * 2) The string. + * 3) The free buffer at the end if any. + * 4) The implicit null term. + */ +size_t sdsAllocSize(sds s) { + size_t alloc = sdsalloc(s); + return sdsHdrSize(s[-1])+alloc+1; +} + +/* Return the pointer of the actual SDS allocation (normally SDS strings + * are referenced by the start of the string buffer). */ +void *sdsAllocPtr(sds s) { + return (void*) (s-sdsHdrSize(s[-1])); +} + +/* Increment the sds length and decrements the left free space at the + * end of the string according to 'incr'. Also set the null term + * in the new end of the string. + * + * This function is used in order to fix the string length after the + * user calls sdsMakeRoomFor(), writes something after the end of + * the current string, and finally needs to set the new length. + * + * Note: it is possible to use a negative increment in order to + * right-trim the string. + * + * Usage example: + * + * Using sdsIncrLen() and sdsMakeRoomFor() it is possible to mount the + * following schema, to cat bytes coming from the kernel to the end of an + * sds string without copying into an intermediate buffer: + * + * oldlen = sdslen(s); + * s = sdsMakeRoomFor(s, BUFFER_SIZE); + * nread = read(fd, s+oldlen, BUFFER_SIZE); + * ... check for nread <= 0 and handle it ... + * sdsIncrLen(s, nread); + */ +void sdsIncrLen(sds s, ssize_t incr) { + unsigned char flags = s[-1]; + size_t len; + switch(flags&SDS_TYPE_MASK) { + case SDS_TYPE_5: { + unsigned char *fp = ((unsigned char*)s)-1; + unsigned char oldlen = SDS_TYPE_5_LEN(flags); + assert((incr > 0 && oldlen+incr < 32) || (incr < 0 && oldlen >= (unsigned int)(-incr))); + *fp = SDS_TYPE_5 | ((oldlen+incr) << SDS_TYPE_BITS); + len = oldlen+incr; + break; + } + case SDS_TYPE_8: { + SDS_HDR_VAR(8,s); + assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr))); + len = (sh->len += incr); + break; + } + case SDS_TYPE_16: { + SDS_HDR_VAR(16,s); + assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr))); + len = (sh->len += incr); + break; + } + case SDS_TYPE_32: { + SDS_HDR_VAR(32,s); + assert((incr >= 0 && sh->alloc-sh->len >= (unsigned int)incr) || (incr < 0 && sh->len >= (unsigned int)(-incr))); + len = (sh->len += incr); + break; + } + case SDS_TYPE_64: { + SDS_HDR_VAR(64,s); + assert((incr >= 0 && sh->alloc-sh->len >= (uint64_t)incr) || (incr < 0 && sh->len >= (uint64_t)(-incr))); + len = (sh->len += incr); + break; + } + default: len = 0; /* Just to avoid compilation warnings. */ + } + s[len] = '\0'; +} + +/* Grow the sds to have the specified length. Bytes that were not part of + * the original length of the sds will be set to zero. + * + * if the specified length is smaller than the current length, no operation + * is performed. */ +sds sdsgrowzero(sds s, size_t len) { + size_t curlen = sdslen(s); + + if (len <= curlen) return s; + s = sdsMakeRoomFor(s,len-curlen); + if (s == NULL) return NULL; + + /* Make sure added region doesn't contain garbage */ + memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */ + sdssetlen(s, len); + return s; +} + +/* Append the specified binary-safe string pointed by 't' of 'len' bytes to the + * end of the specified sds string 's'. + * + * After the call, the passed sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. */ +sds sdscatlen(sds s, const void *t, size_t len) { + size_t curlen = sdslen(s); + + s = sdsMakeRoomFor(s,len); + if (s == NULL) return NULL; + memcpy(s+curlen, t, len); + sdssetlen(s, curlen+len); + s[curlen+len] = '\0'; + return s; +} + +/* Append the specified null termianted C string to the sds string 's'. + * + * After the call, the passed sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. */ +sds sdscat(sds s, const char *t) { + return sdscatlen(s, t, strlen(t)); +} + +/* Append the specified sds 't' to the existing sds 's'. + * + * After the call, the modified sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. */ +sds sdscatsds(sds s, const sds t) { + return sdscatlen(s, t, sdslen(t)); +} + +/* Destructively modify the sds string 's' to hold the specified binary + * safe string pointed by 't' of length 'len' bytes. */ +sds sdscpylen(sds s, const char *t, size_t len) { + if (sdsalloc(s) < len) { + s = sdsMakeRoomFor(s,len-sdslen(s)); + if (s == NULL) return NULL; + } + memcpy(s, t, len); + s[len] = '\0'; + sdssetlen(s, len); + return s; +} + +/* Like sdscpylen() but 't' must be a null-termined string so that the length + * of the string is obtained with strlen(). */ +sds sdscpy(sds s, const char *t) { + return sdscpylen(s, t, strlen(t)); +} + +/* Helper for sdscatlonglong() doing the actual number -> string + * conversion. 's' must point to a string with room for at least + * SDS_LLSTR_SIZE bytes. + * + * The function returns the length of the null-terminated string + * representation stored at 's'. */ +#define SDS_LLSTR_SIZE 21 +int sdsll2str(char *s, long long value) { + char *p, aux; + unsigned long long v; + size_t l; + + /* Generate the string representation, this method produces + * an reversed string. */ + v = (value < 0) ? -value : value; + p = s; + do { + *p++ = '0'+(v%10); + v /= 10; + } while(v); + if (value < 0) *p++ = '-'; + + /* Compute length and add null term. */ + l = p-s; + *p = '\0'; + + /* Reverse the string. */ + p--; + while(s < p) { + aux = *s; + *s = *p; + *p = aux; + s++; + p--; + } + return l; +} + +/* Identical sdsll2str(), but for unsigned long long type. */ +int sdsull2str(char *s, unsigned long long v) { + char *p, aux; + size_t l; + + /* Generate the string representation, this method produces + * an reversed string. */ + p = s; + do { + *p++ = '0'+(v%10); + v /= 10; + } while(v); + + /* Compute length and add null term. */ + l = p-s; + *p = '\0'; + + /* Reverse the string. */ + p--; + while(s < p) { + aux = *s; + *s = *p; + *p = aux; + s++; + p--; + } + return l; +} + +/* Create an sds string from a long long value. It is much faster than: + * + * sdscatprintf(sdsempty(),"%lld\n", value); + */ +sds sdsfromlonglong(long long value) { + char buf[SDS_LLSTR_SIZE]; + int len = sdsll2str(buf,value); + + return sdsnewlen(buf,len); +} + +/* Like sdscatprintf() but gets va_list instead of being variadic. */ +sds sdscatvprintf(sds s, const char *fmt, va_list ap) { + va_list cpy; + char staticbuf[1024], *buf = staticbuf, *t; + size_t buflen = strlen(fmt)*2; + + /* We try to start using a static buffer for speed. + * If not possible we revert to heap allocation. */ + if (buflen > sizeof(staticbuf)) { + buf = s_malloc(buflen); + if (buf == NULL) return NULL; + } else { + buflen = sizeof(staticbuf); + } + + /* Try with buffers two times bigger every time we fail to + * fit the string in the current buffer size. */ + while(1) { + buf[buflen-2] = '\0'; + va_copy(cpy,ap); + vsnprintf(buf, buflen, fmt, cpy); + va_end(cpy); + if (buf[buflen-2] != '\0') { + if (buf != staticbuf) s_free(buf); + buflen *= 2; + buf = s_malloc(buflen); + if (buf == NULL) return NULL; + continue; + } + break; + } + + /* Finally concat the obtained string to the SDS string and return it. */ + t = sdscat(s, buf); + if (buf != staticbuf) s_free(buf); + return t; +} + +/* Append to the sds string 's' a string obtained using printf-alike format + * specifier. + * + * After the call, the modified sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. + * + * Example: + * + * s = sdsnew("Sum is: "); + * s = sdscatprintf(s,"%d+%d = %d",a,b,a+b). + * + * Often you need to create a string from scratch with the printf-alike + * format. When this is the need, just use sdsempty() as the target string: + * + * s = sdscatprintf(sdsempty(), "... your format ...", args); + */ +sds sdscatprintf(sds s, const char *fmt, ...) { + va_list ap; + char *t; + va_start(ap, fmt); + t = sdscatvprintf(s,fmt,ap); + va_end(ap); + return t; +} + +/* This function is similar to sdscatprintf, but much faster as it does + * not rely on sprintf() family functions implemented by the libc that + * are often very slow. Moreover directly handling the sds string as + * new data is concatenated provides a performance improvement. + * + * However this function only handles an incompatible subset of printf-alike + * format specifiers: + * + * %s - C String + * %S - SDS string + * %i - signed int + * %I - 64 bit signed integer (long long, int64_t) + * %u - unsigned int + * %U - 64 bit unsigned integer (unsigned long long, uint64_t) + * %% - Verbatim "%" character. + */ +sds sdscatfmt(sds s, char const *fmt, ...) { + size_t initlen = sdslen(s); + const char *f = fmt; + long i; + va_list ap; + + /* To avoid continuous reallocations, let's start with a buffer that + * can hold at least two times the format string itself. It's not the + * best heuristic but seems to work in practice. */ + s = sdsMakeRoomFor(s, initlen + strlen(fmt)*2); + va_start(ap,fmt); + f = fmt; /* Next format specifier byte to process. */ + i = initlen; /* Position of the next byte to write to dest str. */ + while(*f) { + char next, *str; + size_t l; + long long num; + unsigned long long unum; + + /* Make sure there is always space for at least 1 char. */ + if (sdsavail(s)==0) { + s = sdsMakeRoomFor(s,1); + } + + switch(*f) { + case '%': + next = *(f+1); + f++; + switch(next) { + case 's': + case 'S': + str = va_arg(ap,char*); + l = (next == 's') ? strlen(str) : sdslen(str); + if (sdsavail(s) < l) { + s = sdsMakeRoomFor(s,l); + } + memcpy(s+i,str,l); + sdsinclen(s,l); + i += l; + break; + case 'i': + case 'I': + if (next == 'i') + num = va_arg(ap,int); + else + num = va_arg(ap,long long); + { + char buf[SDS_LLSTR_SIZE]; + l = sdsll2str(buf,num); + if (sdsavail(s) < l) { + s = sdsMakeRoomFor(s,l); + } + memcpy(s+i,buf,l); + sdsinclen(s,l); + i += l; + } + break; + case 'u': + case 'U': + if (next == 'u') + unum = va_arg(ap,unsigned int); + else + unum = va_arg(ap,unsigned long long); + { + char buf[SDS_LLSTR_SIZE]; + l = sdsull2str(buf,unum); + if (sdsavail(s) < l) { + s = sdsMakeRoomFor(s,l); + } + memcpy(s+i,buf,l); + sdsinclen(s,l); + i += l; + } + break; + default: /* Handle %% and generally %. */ + s[i++] = next; + sdsinclen(s,1); + break; + } + break; + default: + s[i++] = *f; + sdsinclen(s,1); + break; + } + f++; + } + va_end(ap); + + /* Add null-term */ + s[i] = '\0'; + return s; +} + +/* Remove the part of the string from left and from right composed just of + * contiguous characters found in 'cset', that is a null terminted C string. + * + * After the call, the modified sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. + * + * Example: + * + * s = sdsnew("AA...AA.a.aa.aHelloWorld :::"); + * s = sdstrim(s,"Aa. :"); + * printf("%s\n", s); + * + * Output will be just "HelloWorld". + */ +sds sdstrim(sds s, const char *cset) { + char *start, *end, *sp, *ep; + size_t len; + + sp = start = s; + ep = end = s+sdslen(s)-1; + while(sp <= end && strchr(cset, *sp)) sp++; + while(ep > sp && strchr(cset, *ep)) ep--; + len = (sp > ep) ? 0 : ((ep-sp)+1); + if (s != sp) memmove(s, sp, len); + s[len] = '\0'; + sdssetlen(s,len); + return s; +} + +/* Turn the string into a smaller (or equal) string containing only the + * substring specified by the 'start' and 'end' indexes. + * + * start and end can be negative, where -1 means the last character of the + * string, -2 the penultimate character, and so forth. + * + * The interval is inclusive, so the start and end characters will be part + * of the resulting string. + * + * The string is modified in-place. + * + * Example: + * + * s = sdsnew("Hello World"); + * sdsrange(s,1,-1); => "ello World" + */ +void sdsrange(sds s, ssize_t start, ssize_t end) { + size_t newlen, len = sdslen(s); + + if (len == 0) return; + if (start < 0) { + start = len+start; + if (start < 0) start = 0; + } + if (end < 0) { + end = len+end; + if (end < 0) end = 0; + } + newlen = (start > end) ? 0 : (end-start)+1; + if (newlen != 0) { + if (start >= (ssize_t)len) { + newlen = 0; + } else if (end >= (ssize_t)len) { + end = len-1; + newlen = (start > end) ? 0 : (end-start)+1; + } + } else { + start = 0; + } + if (start && newlen) memmove(s, s+start, newlen); + s[newlen] = 0; + sdssetlen(s,newlen); +} + +/* Apply tolower() to every character of the sds string 's'. */ +void sdstolower(sds s) { + size_t len = sdslen(s), j; + + for (j = 0; j < len; j++) s[j] = tolower(s[j]); +} + +/* Apply toupper() to every character of the sds string 's'. */ +void sdstoupper(sds s) { + size_t len = sdslen(s), j; + + for (j = 0; j < len; j++) s[j] = toupper(s[j]); +} + +/* Compare two sds strings s1 and s2 with memcmp(). + * + * Return value: + * + * positive if s1 > s2. + * negative if s1 < s2. + * 0 if s1 and s2 are exactly the same binary string. + * + * If two strings share exactly the same prefix, but one of the two has + * additional characters, the longer string is considered to be greater than + * the smaller one. */ +int sdscmp(const sds s1, const sds s2) { + size_t l1, l2, minlen; + int cmp; + + l1 = sdslen(s1); + l2 = sdslen(s2); + minlen = (l1 < l2) ? l1 : l2; + cmp = memcmp(s1,s2,minlen); + if (cmp == 0) return l1>l2? 1: (l1". + * + * After the call, the modified sds string is no longer valid and all the + * references must be substituted with the new pointer returned by the call. */ +sds sdscatrepr(sds s, const char *p, size_t len) { + s = sdscatlen(s,"\"",1); + while(len--) { + switch(*p) { + case '\\': + case '"': + s = sdscatprintf(s,"\\%c",*p); + break; + case '\n': s = sdscatlen(s,"\\n",2); break; + case '\r': s = sdscatlen(s,"\\r",2); break; + case '\t': s = sdscatlen(s,"\\t",2); break; + case '\a': s = sdscatlen(s,"\\a",2); break; + case '\b': s = sdscatlen(s,"\\b",2); break; + default: + if (isprint(*p)) + s = sdscatprintf(s,"%c",*p); + else + s = sdscatprintf(s,"\\x%02x",(unsigned char)*p); + break; + } + p++; + } + return sdscatlen(s,"\"",1); +} + +/* Helper function for sdssplitargs() that returns non zero if 'c' + * is a valid hex digit. */ +int is_hex_digit(char c) { + return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || + (c >= 'A' && c <= 'F'); +} + +/* Helper function for sdssplitargs() that converts a hex digit into an + * integer from 0 to 15 */ +int hex_digit_to_int(char c) { + switch(c) { + case '0': return 0; + case '1': return 1; + case '2': return 2; + case '3': return 3; + case '4': return 4; + case '5': return 5; + case '6': return 6; + case '7': return 7; + case '8': return 8; + case '9': return 9; + case 'a': case 'A': return 10; + case 'b': case 'B': return 11; + case 'c': case 'C': return 12; + case 'd': case 'D': return 13; + case 'e': case 'E': return 14; + case 'f': case 'F': return 15; + default: return 0; + } +} + +/* Split a line into arguments, where every argument can be in the + * following programming-language REPL-alike form: + * + * foo bar "newline are supported\n" and "\xff\x00otherstuff" + * + * The number of arguments is stored into *argc, and an array + * of sds is returned. + * + * The caller should free the resulting array of sds strings with + * sdsfreesplitres(). + * + * Note that sdscatrepr() is able to convert back a string into + * a quoted string in the same format sdssplitargs() is able to parse. + * + * The function returns the allocated tokens on success, even when the + * input string is empty, or NULL if the input contains unbalanced + * quotes or closed quotes followed by non space characters + * as in: "foo"bar or "foo' + */ +sds *sdssplitargs(const char *line, int *argc) { + const char *p = line; + char *current = NULL; + char **vector = NULL; + + *argc = 0; + while(1) { + /* skip blanks */ + while(*p && isspace(*p)) p++; + if (*p) { + /* get a token */ + int inq=0; /* set to 1 if we are in "quotes" */ + int insq=0; /* set to 1 if we are in 'single quotes' */ + int done=0; + + if (current == NULL) current = sdsempty(); + while(!done) { + if (inq) { + if (*p == '\\' && *(p+1) == 'x' && + is_hex_digit(*(p+2)) && + is_hex_digit(*(p+3))) + { + unsigned char byte; + + byte = (hex_digit_to_int(*(p+2))*16)+ + hex_digit_to_int(*(p+3)); + current = sdscatlen(current,(char*)&byte,1); + p += 3; + } else if (*p == '\\' && *(p+1)) { + char c; + + p++; + switch(*p) { + case 'n': c = '\n'; break; + case 'r': c = '\r'; break; + case 't': c = '\t'; break; + case 'b': c = '\b'; break; + case 'a': c = '\a'; break; + default: c = *p; break; + } + current = sdscatlen(current,&c,1); + } else if (*p == '"') { + /* closing quote must be followed by a space or + * nothing at all. */ + if (*(p+1) && !isspace(*(p+1))) goto err; + done=1; + } else if (!*p) { + /* unterminated quotes */ + goto err; + } else { + current = sdscatlen(current,p,1); + } + } else if (insq) { + if (*p == '\\' && *(p+1) == '\'') { + p++; + current = sdscatlen(current,"'",1); + } else if (*p == '\'') { + /* closing quote must be followed by a space or + * nothing at all. */ + if (*(p+1) && !isspace(*(p+1))) goto err; + done=1; + } else if (!*p) { + /* unterminated quotes */ + goto err; + } else { + current = sdscatlen(current,p,1); + } + } else { + switch(*p) { + case ' ': + case '\n': + case '\r': + case '\t': + case '\0': + done=1; + break; + case '"': + inq=1; + break; + case '\'': + insq=1; + break; + default: + current = sdscatlen(current,p,1); + break; + } + } + if (*p) p++; + } + /* add the token to the vector */ + vector = s_realloc(vector,((*argc)+1)*sizeof(char*)); + vector[*argc] = current; + (*argc)++; + current = NULL; + } else { + /* Even on empty input string return something not NULL. */ + if (vector == NULL) vector = s_malloc(sizeof(void*)); + return vector; + } + } + +err: + while((*argc)--) + sdsfree(vector[*argc]); + s_free(vector); + if (current) sdsfree(current); + *argc = 0; + return NULL; +} + +/* Modify the string substituting all the occurrences of the set of + * characters specified in the 'from' string to the corresponding character + * in the 'to' array. + * + * For instance: sdsmapchars(mystring, "ho", "01", 2) + * will have the effect of turning the string "hello" into "0ell1". + * + * The function returns the sds string pointer, that is always the same + * as the input pointer since no resize is needed. */ +sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) { + size_t j, i, l = sdslen(s); + + for (j = 0; j < l; j++) { + for (i = 0; i < setlen; i++) { + if (s[j] == from[i]) { + s[j] = to[i]; + break; + } + } + } + return s; +} + +/* Join an array of C strings using the specified separator (also a C string). + * Returns the result as an sds string. */ +sds sdsjoin(char **argv, int argc, char *sep) { + sds join = sdsempty(); + int j; + + for (j = 0; j < argc; j++) { + join = sdscat(join, argv[j]); + if (j != argc-1) join = sdscat(join,sep); + } + return join; +} + +/* Like sdsjoin, but joins an array of SDS strings. */ +sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) { + sds join = sdsempty(); + int j; + + for (j = 0; j < argc; j++) { + join = sdscatsds(join, argv[j]); + if (j != argc-1) join = sdscatlen(join,sep,seplen); + } + return join; +} + +/* Wrapper functions that abort on OOM */ + +void *sds_malloc(size_t size) { + void *ptr = malloc(size); + if (!ptr) { + fprintf(stderr, "oom\n"); + abort(); + } + + return p; +} +void *sds_realloc(void *ptr, size_t size) { + ptr = realloc(ptr, size); + + if (!ptr) { + fprintf(stderr, "oom\n"); + abort(); + } + + return realloc(ptr,size); +} +void sds_free(void *ptr) { free(ptr); } + +#if defined(SDS_TEST_MAIN) +#include +#include "testhelp.h" +#include "limits.h" + +#define UNUSED(x) (void)(x) +int sdsTest(void) { + { + sds x = sdsnew("foo"), y; + + test_cond("Create a string and obtain the length", + sdslen(x) == 3 && memcmp(x,"foo\0",4) == 0) + + sdsfree(x); + x = sdsnewlen("foo",2); + test_cond("Create a string with specified length", + sdslen(x) == 2 && memcmp(x,"fo\0",3) == 0) + + x = sdscat(x,"bar"); + test_cond("Strings concatenation", + sdslen(x) == 5 && memcmp(x,"fobar\0",6) == 0); + + x = sdscpy(x,"a"); + test_cond("sdscpy() against an originally longer string", + sdslen(x) == 1 && memcmp(x,"a\0",2) == 0) + + x = sdscpy(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk"); + test_cond("sdscpy() against an originally shorter string", + sdslen(x) == 33 && + memcmp(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk\0",33) == 0) + + sdsfree(x); + x = sdscatprintf(sdsempty(),"%d",123); + test_cond("sdscatprintf() seems working in the base case", + sdslen(x) == 3 && memcmp(x,"123\0",4) == 0) + + sdsfree(x); + x = sdsnew("--"); + x = sdscatfmt(x, "Hello %s World %I,%I--", "Hi!", LLONG_MIN,LLONG_MAX); + test_cond("sdscatfmt() seems working in the base case", + sdslen(x) == 60 && + memcmp(x,"--Hello Hi! World -9223372036854775808," + "9223372036854775807--",60) == 0) + printf("[%s]\n",x); + + sdsfree(x); + x = sdsnew("--"); + x = sdscatfmt(x, "%u,%U--", UINT_MAX, ULLONG_MAX); + test_cond("sdscatfmt() seems working with unsigned numbers", + sdslen(x) == 35 && + memcmp(x,"--4294967295,18446744073709551615--",35) == 0) + + sdsfree(x); + x = sdsnew(" x "); + sdstrim(x," x"); + test_cond("sdstrim() works when all chars match", + sdslen(x) == 0) + + sdsfree(x); + x = sdsnew(" x "); + sdstrim(x," "); + test_cond("sdstrim() works when a single char remains", + sdslen(x) == 1 && x[0] == 'x') + + sdsfree(x); + x = sdsnew("xxciaoyyy"); + sdstrim(x,"xy"); + test_cond("sdstrim() correctly trims characters", + sdslen(x) == 4 && memcmp(x,"ciao\0",5) == 0) + + y = sdsdup(x); + sdsrange(y,1,1); + test_cond("sdsrange(...,1,1)", + sdslen(y) == 1 && memcmp(y,"i\0",2) == 0) + + sdsfree(y); + y = sdsdup(x); + sdsrange(y,1,-1); + test_cond("sdsrange(...,1,-1)", + sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0) + + sdsfree(y); + y = sdsdup(x); + sdsrange(y,-2,-1); + test_cond("sdsrange(...,-2,-1)", + sdslen(y) == 2 && memcmp(y,"ao\0",3) == 0) + + sdsfree(y); + y = sdsdup(x); + sdsrange(y,2,1); + test_cond("sdsrange(...,2,1)", + sdslen(y) == 0 && memcmp(y,"\0",1) == 0) + + sdsfree(y); + y = sdsdup(x); + sdsrange(y,1,100); + test_cond("sdsrange(...,1,100)", + sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0) + + sdsfree(y); + y = sdsdup(x); + sdsrange(y,100,100); + test_cond("sdsrange(...,100,100)", + sdslen(y) == 0 && memcmp(y,"\0",1) == 0) + + sdsfree(y); + sdsfree(x); + x = sdsnew("foo"); + y = sdsnew("foa"); + test_cond("sdscmp(foo,foa)", sdscmp(x,y) > 0) + + sdsfree(y); + sdsfree(x); + x = sdsnew("bar"); + y = sdsnew("bar"); + test_cond("sdscmp(bar,bar)", sdscmp(x,y) == 0) + + sdsfree(y); + sdsfree(x); + x = sdsnew("aar"); + y = sdsnew("bar"); + test_cond("sdscmp(bar,bar)", sdscmp(x,y) < 0) + + sdsfree(y); + sdsfree(x); + x = sdsnewlen("\a\n\0foo\r",7); + y = sdscatrepr(sdsempty(),x,sdslen(x)); + test_cond("sdscatrepr(...data...)", + memcmp(y,"\"\\a\\n\\x00foo\\r\"",15) == 0) + + { + unsigned int oldfree; + char *p; + int step = 10, j, i; + + sdsfree(x); + sdsfree(y); + x = sdsnew("0"); + test_cond("sdsnew() free/len buffers", sdslen(x) == 1 && sdsavail(x) == 0); + + /* Run the test a few times in order to hit the first two + * SDS header types. */ + for (i = 0; i < 10; i++) { + int oldlen = sdslen(x); + x = sdsMakeRoomFor(x,step); + int type = x[-1]&SDS_TYPE_MASK; + + test_cond("sdsMakeRoomFor() len", sdslen(x) == oldlen); + if (type != SDS_TYPE_5) { + test_cond("sdsMakeRoomFor() free", sdsavail(x) >= step); + oldfree = sdsavail(x); + } + p = x+oldlen; + for (j = 0; j < step; j++) { + p[j] = 'A'+j; + } + sdsIncrLen(x,step); + } + test_cond("sdsMakeRoomFor() content", + memcmp("0ABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJ",x,101) == 0); + test_cond("sdsMakeRoomFor() final length",sdslen(x)==101); + + sdsfree(x); + } + } + test_report() + return 0; +} +#endif + +#ifdef SDS_TEST_MAIN +int main(void) { + return sdsTest(); +} +#endif diff --git a/common/sds.h b/common/sds.h new file mode 100644 index 0000000..adcc12c --- /dev/null +++ b/common/sds.h @@ -0,0 +1,274 @@ +/* SDSLib 2.0 -- A C dynamic strings library + * + * Copyright (c) 2006-2015, Salvatore Sanfilippo + * Copyright (c) 2015, Oran Agra + * Copyright (c) 2015, Redis Labs, Inc + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Redis 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 THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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 __SDS_H +#define __SDS_H + +#define SDS_MAX_PREALLOC (1024*1024) +extern const char *SDS_NOINIT; + +#include +#include +#include + +typedef char *sds; + +/* Note: sdshdr5 is never used, we just access the flags byte directly. + * However is here to document the layout of type 5 SDS strings. */ +struct __attribute__ ((__packed__)) sdshdr5 { + unsigned char flags; /* 3 lsb of type, and 5 msb of string length */ + char buf[]; +}; +struct __attribute__ ((__packed__)) sdshdr8 { + uint8_t len; /* used */ + uint8_t alloc; /* excluding the header and null terminator */ + unsigned char flags; /* 3 lsb of type, 5 unused bits */ + char buf[]; +}; +struct __attribute__ ((__packed__)) sdshdr16 { + uint16_t len; /* used */ + uint16_t alloc; /* excluding the header and null terminator */ + unsigned char flags; /* 3 lsb of type, 5 unused bits */ + char buf[]; +}; +struct __attribute__ ((__packed__)) sdshdr32 { + uint32_t len; /* used */ + uint32_t alloc; /* excluding the header and null terminator */ + unsigned char flags; /* 3 lsb of type, 5 unused bits */ + char buf[]; +}; +struct __attribute__ ((__packed__)) sdshdr64 { + uint64_t len; /* used */ + uint64_t alloc; /* excluding the header and null terminator */ + unsigned char flags; /* 3 lsb of type, 5 unused bits */ + char buf[]; +}; + +#define SDS_TYPE_5 0 +#define SDS_TYPE_8 1 +#define SDS_TYPE_16 2 +#define SDS_TYPE_32 3 +#define SDS_TYPE_64 4 +#define SDS_TYPE_MASK 7 +#define SDS_TYPE_BITS 3 +#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T))); +#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T)))) +#define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS) + +static inline size_t sdslen(const sds s) { + unsigned char flags = s[-1]; + switch(flags&SDS_TYPE_MASK) { + case SDS_TYPE_5: + return SDS_TYPE_5_LEN(flags); + case SDS_TYPE_8: + return SDS_HDR(8,s)->len; + case SDS_TYPE_16: + return SDS_HDR(16,s)->len; + case SDS_TYPE_32: + return SDS_HDR(32,s)->len; + case SDS_TYPE_64: + return SDS_HDR(64,s)->len; + } + return 0; +} + +static inline size_t sdsavail(const sds s) { + unsigned char flags = s[-1]; + switch(flags&SDS_TYPE_MASK) { + case SDS_TYPE_5: { + return 0; + } + case SDS_TYPE_8: { + SDS_HDR_VAR(8,s); + return sh->alloc - sh->len; + } + case SDS_TYPE_16: { + SDS_HDR_VAR(16,s); + return sh->alloc - sh->len; + } + case SDS_TYPE_32: { + SDS_HDR_VAR(32,s); + return sh->alloc - sh->len; + } + case SDS_TYPE_64: { + SDS_HDR_VAR(64,s); + return sh->alloc - sh->len; + } + } + return 0; +} + +static inline void sdssetlen(sds s, size_t newlen) { + unsigned char flags = s[-1]; + switch(flags&SDS_TYPE_MASK) { + case SDS_TYPE_5: + { + unsigned char *fp = ((unsigned char*)s)-1; + *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS); + } + break; + case SDS_TYPE_8: + SDS_HDR(8,s)->len = newlen; + break; + case SDS_TYPE_16: + SDS_HDR(16,s)->len = newlen; + break; + case SDS_TYPE_32: + SDS_HDR(32,s)->len = newlen; + break; + case SDS_TYPE_64: + SDS_HDR(64,s)->len = newlen; + break; + } +} + +static inline void sdsinclen(sds s, size_t inc) { + unsigned char flags = s[-1]; + switch(flags&SDS_TYPE_MASK) { + case SDS_TYPE_5: + { + unsigned char *fp = ((unsigned char*)s)-1; + unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc; + *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS); + } + break; + case SDS_TYPE_8: + SDS_HDR(8,s)->len += inc; + break; + case SDS_TYPE_16: + SDS_HDR(16,s)->len += inc; + break; + case SDS_TYPE_32: + SDS_HDR(32,s)->len += inc; + break; + case SDS_TYPE_64: + SDS_HDR(64,s)->len += inc; + break; + } +} + +/* sdsalloc() = sdsavail() + sdslen() */ +static inline size_t sdsalloc(const sds s) { + unsigned char flags = s[-1]; + switch(flags&SDS_TYPE_MASK) { + case SDS_TYPE_5: + return SDS_TYPE_5_LEN(flags); + case SDS_TYPE_8: + return SDS_HDR(8,s)->alloc; + case SDS_TYPE_16: + return SDS_HDR(16,s)->alloc; + case SDS_TYPE_32: + return SDS_HDR(32,s)->alloc; + case SDS_TYPE_64: + return SDS_HDR(64,s)->alloc; + } + return 0; +} + +static inline void sdssetalloc(sds s, size_t newlen) { + unsigned char flags = s[-1]; + switch(flags&SDS_TYPE_MASK) { + case SDS_TYPE_5: + /* Nothing to do, this type has no total allocation info. */ + break; + case SDS_TYPE_8: + SDS_HDR(8,s)->alloc = newlen; + break; + case SDS_TYPE_16: + SDS_HDR(16,s)->alloc = newlen; + break; + case SDS_TYPE_32: + SDS_HDR(32,s)->alloc = newlen; + break; + case SDS_TYPE_64: + SDS_HDR(64,s)->alloc = newlen; + break; + } +} + +sds sdsnewlen(const void *init, size_t initlen); +sds sdsnew(const char *init); +sds sdsempty(void); +sds sdsdup(const sds s); +void sdsfree(sds s); +sds sdsgrowzero(sds s, size_t len); +sds sdscatlen(sds s, const void *t, size_t len); +sds sdscat(sds s, const char *t); +sds sdscatsds(sds s, const sds t); +sds sdscpylen(sds s, const char *t, size_t len); +sds sdscpy(sds s, const char *t); + +sds sdscatvprintf(sds s, const char *fmt, va_list ap); +#ifdef __GNUC__ +sds sdscatprintf(sds s, const char *fmt, ...) + __attribute__((format(printf, 2, 3))); +#else +sds sdscatprintf(sds s, const char *fmt, ...); +#endif + +sds sdscatfmt(sds s, char const *fmt, ...); +sds sdstrim(sds s, const char *cset); +void sdsrange(sds s, ssize_t start, ssize_t end); +void sdsupdatelen(sds s); +void sdsclear(sds s); +int sdscmp(const sds s1, const sds s2); +sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count); +void sdsfreesplitres(sds *tokens, int count); +void sdstolower(sds s); +void sdstoupper(sds s); +sds sdsfromlonglong(long long value); +sds sdscatrepr(sds s, const char *p, size_t len); +sds *sdssplitargs(const char *line, int *argc); +sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen); +sds sdsjoin(char **argv, int argc, char *sep); +sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen); + +/* Low level functions exposed to the user API */ +sds sdsMakeRoomFor(sds s, size_t addlen); +void sdsIncrLen(sds s, ssize_t incr); +sds sdsRemoveFreeSpace(sds s); +size_t sdsAllocSize(sds s); +void *sdsAllocPtr(sds s); + +/* Export the allocator used by SDS to the program using SDS. + * Sometimes the program SDS is linked to, may use a different set of + * allocators, but may want to allocate or free things that SDS will + * respectively free or allocate. */ +void *sds_malloc(size_t size); +void *sds_realloc(void *ptr, size_t size); +void sds_free(void *ptr); + +#ifdef REDIS_TEST +int sdsTest(int argc, char *argv[]); +#endif + +#endif diff --git a/linux/1394ethbridge.c b/linux/1394ethbridge.c new file mode 100644 index 0000000..c7fffcf --- /dev/null +++ b/linux/1394ethbridge.c @@ -0,0 +1,266 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +enum { + SERVER_FD = 0, + IEEE_FD = 1, + CLIENT_FD = 2, + DESCRIPTORS = 3 +}; + +static struct msg_state client_state; +static raw1394handle_t ieee_handle; +static struct pollfd pollfds[DESCRIPTORS] = {{0}}; + +static void verr(char *fmt, va_list va) { + int n = 0; + if (fmt) + n = vfprintf(stderr, fmt, va); + + if (errno) + fprintf(stderr, "%s%s\n", n ? ": " : "", strerror(errno)); + else + fprintf(stderr, "\n"); + exit(1); +} + +static void err(char *fmt, ...) { + va_list va; + va_start(va, fmt); + verr(fmt, va); + va_end(va); +} + +static void server_accept(void) { + int fd = accept(pollfds[SERVER_FD], NULL, NULL); + if (pollfds[CLIENT_FD].fd >= 0) { + close(fd); + return; + } + + if (fd < 0) { + if (errno != ECONNABORTED) + err("accept"); + else + return; + } + + pollfds[CLIENT_FD].fd = fd; + client_state.state = PARSE_VERSION_MESSAGE; + client_state.type = MESSAGE_INVALID; + if (client_state.buf) { + sdsclear(client_state.buf); + } else { + client_state.buf = sdsempty(); + } +} + +static void iterate(void) { + if (raw1394_loop_iterate(ieee_handle) < 0) + err("raw1394_loop_iterate"); +} + +/* 0b111111 = 0x3F + * if tags[x] < 0, then tag is not allocated + */ +#define TAG_NUM 0x40 +static long tag_to_handle[TAG_NUM]; + +static void handle_send_async(union msg *msg) { + switch (msg->send_async.tcode) { + case TCODE_WRITE_QUADLET_REQUEST: + case TCODE_WRITE_BLOCK_REQUEST: + raw1394_start_write(ieee_handle, msg->send_async.node, + msg->send_async.addr, msg->send_async.len, + msg->send_async.buf, msg->send_async.tlabel); + break; + case TCODE_READ_QUADLET_REQUEST: + case TCODE_READ_BLOCK_REQUEST: + raw1394_start_read(ieee_handle, msg->send_async.node, + msg->send_async.addr, msg->send_async.len, + msg->send_async.buf, msg->send_async.tlabel); + break; + case TCODE_WRITE_RESONSE: case TCODE_READ_QUADLET_RESPONSE: + case TCODE_READ_BLOCK_RESPONSE: + if (msg->send_async.tlabel < TAG_NUM && + tags_to_handle[msg->send_async.tlabel] >= 0) { + raw1394_send_rw_response(ieee_handle, msg->send_async.tcode, + msg->send_async.buf, msg->send_async.len, + tags_to_handle[msg->send_async.tlabel]); + tags_to_handle[msg->send_async.tlabel] = 0; + } + break; + /* FIXME: implement lock request */ + } +} + +static void handle_send_iso(union msg *msg) { + /* do nothing */ +} + +static int arm_handler(raw1394handle_t handle, raw1394_arm_allocation_t *arm, + int tcode, unsigned long long offset, int source_node_id, + int card, unsigned kernel_handle, size_t length, void *data) +{ + (void)handle; + uint8_t tag; + + /* Allocate tags. + * Tags are temporarily allocated since the real tag is stored in the + * kernel in the kernel_handle. + * + * firewire-cdev: bus is only 1023? + */ + for (tag = 0; tag < MAX_TAG; tag++) { + if (tag_to_handle[tag] < 0) + break; + } + if (tag == MAX_TAG) + return -1; + + tag_to_handle[tag] = kernel_handle; + if (msg_send_async(pollfds[SERVER_FD].fd, 1023, source_node_id, offset, + tcode, tag, length, data) < 0) + tag_to_handle[tag] = -1; + /* TODO: return an error response */ + return 0; +} + +static void handle_allocation(union msg *msg) { + /* may fail due to overlap: ignore */ + raw1394_arm_register(ieee_handle, msg->allocate.start, msg->allocate.length, + ARM_READ | ARM_WRITE | ARM_LOCK, + ARM_READ | ARM_WRITE | ARM_LOCK, + 0 /* ignored */); +} + +static bool read_client(void) { + char buf[512]; + ssize_t len; + int msgtype; + + len = read(pollfds[CLIENT_FD].fd, buf, sizeof(buf)); + if (len <= 0) + return false; + + client_state.buf = sdscatlen(client_state.buf, buf, len); + while (!parse_packet(fdstate)); + + return true; +} + +static bool client_process(void) { + if (fd->revents & POLLERR) + return false; + + if (fd->revents & POLLIN) + if (!read_client(fd, fdstate)) + return false; + + if (!(fd->revents & POLLIN) && fd->revents & POLLHUP) + return false; + return true; +} + +static int open_server(const char *port) { + int r; + struct addrinfo *serv; + int sock; + + if ((r = getaddrinfo(NULL, port, &(struct addrinfo){ + .ai_family = AF_INET, + .ai_socktype = SOCK_STREAM, + .ai_flags = AI_PASSIVE + }, &serv) != 0) { + err("getaddrinfo: %s", gai_strerror(r)); + } + + for (struct addrinfo *p = serv; p; p = p->ai_next) { + sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol); + if (sock < 0) + continue; + if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR) < 0) + continue; + if (bind(sock, p->ai_addr, p->ai_addrlen) < 0) + continue; + break; + } + if (!p) + err("socket"); + + freeaddrinfo(serv); + + if (listen(p, 5) < 0) + err("listen"); + + return sock; +} + +static int setup_port(int port) { + int num; + int fd; + static struct raw1394_portinfo ports[PORTSNUM] = {0}; + + ieee_handle = raw1394_new_handle(); + if (!ieee_handle) + err("raw1394_new_handle"); + + num = raw1394_get_port_info(ieee_handle, ports, PORTSNUM); + + do { + for (int i = 0; i < num && i < PORTSNUM; i++) + fprintf(stderr, "[%d/%d]: %s w/ %d\n", i + 1, num, + ports[i].name, ports[i].nodes); + errno = 0; + raw1394_set_port(ieee_handle, port); + } while (errno != ESTALE); + + if (errno) + die("raw1394_set_port"); + + fd = raw1394_get_fd(ieee_handle); + if (fd < 0) + die("raw1394_get_fd"); + + return fd; +} + +int main(void) { + pollfds[IEEE_FD].fd = setup_port(0); + pollfds[IEEE_FD].events = POLLIN | POLLPRI; + pollfds[SERVER_FD].fd = open_server("1394"); + pollfds[SERVER_FD].events = POLLIN | POLLPRI; + pollfds[CLIENT_FD].fd = -1; + + for (int i = 0; i < TAG_NUM; i++) + tag_to_handle[i] = -1; + + client_state.on_read[PARSE_SEND_ASYNC] = ieee_process; + + while (1) { + if (poll(pollfds, DESCRIPTORS, -1) <= 0) + err("poll"); + + if (pollfds[SERVER_FD].revents & (POLLIN | POLLPRI)) { + server_accept(); + } else if (pollfds[IEEE_FD].revents & (POLLIN | POLLPRI)) { + ieee_process(); + } + if (!client_process()) { + close(pollfds[CLIENT_FD].fd); + pollfds[CLIENT_FD].fd = -1; + + // Reset Firewire + raw1394_destroy_handle(ieee_handle); + pollfds[IEEE_FD].fd = setup_port(0); + } + } +} diff --git a/win/shim.c b/win/shim.c new file mode 100644 index 0000000..d1d41bb --- /dev/null +++ b/win/shim.c @@ -0,0 +1,369 @@ +#include +#include +#include +#include +#include "sdnet.h" + +#define export __declspec(dllexport) +#define ADDR "192.168.1.1" +#define PORT 1394 + +static FILE *log; +static SOCKET sock = INVALID_SOCKET; +static WSADATA wsd; + +static FILE *makelog(void) { + char buf[128]; + time_t t = time(NULL); + + snprintf(buf, sizeof(buf), "logfile-%lu.txt", (unsigned long) t); + + return fopen(buf, "w"); +} + +static SOCKET makesock(void) { + struct addrinfo hints, *ai, *p; + SOCKET s; + + if (WSAStartup(MAKEWORD(2,2), &wsd) != 0) { + fputs(log, "wsa\n"); + return INVALID_SOCKET; + } + + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_INET; + hints.ai_socktype = SOCK_STREAM; + hints.ai_protocol = IPPROTO_TCP; + + if (getaddrinfo(ADDR, PORT, &hints, &ai) != 0) { + fputs(log, "getaddrinfo\n"); + return INVALID_SOCKET; + } + + for (p = ai; p; p = p->ai_next) { + s = socket(p->ai_family, p->ai_socktype, p->ai_protocol); + if (s == INVALID_SOCKET) + continue; + if (connect(s, p->ai_addr, (int)->ai_addrlen) == SOCKET_ERROR) { + closesocket(s); + continue; + } + break; + } + + freeaddrinfo(ai); + if (!p) { + fputs(log, "getaddrinfo socket connect\n"); + return INVALID_SOCKET; + } + + return s; +} + +export LONG sdNET_OpenAdapter(PHANDLE hDevice, ULONG wwuid, + ULONG adpNumber) { + (void)wwuid; + (void)adpNumber; + + if (!log) + return sdNET_ERR_ADAPTER_BUSY; + + log = makelog(); + if (!log) + return sdNET_ERR_ADAPTER_BUSY; + fputs(log, "open log\n"); + + sock = makesock(); + if (!sock) + return sdNET_ERR_ADAPTER_BUSY; + + *hDevice = 1394; + return sdNET_ERR_SUCCESS; +} + +export LONG sdNET_CloseAdapter(PHANDLE hDevice) { + if (*hDevice != 1394) + return sdNET_ERR_INVALID_HANDLE; + fputs(log, "Closing\n"); + fclose(log); + closesocket(sock); + + log = NULL; + sock = INVALID_SOCKET; + + return sdNET_ERR_INVALID_HANDLE; +} + +static int dump_tcode(unsigned long tcode) +{ + unsigned long other = tcode & ~IEEE1394_tCODE_MASK; + int is_iso = 0; + + fprint(logfile, "Transaction Code: "); + + switch (tcode & IEEE1394_tCODE_MASK) { + case IEEE1394_QUAD_WRREQ: + log("Async request subaction, quadlet"); + break; + case IEEE1394_BLOCK_WRREQ: + log(Async request subaction, block"); + break; + case IEEE1394_WRRESP: + log("Async response subaction for both write request types, no payload"); + break; + case IEEE1394_QUAD_RDREQ: + log("Async request subaction, no payload"); + break; + case IEEE1394_BLOCK_RDREQ: + log("Async request subaction quadlet payload"); + break; + case IEEE1394_QUAD_RDRESP: + log("Async response subaction to request for quadlet, quadlet payload"); + break; + case IEEE1394_BLOCK_RDRESP: + log("Async response subaction to request for block, block payload"); + break; + case IEEE1394_CYCLE_START_REQ: + log("Async request to start isochronous cycle, quadlet payload"); + break; + case IEEE1394_LOCK_REQ: + log("Async request subaction, block payload"); + break; + case IEEE1394_ISOBLOCK_REQ: + log("Isochronous subaction, block payload"); + is_iso = 1; + break; + case IEEE194_LOCK_RESP: + log("Asynchronous request subaction for lock request, block payload"); + break; + default: + log("Unknown code %lu", tcode & IEEE1394_tCODE_MASK); + break; + } + + if (other) { + log("Other transaction code: %lu", other); + } + + log("\n"); + return is_iso; +} + +static void dump_data(unsigned long len, unsigned long *data) +{ + /* Dump in base52 instead? */ + unsigned long i; + + log("Data length: %lu\n", len); + log("Data:"); + for (i = 0; i < len >> 2; i++) { + fprintf(" %08lX", *data); + data++; + } + + log("\n"); +} + +static void dump_asy(PsdNET_Packet_t p) +{ + fprintf(logfile, + "Asynchronous Packet.\n" + "Bus: %lu\n" + "Node: %lu\n" + "Address Offset, High: 0x%08lX\n" + "Address Offset, Low: 0x%08lX\n" + "Transaction Label: %lu\n", + p->type.asy.bus, + p->type.asy.node, + p->type.asy.offsetHigh, + p->type.asy.offsetLow + ); + + log("Retry code: "); + switch (p->type.asy.retryCode) { + case IEEE1394_Retry_0: + log("Initial subaction.\n"); + break; + case IEEE1394_Retry_X: + log("Retry subaction from acknowledge busy, or retry from acknowledge busy A or B.\n"); + break; + case IEEE1394_Retry_A: + log("Retry subaction, dual-phase retry node, A.\n"); + break; + case IEEE1394_Retry_B: + log("Retry subaction, dual-phase retry node, B.\n"); + break; + default: + log("Unknown %lu\n", p->type.asy.retryCode); + break; + } + + log("Response code: "); + switch(p->type.asy.rCode) { + case IEEE1394_RESP_COMPLETE: + log("Complete\n"); + break; + case IEEE1394_RESP_CONFLICT_ERROR: + log("Resource conflict\n"); + break; + case IEEE1394_RESP_DATA_ERROR: + log("Hardware error\n"); + break; + case IEEE1394_RESP_TYPE_ERROR: + log("Invalid value or transaction\n"); + break; + case IEEE1394_RESP_ADDR_ERROR: + log("Destination not accessable\n"); + break; + default: + log("Unknown %lu\n", p->type.asy.rCode); + } + + log("Extended response code: "); + switch (p->type.asy.xtCode) { + case IEEE1394_MASK_SWAP: + log("Mask swap\n"); + break; + case IEEE1394_COMPARE_SWAP: + log("Compare swap\n"); + break; + case IEEE1394_FETCH_ADD: + log("Fetch add\n"); + break; + case IEEE1394_BOUNDED_ADD: + log("Bounded add\n"); + break; + case IEEE1394_WRAP_ADD: + log("Wrap add\n"); + break; + case IEEE1394_VENDER_DEP: + log("Vendor dependent\n"); + default: + log("Unknown %lu\n", p->type.asy.xtCode); + } +} + +static void dump_iso(PsdNET_Packet_t p) +{ + log("Isochronous packet.\n" + "Channel: %lu\n" + "Synchronization code: %lu\n", + p->type.iso.channel, + p->type.iso.synchro); + + log("Tag: "); + switch (p->type.iso.tag) { + case IEEE1394_TAG_UNFORMATTED: + log("Unformatted\n"); + break; + case IEEE1394_TAG_FORMAT1: + log("1\n"); + break; + case IEEE1394_TAG_FORMAT2: + log("2\n"); + break; + case IEEE1394_TAG_FORMAT3: + log("3\n"); + break; + default: + log("Unknown tag %lu\n", p->type.iso.tag); + break; + } +} + +static void dump_packet(PsdNET_Packet_t p) +{ + log("Timeout: %lu\n", p->tCode); + log("Flags:"); + if (p->flags & SDNET__NOBLOCKINGMODE) { + log(" Nonblocking"); + } else if (p->flags & SDNET__BLOCKINGMODE) { + log(" Blocking"); + } + log("\n"); + + if (dump_tcode(p->tCode) == 1) + dump_iso(p); + else + dump_asy(p); + + + log("Acknowledge code: "); + switch (p->ack) { + case IEEE1394_ACK_COMPLETE: + log("Accepted and completed\n"); + break; + case IEEE1394_ACK_PENDING: + log("Accepted and pending\n"); + break; + case IEEE1394_ACK_BUSY_X: + log("Rejected, retry\n"); + break; + case IEEE1394_ACK_BUSY_A: + log("Rejected, retry at phase A\n"); + break; + case IEEE1394_ACK_BUSY_B: + log("Rejected, retry at phase B\n"); + break; + case IEEE1394_ACK_DATA_ERROR: + log("CRC/length check fail\n"); + break; + case IEEE1394_ACK_TYPE_ERROR: + log("Unsupported or incorrect value, or invalid transaction\n"); + default: + log("Unknown %lu\n", p->ack); + } + + log("Speed: "); + switch (p->speed) { + case IEEE1394_ASYSPD_100Mbits: + case IEEE1394_ISOSPD_100Mbits: + log("100\n"); + break; + case IEEE1394_ASYSPD200Mbits: + case IEEE1394_ISOSPD200Mbits: + log("200\n"); + break; + case IEEE1394_ASYSPD400Mbits: + case IEEE1394_ISOSPD400Mbits: + log("400\n"); + break; + default: + log("Unknown %lu\n", p->speed); + } + + dump_data(p->datalen, p->data); +} + +export LONG sdNET_SendAsyncPacket(PHANDLE hDevice, PsdNET_Packet_t pk) { + fputs(log, "Send Async\n"); + dump_packet(pk); + /* TODO: convert pk->asy.data and pk->asy.datalen from long to octet */ + msg_send_async(sock, pk->asy.bus, pk->asy.node, + pk->asy.offset_high << 32 | pk->asy.offset_low, + pk->tcode, pk->asy.tLabel, pk->asy.datalen, pk->asy.data); + return sdNET_ERR_TIMEOUT; +} + +export LONG sdNET_SendIsochPacket(PHANDLE hDevice, PsdNET_Packet_t pk) { + fputs(log, "Send Isoch\n"); + dump_packet(pk); + return sdNET_ERR_TIMEOUT; +} + +export LONG sdNET_ReceivePacket(PHANDLE hDevice, PsdNET_Packet_t pk) { + char buf[512]; + fputs(log, "Receive One\n"); + + return sdNET_ERR_TIMEOUT; +} + +export LONG sdNET_IOControl(PHANDLE hDevice, ULONG cmd, PVOID iodata) { + fputs(log, "IOControl\n"); + return sdNET_ERR_IOCTL_FAILED; +} + +export LONG sdNET_MultiReceive(PHANDLE hDevice, PsdNET_MultiPk_t multiPk) { + fputs(log, "Recv many\n"); + return sdNET_ERR_TIMEOUT; +}