/*******************************************************************************
* Move 'len' bytes from 'src' buffer to 'dest' buffer. There must be at
* least 'len' bytes available in the source buffer and space for 'len'
* bytes in the destination buffer.
*/
void fcgi_buf_get_to_buf(Buffer *dest, Buffer *src, int len)
{
char *dest_end, *src_begin;
int dest_len, src_len, move_len;
ASSERT(len > 0);
ASSERT(BufferLength(src) >= len);
ASSERT(BufferFree(dest) >= len);
fcgi_buf_check(src);
fcgi_buf_check(dest);
for (;;) {
if (len == 0)
return;
fcgi_buf_get_free_block_info(dest, &dest_end, &dest_len);
fcgi_buf_get_block_info(src, &src_begin, &src_len);
move_len = min(dest_len, src_len);
move_len = min(move_len, len);
if (move_len == 0)
return;
memcpy(dest_end, src_begin, move_len);
fcgi_buf_toss(src, move_len);
fcgi_buf_add_update(dest, move_len);
len -= move_len;
}
}
// DataSize
size_t
ResourceItem::DataSize() const
{
if (IsModified())
return BufferLength();
return fInitialSize;
}
int CSessionThread::Send(struct packet_s& out_pkt)
{
CSingleLock GateKeeper(&m_ImmediateSendAccess, TRUE);
int retcode, len;
len = BufferLength(out_pkt);
if (len < sizeof(out_pkt.header))
len = sizeof(out_pkt.header);
out_pkt.header.magic = htonl(PKT_MAGIC_NUMBER);
out_pkt.header.size = htons(len);
out_pkt.header.sequence = htonl(++m_sent_packets);
retcode = send(m_socket, (LPSTR)&out_pkt, len, 0);
m_bytes_sent += len;
if (retcode == SOCKET_ERROR)
{
retcode = 0;
if (WSAGetLastError() == WSAECONNRESET) // Conexão abortada
{
m_stop = TRUE;
}
else
{
ReportSocketError(__LINE__);
}
}
return retcode;
}
Handle<Value> MerlinImage::New(const Arguments& args) {
HandleScope scope;
size_t len = BufferLength(args[0]->ToObject());
node::Buffer *tmp = node::Buffer::New(len);
memcpy(BufferData(tmp), BufferData(args[0]->ToObject()), len);
MerlinImage* img = new MerlinImage(tmp);
img->Wrap(args.This());
return scope.Close(args.This());
}
Handle<Value> MerlinImage::GetBuffer(const Arguments& args) {
HandleScope scope;
MerlinImage *img = ObjectWrap::Unwrap<MerlinImage>(args.This());
//fast buffer
Function* fastBufferConstructor = Function::Cast(*Context::GetCurrent()->Global()->Get(String::NewSymbol("Buffer")));
Handle<Value> argv[3] = {
img->buffer->handle_, Integer::New(BufferLength(img->buffer)), Integer::New(0)
};
return scope.Close(fastBufferConstructor->NewInstance(3, argv));
}
static void ReadBinary(P_WBXML_INFO buffer, FILE* file)
{
char buf[4096];
int m = 1;
long n;
if (buffer && file)
{
if (file != stdin)
{
buffer->m_length = FileSize(file);
buffer->m_start = (P_WBXML) malloc(buffer->m_length);
buffer->m_curpos = buffer->m_start;
if (!buffer->m_start)
{
fclose(file);
ParseError(ERR_NOT_ENOUGH_MEMORY);
}
if (fread(buffer->m_start, 1, buffer->m_length, file) != buffer->m_length)
{
fclose(file);
ParseError(ERR_FILE_NOT_READ);
}
else
{
fclose(file);
}
}
else
{
while ((n = fread(buf, 1, sizeof(buf), file)) > 0)
{
buffer->m_start = (P_WBXML) realloc(buffer->m_start, sizeof(buf) * m);
memcpy(buffer->m_start + (sizeof(buf) * (m - 1)), buf, sizeof(buf));
m++;
}
buffer->m_length = BufferLength(buffer);
buffer->m_curpos = buffer->m_start;
}
}
else
{
ParseError(ERR_INTERNAL_BAD_PARAM);
}
}
/*----------------------------------------------------------------------
* Append "len" bytes from "buf" into "arr". Apache arrays are used
* whenever the data being handled is binary (may contain null chars).
*/
void fcgi_buf_get_to_array(Buffer *buf, array_header *arr, int len)
{
int len1 = min(buf->length, buf->data + buf->size - buf->begin);
fcgi_buf_check(buf);
ASSERT(len > 0);
ASSERT(len <= BufferLength(buf));
array_grow(arr, len);
len1 = min(len1, len);
array_cat_block(arr, buf->begin, len1);
if (len1 < len)
array_cat_block(arr, buf->data, len - len1);
fcgi_buf_toss(buf, len);
}
// IsLoaded
bool
ResourceItem::IsLoaded() const
{
return (BufferLength() > 0 || fIsLoaded);
}
MagickWand* MerlinImage::ReadImage(MerlinImage *img) {
MagickWand* wand = NewMagickWand();
MagickReadImageBlob(wand, reinterpret_cast<unsigned char*>(BufferData(img->buffer)), BufferLength(img->buffer));
return wand;
}
