void PacketFileWriter::WritePacket(uint16 eq_op, uint32 packlen, const unsigned char *packet, bool to_server, const struct timeval &tv) {
if(out == NULL)
return;
_WriteBlock(eq_op, packet, packlen, to_server, tv);
/*
Could log only the packets we care about, but this is most of the stream,
so just log them all...
switch(eq_op) {
case OP_NewZone:
case OP_ZoneSpawns:
case OP_NewSpawn:
case OP_MobUpdate:
case OP_ClientUpdate:
case OP_Death:
case OP_DeleteSpawn:
case OP_CastSpell:
case OP_ShopRequest:
case OP_ShopEndConfirm:
case OP_ItemPacket:
_WriteBlock(eq_op, packet, packlen);
default:
return;
}
*/
}
void isoFile::WriteBlock(const u8* src, uint lsn)
{
if (m_flags == ISOFLAGS_BLOCKDUMP_V2)
_WriteBlockD(src, lsn);
else
_WriteBlock(src, lsn);
}
void Database::_WriteBlock(Item towrite, uint64_t blockpos) {
backing.seekg(blockpos);
backing.seekp(blockpos);
uint64_t blkhdrs[4];
if (backing.eof()) {
blkhdrs[0] = 0;
blkhdrs[1] = towrite.itemsize;
blkhdrs[2] = towrite.itemsize;
blkhdrs[3] = towrite.itemsize + (sizeof(uint64_t)*4) + 1;
backing.write(0, 1);
backing.write((char*)&blkhdrs, sizeof(uint64_t)*4);
backing.write(towrite.item, towrite.itemsize);
backing.flush();
} else {
_GetLock(blockpos, true);
backing.read((char*)blkhdrs, sizeof(uint64_t)*4);
if (towrite.itemsize + 1 + (sizeof(uint64_t)*4) <= blkhdrs[3]) {
//Block large enough or non-existent block
backing.write(0, 1);
blkhdrs[0] = 0;
blkhdrs[1] = towrite.itemsize;
blkhdrs[2] = towrite.itemsize;
//Keep blkhdrs[3]
backing.write((char*)&blkhdrs, sizeof(uint64_t)*4);
backing.write(towrite.item, towrite.itemsize);
backing.flush();
_ReleaseLock(blockpos, true);
} else {
//Have to continue to a new block, allocate or reuse
std::streampos currentpos = backing.tellp();
backing.seekp(0, std::ios::end);
std::streampos endpos = backing.tellp();
backing.seekp(currentpos, std::ios::beg);
blkhdrs[0] = (uint64_t) endpos;
//Keep blkhdrs[1]
blkhdrs[2] = towrite.itemsize;
//Keep blkhdrs[3]
uint64_t blockcancontain = blkhdrs[3] - ((sizeof(uint64_t)*4) + 1);
backing.write(0, 1);
backing.write((char*)&blkhdrs, sizeof(uint64_t)*4);
backing.write(towrite.item, blockcancontain);
backing.flush();
_ReleaseLock(blockpos, true);
//Continue to next block!
Item process;
process.itemsize = towrite.itemsize-blockcancontain;
process.item = towrite.item+blockcancontain;
_WriteBlock(process, blockpos);
}
}
}
uint64_t Database::AddItem(const Item item) {
Index toadd;
Item topmostblock = _ReadBlock(indexstore.HighestID, 0);
uint64_t blockpos = indexstore.Indexes[indexstore.HighestID].blockoffset+topmostblock.itemsize;
_WriteBlock(item, blockpos);
toadd.blockoffset = blockpos;
toadd.id = indexstore.HighestID+1;
toadd.name = (char*)malloc(strlen(item.name));
strcpy(toadd.name, item.name);
indexstore.Indexes.insert(indexstore.Indexes.end(), toadd);
indexstore.HighestID++;
return toadd.id;
}
// _pageBlock aligns buffer to page boundaries for writing.
// and to TWI buffer size
// returns 0 = OK otherwise error
int I2C_eeprom::_pageBlock(const uint16_t memoryAddress, const uint8_t* buffer, const uint16_t length, const bool incrBuffer)
{
uint16_t addr = memoryAddress;
uint16_t len = length;
int rv = 0;
while (len > 0) // was length
{
uint8_t bytesUntilPageBoundary = this->_pageSize - addr % this->_pageSize;
uint8_t cnt = min(len, bytesUntilPageBoundary);
cnt = min(cnt, I2C_TWIBUFFERSIZE);
int rv = _WriteBlock(addr, buffer, cnt);
if (rv != 0) return rv;
addr += cnt;
if (incrBuffer) buffer += cnt;
len -= cnt;
}
return rv;
}
int I2C_eeprom::writeByte(const uint16_t memoryAddress, const uint8_t data)
{
int rv = _WriteBlock(memoryAddress, &data, 1);
return rv;
}
