示例#1
0
void BStream_writeTaggedData_length_(BStream *self, const unsigned char *data, size_t length)
{
	BStream_writeTag(self, BSTREAM_UNSIGNED_INT, 1, 1);
	BStream_writeTaggedInt32_(self, length);
	UArray_appendBytes_size_(self->ba, (unsigned char *)data, length);
	self->index += length;
}
示例#2
0
文件: AudioDevice.c 项目: ADTSH/io
void AudioDevice_writeData_length_(AudioDevice *self, uint8_t *data, size_t numBytes)
{
	self->writeBufferIsEmpty = 0;
	AudioDevice_lock(self);
	UArray_appendBytes_size_(self->nextWriteBuffer, data, numBytes);
	self->needsData = 0;
	//printf("writting self->needsData = 0\n");
	AudioDevice_unlock(self);
	AudioDevice_start(self);
}
示例#3
0
void BStream_writeNumber_size_(BStream *self, unsigned char *v, size_t length)
{
	memcpy(self->typeBuf, v, length);

	if (self->flipEndian)
	{
		reverseBytes(self->typeBuf, length);
	}

	UArray_appendBytes_size_(self->ba, (unsigned char *)self->typeBuf, length);
	self->index += length;
}
示例#4
0
UArray *UArray_asNumberArrayString(const UArray *self)
{
    UArray *out = UArray_new();
    UArray_setEncoding_(out, CENCODING_ASCII);

    UARRAY_INTFOREACH(self, i, v,
                      char s[128];

                      if(UArray_isFloatType(self))
{
    sprintf(s, "%f", (double)v);
    }
    else
    {
        sprintf(s, "%i", (int)v);
    }

    if(i != UArray_size(self) -1 ) strcat(s, ", ");
    UArray_appendBytes_size_(out, (unsigned char *)s, strlen(s));
                     );
示例#5
0
文件: IoBlowfish.c 项目: anthem/io
IoObject *IoBlowfish_process(IoBlowfish *self, IoObject *locals, IoMessage *m)
{
	/*doc Blowfish process
	Process the inputBuffer and appends the result to the outputBuffer.
	The processed inputBuffer is empties except for the spare 
	bytes at the end which don't fit into a cipher block.
	*/
	blowfish_ctx *context = &(DATA(self)->context);
	int isEncrypting = DATA(self)->isEncrypting;

	UArray *input = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("inputBuffer"));
	UArray *output = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("outputBuffer"));

	const unsigned char *inputBytes  = (uint8_t *)UArray_bytes(input);
	size_t inputSize = UArray_sizeInBytes(input);

	unsigned long lr[2];
	size_t i, runs = inputSize / sizeof(lr);

	for (i = 0; i < runs; i ++)
	{
		memcpy(lr, inputBytes, sizeof(lr));

		inputBytes += sizeof(lr);

		if (isEncrypting)
		{
			blowfish_encrypt(context, &lr[0], &lr[1]);
		}
		else
		{
			blowfish_decrypt(context, &lr[0], &lr[1]);
		}

		UArray_appendBytes_size_(output, (unsigned char *)&lr, sizeof(lr));
	}

	UArray_removeRange(input, 0, runs * sizeof(lr));
	return self;
}
示例#6
0
文件: IoBlowfish.c 项目: anthem/io
IoObject *IoBlowfish_endProcessing(IoBlowfish *self, IoObject *locals, IoMessage *m)
{
	/*doc Blowfish endProcessing
	Finish processing remaining bytes of inputBuffer.
	*/

	blowfish_ctx *context = &(DATA(self)->context);
	unsigned long lr[2];

	IoBlowfish_process(self, locals, m); // process the full blocks first


	{
		int isEncrypting = DATA(self)->isEncrypting;

		UArray *input  = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("inputBuffer"));
		UArray *output = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("outputBuffer"));

		IOASSERT(UArray_sizeInBytes(input) < sizeof(lr), "internal error - too many bytes left in inputBuffer");

		memset(lr, 0, sizeof(lr));
		memcpy(lr, (uint8_t *)UArray_bytes(input), UArray_sizeInBytes(input));

		if (isEncrypting)
		{
			blowfish_encrypt(context, &lr[0], &lr[1]);
		}
		else
		{
			blowfish_decrypt(context, &lr[0], &lr[1]);
		}

		UArray_appendBytes_size_(output, (unsigned char *)&lr, sizeof(lr));

		UArray_setSize_(input, 0);
	}
	return self;
}
示例#7
0
void BStream_writeData_length_(BStream *self, const unsigned char *data, size_t length)
{
	UArray_appendBytes_size_(self->ba, (unsigned char *)data, length);
	self->index += length;
}