void OutputMessage::addU16(uint16 value)
{
checkWrite(2);
stdext::writeLE16(m_buffer + m_writePos, value);
m_writePos += 2;
m_messageSize += 2;
}
void OutputMessage::addU32(uint32 value)
{
checkWrite(4);
stdext::writeLE32(m_buffer + m_writePos, value);
m_writePos += 4;
m_messageSize += 4;
}
void OutputMessage::addU16(uint16 value)
{
checkWrite(2);
*(uint16_t*)(m_buffer + m_writePos) = value;
m_writePos += 2;
m_messageSize += 2;
}
void OutputMessage::addU64(uint64 value)
{
checkWrite(8);
stdext::writeLE64(m_buffer + m_writePos, value);
m_writePos += 8;
m_messageSize += 8;
}
static VALUE
memory_put_bytes(int argc, VALUE* argv, VALUE self)
{
AbstractMemory* ptr = MEMORY(self);
VALUE offset = Qnil, str = Qnil, rbIndex = Qnil, rbLength = Qnil;
long off, len, idx;
int nargs = rb_scan_args(argc, argv, "22", &offset, &str, &rbIndex, &rbLength);
Check_Type(str, T_STRING);
off = NUM2LONG(offset);
idx = nargs > 2 ? NUM2LONG(rbIndex) : 0;
if (idx < 0) {
rb_raise(rb_eRangeError, "index canot be less than zero");
return Qnil;
}
len = nargs > 3 ? NUM2LONG(rbLength) : (RSTRING_LEN(str) - idx);
if ((idx + len) > RSTRING_LEN(str)) {
rb_raise(rb_eRangeError, "index+length is greater than size of string");
return Qnil;
}
checkWrite(ptr);
checkBounds(ptr, off, len);
if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
return Qnil;
}
memcpy(ptr->address + off, RSTRING_PTR(str) + idx, len);
return self;
}
void GaduSocketNotifiers::createSocketNotifiers()
{
kdebugf();
deleteSocketNotifiers();
if (0 >= Socket)
return;
ReadNotifier = new QSocketNotifier(Socket, QSocketNotifier::Read, this);
connect(ReadNotifier, SIGNAL(activated(int)), this, SLOT(dataReceived()));
if (!checkRead())
ReadNotifier->setEnabled(false);
WriteNotifier = new QSocketNotifier(Socket, QSocketNotifier::Write, this);
connect(WriteNotifier, SIGNAL(activated(int)), this, SLOT(dataSent()));
if (!checkWrite())
WriteNotifier->setEnabled(false);
TimeoutTimer = new QTimer();
TimeoutTimer->setSingleShot(true);
connect(TimeoutTimer, SIGNAL(timeout()), this, SLOT(socketTimeout()));
Started = true;
int tout = timeout();
if (0 < tout)
TimeoutTimer->start(tout);
kdebugf2();
}
BOOL LLVOCache::updateEntry(const HeaderEntryInfo* entry)
{
LLAPRFile* apr_file = new LLAPRFile(mHeaderFileName, APR_WRITE|APR_BINARY, mLocalAPRFilePoolp);
apr_file->seek(APR_SET, entry->mIndex * sizeof(HeaderEntryInfo) + sizeof(HeaderMetaInfo)) ;
return checkWrite(apr_file, (void*)entry, sizeof(HeaderEntryInfo)) ;
}
void OutputMessage::addU32(uint32 value)
{
checkWrite(4);
*(uint32*)(m_buffer + m_writePos) = value;
m_writePos += 4;
m_messageSize += 4;
}
void OutputMessage::addU64(uint64 value)
{
checkWrite(8);
*(uint64*)(m_buffer + m_writePos) = value;
m_writePos += 8;
m_messageSize += 8;
}
void OutputMessage::addU8(uint8 value)
{
checkWrite(1);
m_buffer[m_writePos] = value;
m_writePos += 1;
m_messageSize += 1;
}
void OutputMessage::addPaddingBytes(int bytes, uint8 byte)
{
if(bytes <= 0)
return;
checkWrite(bytes);
memset((void*)&m_buffer[m_writePos], byte, bytes);
m_writePos += bytes;
m_messageSize += bytes;
}
void InputMessage::setBuffer(const std::string& buffer)
{
int len = buffer.size();
checkWrite(MAX_HEADER_SIZE + len);
memcpy(m_buffer + MAX_HEADER_SIZE, buffer.c_str(), len);
m_readPos = MAX_HEADER_SIZE;
m_headerPos = MAX_HEADER_SIZE;
m_messageSize = len;
}
void LLVOCache::writeCacheHeader()
{
if(mReadOnly)
{
return ;
}
LLAPRFile* apr_file = new LLAPRFile(mHeaderFileName, APR_CREATE|APR_WRITE|APR_BINARY, mLocalAPRFilePoolp);
//write the meta element
if(!checkWrite(apr_file, &mMetaInfo, sizeof(HeaderMetaInfo)))
{
return ;
}
mNumEntries = 0 ;
for(header_entry_queue_t::iterator iter = mHeaderEntryQueue.begin() ; iter != mHeaderEntryQueue.end(); ++iter)
{
(*iter)->mIndex = mNumEntries++ ;
if(!checkWrite(apr_file, (void*)*iter, sizeof(HeaderEntryInfo)))
{
return ;
}
}
mNumEntries = mHeaderEntryQueue.size() ;
if(mNumEntries < MAX_NUM_OBJECT_ENTRIES)
{
HeaderEntryInfo* entry = new HeaderEntryInfo() ;
for(S32 i = mNumEntries ; i < MAX_NUM_OBJECT_ENTRIES ; i++)
{
//fill the cache with the default entry.
if(!checkWrite(apr_file, entry, sizeof(HeaderEntryInfo)))
{
mReadOnly = TRUE ; //disable the cache.
return ;
}
}
delete entry ;
}
delete apr_file ;
}
void OutputMessage::addString(const std::string& buffer)
{
int len = buffer.length();
if(len > MAX_STRING_LENGTH)
g_lua.throwError(stdext::format("string length > %d", MAX_STRING_LENGTH));
checkWrite(len + 2);
addU16(len);
memcpy((char*)(m_buffer + m_writePos), buffer.c_str(), len);
m_writePos += len;
m_messageSize += len;
}
void OutputMessage::addString(const char* value)
{
size_t stringLength = strlen(value);
if(stringLength > 65535)
throw NetworkException("[OutputMessage::addString] string length > 65535");
checkWrite(stringLength + 2);
addU16(stringLength);
strcpy((char*)(m_buffer + m_writePos), value);
m_writePos += stringLength;
m_messageSize += stringLength;
}
void RingQueue::Write(const uint8_t* pbuffer, uint32_t len)
{
checkWrite(len);
len = std::min(len,(_capacity-_size));
/* first put the data starting from fifo->in to buffer end */
uint32_t n = std::min(len,_capacity - _in);
memcpy(_buffer + _in, pbuffer,n);
/* then put the rest (if any) at the beginning of the buffer */
memcpy(_buffer, pbuffer + n, len - n);
_in += len;
_in %=_capacity;
_size += len;
}
void GaduSocketNotifiers::enable()
{
kdebugf();
if (!Started || Lock)
return;
if (checkRead())
ReadNotifier->setEnabled(true);
if (checkWrite())
WriteNotifier->setEnabled(true);
int tout = timeout();
if (0 < tout)
TimeoutTimer->start(tout);
}
/*
* call-seq: memory.put_string(offset, str)
* @param [Numeric] offset
* @param [String] str
* @return [self]
* @raise {SecurityError} when writing unsafe string to memory
* @raise {IndexError} if +offset+ is too great
* @raise {NullPointerError} if memory not initialized
* Put a string in memory.
*/
static VALUE
memory_put_string(VALUE self, VALUE offset, VALUE str)
{
AbstractMemory* ptr = MEMORY(self);
long off, len;
Check_Type(str, T_STRING);
off = NUM2LONG(offset);
len = RSTRING_LEN(str);
checkWrite(ptr);
checkBounds(ptr, off, len + 1);
memcpy(ptr->address + off, RSTRING_PTR(str), len);
*((char *) ptr->address + off + len) = '\0';
return self;
}
/*
* call-seq: []=(index, value)
* @param [Numeric] index
* @param [Type, Struct]
* @return [value]
*/
static VALUE
inline_array_aset(VALUE self, VALUE rbIndex, VALUE rbValue)
{
InlineArray* array;
Data_Get_Struct(self, InlineArray, array);
if (array->op != NULL) {
if (unlikely(array->componentType->nativeType == NATIVE_MAPPED)) {
rbValue = rb_funcall(((MappedType *) array->componentType)->rbConverter,
rb_intern("to_native"), 2, rbValue, Qnil);
}
array->op->put(array->memory, inline_array_offset(array, NUM2INT(rbIndex)),
rbValue);
} else if (array->componentType->nativeType == NATIVE_STRUCT) {
int offset = inline_array_offset(array, NUM2INT(rbIndex));
Struct* s;
if (!rb_obj_is_kind_of(rbValue, rbffi_StructClass)) {
rb_raise(rb_eTypeError, "argument not an instance of struct");
return Qnil;
}
checkWrite(array->memory);
checkBounds(array->memory, offset, array->componentType->ffiType->size);
Data_Get_Struct(rbValue, Struct, s);
checkRead(s->pointer);
checkBounds(s->pointer, 0, array->componentType->ffiType->size);
memcpy(array->memory->address + offset, s->pointer->address, array->componentType->ffiType->size);
} else {
ArrayType* arrayType;
Data_Get_Struct(array->field->rbType, ArrayType, arrayType);
rb_raise(rb_eArgError, "set not supported for %s", rb_obj_classname(arrayType->rbComponentType));
return Qnil;
}
return rbValue;
}
static VALUE
memory_put_string(VALUE self, VALUE offset, VALUE str)
{
AbstractMemory* ptr = MEMORY(self);
long off, len;
Check_Type(str, T_STRING);
off = NUM2LONG(offset);
len = RSTRING_LEN(str);
checkWrite(ptr);
checkBounds(ptr, off, len + 1);
if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
return Qnil;
}
memcpy(ptr->address + off, RSTRING_PTR(str), len);
*((char *) ptr->address + off + len) = '\0';
return self;
}
void conditionDrivenWritingFunctionObject::write()
{
bool doWrite=false;
switch(theState_) {
case stateWaiting:
doWrite=checkWrite();
break;
case stateWriting:
switch(writeControlMode_) {
case scmWriteAlways:
doWrite=checkStartWriting();
break;
case scmWriteNTimesteps:
doWrite=(time().timeIndex()<=timestepForStateChange_);
break;
case scmWriteIntervall:
doWrite=(time().value()<=timeForStateChange_);
break;
case scmWriteUntilSwitch:
doWrite=!checkStopWriting();
break;
default:
FatalErrorIn("conditionDrivenWritingFunctionObject::write")
<< "Unimplemented 'writeControlMode'"
<< endl
<< exit(FatalError);
}
if(!doWrite) {
Info << name() << ": Stopped writting. Starting cooldown" << endl;
theState_=stateStartCooldown;
}
break;
case stateCooldown:
{
bool stopCooldown=checkCooldown();
if(stopCooldown) {
Info << name() << " cooldown ended. Writing possible" << endl;
theState_=stateWaiting;
doWrite=checkWrite();
}
}
break;
case stateStartCooldown:
FatalErrorIn("conditionDrivenWritingFunctionObject::write")
<< "State 'startCooldown' should not be reached here"
<< endl
<< exit(FatalError);
default:
FatalErrorIn("conditionDrivenWritingFunctionObject::write")
<< "Unsupported state"
<< endl
<< exit(FatalError);
}
if(theState_==stateStartCooldown) {
theState_=stateCooldown;
switch(cooldownMode_) {
case cdmNoCooldown:
theState_=stateWaiting;
break;
case cdmNTimesteps:
Info << name() << ": Waiting for " << cooldownTimesteps_
<< " till next output" << endl;
timestepForStateChange_=time().timeIndex()+cooldownTimesteps_;
break;
case cdmIntervall:
timeForStateChange_=time().value()+cooldownIntervall_;
Info << name() << ": Waiting till " << timeForStateChange_
<< " till next output" << endl;
break;
case cdmRetrigger:
Info << name() << ": waiting until triggered for next output"
<< endl;
break;
default:
FatalErrorIn("conditionDrivenWritingFunctionObject::write")
<< "Unsupported cooldown mode"
<< endl
<< exit(FatalError);
}
bool stopCooldown=checkCooldown();
if(stopCooldown) {
Info << name() << " cooldown ended. Writing possible" << endl;
theState_=stateWaiting;
doWrite=checkWrite();
}
}
if(doWrite) {
writeNow();
} else {
// don't need to store the state if it was already written
if(storeAndWritePreviousState_) {
storePreviousState();
}
}
}
void LLVOCache::writeToCache(U64 handle, const LLUUID& id, const LLVOCacheEntry::vocache_entry_map_t& cache_entry_map, BOOL dirty_cache)
{
llassert_always(mInitialized);
if(mReadOnly)
{
return ;
}
HeaderEntryInfo* entry;
handle_entry_map_t::iterator iter = mHandleEntryMap.find(handle) ;
if(iter == mHandleEntryMap.end()) //new entry
{
if(mNumEntries >= mCacheSize)
{
purgeEntries() ;
}
entry = new HeaderEntryInfo();
entry->mHandle = handle ;
entry->mTime = time(NULL) ;
entry->mIndex = mNumEntries++ ;
mHeaderEntryQueue.insert(entry) ;
mHandleEntryMap[handle] = entry ;
}
else
{
entry = iter->second ;
entry->mTime = time(NULL) ;
//resort
mHeaderEntryQueue.erase(entry) ;
mHeaderEntryQueue.insert(entry) ;
}
//update cache header
if(!updateEntry(entry))
{
return ; //update failed.
}
if(!dirty_cache)
{
return ; //nothing changed, no need to update.
}
//write to cache file
std::string filename;
getObjectCacheFilename(handle, filename);
LLAPRFile* apr_file = new LLAPRFile(filename, APR_CREATE|APR_WRITE|APR_BINARY, mLocalAPRFilePoolp);
if(!checkWrite(apr_file, (void*)id.mData, UUID_BYTES))
{
return ;
}
S32 num_entries = cache_entry_map.size() ;
if(!checkWrite(apr_file, &num_entries, sizeof(S32)))
{
return ;
}
for (LLVOCacheEntry::vocache_entry_map_t::const_iterator iter = cache_entry_map.begin(); iter != cache_entry_map.end(); ++iter)
{
if(!iter->second->writeToFile(apr_file))
{
//failed
delete apr_file ;
removeCache() ;
return ;
}
}
delete apr_file ;
return ;
}
void BufWriter::writeBlock(const void* p, size_t bytes)
{
checkWrite(bytes);
memcpy(m_pPos, p, bytes);
m_pPos += bytes;
}
/*
* call-seq: put(pointer, value)
* @param [AbstractMemory] pointer pointer on a {Struct}
* @param [String, Array] value +value+ may be a String only if array's type is a kind of +int8+
* @return [value]
* Set an array in a {Struct}.
*/
static VALUE
array_field_put(VALUE self, VALUE pointer, VALUE value)
{
StructField* f;
ArrayType* array;
Data_Get_Struct(self, StructField, f);
Data_Get_Struct(f->rbType, ArrayType, array);
if (isCharArray(array) && rb_obj_is_instance_of(value, rb_cString)) {
VALUE argv[2];
argv[0] = INT2FIX(f->offset);
argv[1] = value;
rb_funcall2(pointer, rb_intern("put_string"), 2, argv);
} else {
#ifdef notyet
MemoryOp* op;
int count = RARRAY_LEN(value);
int i;
AbstractMemory* memory = MEMORY(pointer);
if (count > array->length) {
rb_raise(rb_eIndexError, "array too large");
}
/* clear the contents in case of a short write */
checkWrite(memory);
checkBounds(memory, f->offset, f->type->ffiType->size);
if (count < array->length) {
memset(memory->address + f->offset + (count * array->componentType->ffiType->size),
0, (array->length - count) * array->componentType->ffiType->size);
}
/* now copy each element in */
if ((op = get_memory_op(array->componentType)) != NULL) {
for (i = 0; i < count; ++i) {
(*op->put)(memory, f->offset + (i * array->componentType->ffiType->size), rb_ary_entry(value, i));
}
} else if (array->componentType->nativeType == NATIVE_STRUCT) {
for (i = 0; i < count; ++i) {
VALUE entry = rb_ary_entry(value, i);
Struct* s;
if (!rb_obj_is_kind_of(entry, rbffi_StructClass)) {
rb_raise(rb_eTypeError, "array element not an instance of FFI::Struct");
break;
}
Data_Get_Struct(entry, Struct, s);
checkRead(s->pointer);
checkBounds(s->pointer, 0, array->componentType->ffiType->size);
memcpy(memory->address + f->offset + (i * array->componentType->ffiType->size),
s->pointer->address, array->componentType->ffiType->size);
}
} else {
rb_raise(rb_eNotImpError, "put not supported for arrays of type %s", rb_obj_classname(array->rbComponentType));
}
#else
rb_raise(rb_eNotImpError, "cannot set array field");
#endif
}
return value;
}
void InputMessage::fillBuffer(uint8 *buffer, uint16 size)
{
checkWrite(m_readPos + size);
memcpy(m_buffer + m_readPos, buffer, size);
m_messageSize += size;
}
