static int OSC_writeStringArg(OSCbuf *buf, char *arg) { int len; if (CheckTypeTag(buf, 's')) return 9; len = OSC_effectiveStringLength(arg); if (buf->gettingFirstUntypedArg && arg[0] == ',') { /* This un-type-tagged message starts with a string that starts with a comma, so we have to escape it (with a double comma) so it won't look like a type tag string. */ if(OSC_CheckOverflow(buf, len+4))return 1; /* Too conservative */ buf->bufptr += OSC_padStringWithAnExtraStupidComma(buf->bufptr, arg); } else { if(OSC_CheckOverflow(buf, len))return 1; buf->bufptr += OSC_padString(buf->bufptr, arg); } buf->gettingFirstUntypedArg = 0; return 0; }
int OSC_closeBundle(OSCbuf *buf) { if (buf->bundleDepth == 0) { /* This handles EMPTY, ONE_MSG, ARGS, and DONE */ OSC_errorMessage = "Can't close bundle; no bundle is open!"; return 5; } if (CheckTypeTag(buf, '\0')) return 9; if (buf->state == GET_ARGS) { PatchMessageSize(buf); } if (buf->bundleDepth == 1) { /* Closing the last bundle: No bundle size to patch */ buf->state = DONE; } else { /* Closing a sub-bundle: patch bundle size */ int size = buf->bufptr - ((char *) buf->prevCounts[buf->bundleDepth]) - 4; *(buf->prevCounts[buf->bundleDepth]) = htonl(size); buf->state = NEED_COUNT; } --buf->bundleDepth; buf->gettingFirstUntypedArg = 0; buf->typeStringPtr = 0; return 0; }
static int OSC_writeNullArg(OSCbuf *buf, char type) { /* Don't write any data, just check the type tag */ if(OSC_CheckOverflow(buf, 4))return 1; if (CheckTypeTag(buf, type)) return 9; buf->gettingFirstUntypedArg = 0; return 0; }
static int OSC_writeBlobArg(OSCbuf *buf, typedArg *arg, size_t nArgs) { size_t i; unsigned char b; /* pack all the args as single bytes following a 4-byte length */ if(OSC_CheckOverflow(buf, nArgs+4))return 1; if (CheckTypeTag(buf, 'b')) return 9; *((int4byte *) buf->bufptr) = htonl(nArgs); #ifdef DEBUG post ("OSC_writeBlobArg length : %lu", nArgs); #endif buf->bufptr += 4; for (i = 0; i < nArgs; i++) { if (arg[i].type != BLOB_osc) { error("packOSC: blob element %i not blob type", i); return 9; } b = (unsigned char)((arg[i].datum.i)&0x0FF);/* force int to 8-bit byte */ #ifdef DEBUG post ("OSC_writeBlobArg : %d, %d", arg[i].datum.i, b); #endif buf->bufptr[i] = b; } i = OSC_WriteBlobPadding(buf->bufptr, i); buf->bufptr += i; buf->gettingFirstUntypedArg = 0; return 0; }
int OSC_writeIntArg(OSCbuf *buf, int4byte arg) { CheckOverflow(buf, 4); if (CheckTypeTag(buf, 'i')) return 9; *((int4byte *) buf->bufptr) = htonl(arg); buf->bufptr += 4; buf->gettingFirstUntypedArg = 0; return 0; }
int OSC_writeStringArg(OSCbuf *buf, char PROGMEM *arg) { int len; if (CheckTypeTag(buf, 's')) return 9; len = OSC_effectiveStringLength(arg); CheckOverflow(buf, len); buf->bufptr += OSC_padString(buf->bufptr, arg); buf->gettingFirstUntypedArg = 0; return 0; }
int OSC_closeAllBundles(OSCbuf *buf) { if (buf->bundleDepth == 0) { /* This handles EMPTY, ONE_MSG, ARGS, and DONE */ OSC_errorMessage = "Can't close all bundles; no bundle is open!"; return 6; } if (CheckTypeTag(buf, '\0')) return 9; while (buf->bundleDepth > 0) { OSC_closeBundle(buf); } buf->typeStringPtr = 0; return 0; }
static int OSC_writeAddress(OSCbuf *buf, char *name) { int4byte paddedLength; if (buf->state == ONE_MSG_ARGS) { post("packOSC: This packet is not a bundle, so you can't write another address"); return 7; } if (buf->state == DONE) { post("packOSC: This packet is finished; can't write another address"); return 8; } if (CheckTypeTag(buf, '\0')) return 9; paddedLength = OSC_effectiveStringLength(name); if (buf->state == EMPTY) { /* This will be a one-message packet, so no sizes to worry about */ if(OSC_CheckOverflow(buf, paddedLength))return 1; buf->state = ONE_MSG_ARGS; } else { /* GET_ARGS or NEED_COUNT */ if(OSC_CheckOverflow(buf, 4+paddedLength))return 1; if (buf->state == GET_ARGS) { /* Close the old message */ PatchMessageSize(buf); } buf->thisMsgSize = (int4byte *)buf->bufptr; *(buf->thisMsgSize) = 0xbbbbbbbb; buf->bufptr += 4; buf->state = GET_ARGS; } /* Now write the name */ buf->bufptr += OSC_padString(buf->bufptr, name); buf->typeStringPtr = 0; buf->gettingFirstUntypedArg = 1; return 0; }
int OSC_writeFloatArg(OSCbuf *buf, float arg) { int4byte *intp; CheckOverflow(buf, 4); if (CheckTypeTag(buf, 'f')) return 9; /* Pretend arg is a long int so we can use htonl() */ intp = ((int4byte *) &arg); *((int4byte *) buf->bufptr) = htonl(*intp); buf->bufptr += 4; buf->gettingFirstUntypedArg = 0; return 0; }
int OSC_writeFloatArgs(OSCbuf *buf, int numFloats, float *args) { int i; int4byte *intp; CheckOverflow(buf, 4 * numFloats); /* Pretend args are long ints so we can use htonl() */ intp = ((int4byte *) args); for (i = 0; i < numFloats; i++) { if (CheckTypeTag(buf, 'f')) return 9; *((int4byte *) buf->bufptr) = htonl(intp[i]); buf->bufptr += 4; } buf->gettingFirstUntypedArg = 0; return 0; }
int OSC_writeAddressAndTypes(OSCbuf *buf, char *name, char *types) { int result; int4byte paddedLength; if (CheckTypeTag(buf, '\0')) return 9; result = OSC_writeAddress(buf, name); if (result) return result; paddedLength = OSC_effectiveStringLength(types); CheckOverflow(buf, paddedLength); buf->typeStringPtr = buf->bufptr + 1; /* skip comma */ buf->bufptr += OSC_padString(buf->bufptr, types); buf->gettingFirstUntypedArg = 0; return 0; }
static int OSC_writeFloatArg(OSCbuf *buf, float arg) { union intfloat32 { int i; float f; }; union intfloat32 if32; if(OSC_CheckOverflow(buf, 4))return 1; if (CheckTypeTag(buf, 'f')) return 9; /* Pretend arg is a long int so we can use htonl() */ if32.f = arg; *((int4byte *) buf->bufptr) = htonl(if32.i); buf->bufptr += 4; buf->gettingFirstUntypedArg = 0; return 0; }
int OSC_openBundle(OSCbuf *buf, OSCTimeTag tt) { if (buf->state == ONE_MSG_ARGS) { OSC_errorMessage = "Can't open a bundle in a one-message packet"; return 3; } if (buf->state == DONE) { OSC_errorMessage = "This packet is finished; can't open a new bundle"; return 4; } if (++(buf->bundleDepth) >= MAX_BUNDLE_NESTING) { OSC_errorMessage = "Bundles nested too deeply; change MAX_BUNDLE_NESTING in OpenSoundControl.h"; return 2; } if (CheckTypeTag(buf, '\0')) return 9; if (buf->state == GET_ARGS) { PatchMessageSize(buf); } if (buf->state == EMPTY) { /* Need 16 bytes for "#bundle" and time tag */ CheckOverflow(buf, 16); } else { /* This bundle is inside another bundle, so we need to leave a blank size count for the size of this current bundle. */ CheckOverflow(buf, 20); *((int4byte *)buf->bufptr) = 0xaaaaaaaa; buf->prevCounts[buf->bundleDepth] = (int4byte *)buf->bufptr; buf->bufptr += 4; } buf->bufptr += OSC_padString(buf->bufptr, "#bundle"); *((OSCTimeTag *) buf->bufptr) = tt; if (htonl(1) != 1) { /* Byte swap the 8-byte integer time tag */ int4byte *intp = (int4byte *)buf->bufptr; intp[0] = htonl(intp[0]); intp[1] = htonl(intp[1]); #ifdef HAS8BYTEINT { /* tt is a 64-bit int so we have to swap the two 32-bit words. (Otherwise tt is a struct of two 32-bit words, and even though each word was wrong-endian, they were in the right order in the struct.) */ int4byte temp = intp[0]; intp[0] = intp[1]; intp[1] = temp; } #endif } buf->bufptr += sizeof(OSCTimeTag); buf->state = NEED_COUNT; buf->gettingFirstUntypedArg = 0; buf->typeStringPtr = 0; return 0; }
static int OSC_openBundle(OSCbuf *buf, OSCTimeTag tt) { if (buf->state == ONE_MSG_ARGS) { post("packOSC: Can't open a bundle in a one-message packet"); return 3; } if (buf->state == DONE) { post("packOSC: This packet is finished; can't open a new bundle"); return 4; } if (++(buf->bundleDepth) >= MAX_BUNDLE_NESTING) { post("packOSC: Bundles nested too deeply: maybe change MAX_BUNDLE_NESTING from %d and recompile", MAX_BUNDLE_NESTING); return 2; } if (CheckTypeTag(buf, '\0')) return 9; if (buf->state == GET_ARGS) { PatchMessageSize(buf); } if (buf->state == EMPTY) { /* Need 16 bytes for "#bundle" and time tag */ if(OSC_CheckOverflow(buf, 16)) return 1; } else { /* This bundle is inside another bundle, so we need to leave a blank size count for the size of this current bundle. */ if(OSC_CheckOverflow(buf, 20))return 1; *((int4byte *)buf->bufptr) = 0xaaaaaaaa; buf->prevCounts[buf->bundleDepth] = (int4byte *)buf->bufptr; buf->bufptr += 4; } buf->bufptr += OSC_padString(buf->bufptr, "#bundle"); *((OSCTimeTag *) buf->bufptr) = tt; if (htonl(1) != 1) { /* Byte swap the 8-byte integer time tag */ int4byte *intp = (int4byte *)buf->bufptr; intp[0] = htonl(intp[0]); intp[1] = htonl(intp[1]); /* tt is a struct of two 32-bit words, and even though each word was wrong-endian, they were in the right order in the struct.) */ } buf->bufptr += sizeof(OSCTimeTag); buf->state = NEED_COUNT; buf->gettingFirstUntypedArg = 0; buf->typeStringPtr = 0; return 0; }