/* data [, errmsg] = socket:receive(size) */
static int cnt_receive (lua_State *L) {
loski_NetDriver *drv = (loski_NetDriver *)lua_touserdata(L, lua_upvalueindex(1));
loski_Socket *socket = tosock(L, LOSKI_CONNSOCKET);
luaL_Buffer lbuf;
size_t sz, len;
char *buf = newbuffer(L, 2, &lbuf, &sz);
int res = loski_recvfromsocket(drv, socket, buf, sz, &len, NULL);
if (res == 0) {
luaL_addsize(&lbuf, len);
luaL_pushresult(&lbuf); /* close buffer */
}
return pushsockres(L, 1, res);
}
int main() {
int active = true;
char c;
Buffer filebuffer;
printf("creating buffer");
newbuffer(1024, filebuffer);
printf("created buffer");
while (active == TRUE) {
c = getchar(); // Get new character
printf("In: %s; Buffer: %s", c, filebuffer);
if (strlen(filebuffer.content) >= filebuffer.size) {
rebuffer(1024, filebuffer); // Add 1024 bytes to buffer
}
strcat(filebuffer.content, &c); // Add new character
active = !(c == KEY_ESC);
}
printf("terminated without crashes");
return 0;
}
/* data [, errmsg] = socket:receive(size [, getfrom]) */
static int dgm_receive (lua_State *L) {
loski_NetDriver *drv = (loski_NetDriver *)lua_touserdata(L, lua_upvalueindex(1));
loski_Socket *socket = tosock(L, LOSKI_DGRMSOCKET);
luaL_Buffer lbuf;
size_t sz, len;
char *buf = newbuffer(L, 2, &lbuf, &sz);
int res, nr = 1;
if (lua_toboolean(L, 3)) {
loski_Address address;
res = loski_recvfromsocket(drv, socket, buf, sz, &len, &address);
if (res == 0) {
luaL_addsize(&lbuf, len);
luaL_pushresult(&lbuf); /* close buffer */
nr += pushaddress(drv, L, &address);
}
} else {
res = loski_recvfromsocket(drv, socket, buf, sz, &len, NULL);
if (res == 0) {
luaL_addsize(&lbuf, len);
luaL_pushresult(&lbuf); /* close buffer */
}
}
return pushsockres(L, nr, res);
}
charset *parsecharset(const char *str, errmsg_t errmsg)
{
charset *cset = NULL;
buffer *cbuf = NULL;
const wchar_t *p, * const singleescapes = L"_sbqQx";
int hex1, hex2;
wchar_t ch;
wchar_t *wstr;
wstr = (wchar_t *) malloc((strlen(str) + 1) * sizeof(wchar_t));
if (!wstr) {
wcscpy(errmsg,outofmem);
goto pcserror;
}
if ((size_t)(-1) == mbstowcs(wstr, str, strlen(str) + 1)) {
wcscpy(errmsg,mbserror);
goto pcserror;
}
cset = malloc(sizeof (charset));
if (!cset) {
wcscpy(errmsg,outofmem);
goto pcserror;
}
cset->inlist = cset->outlist = NULL;
cset->flags = 0;
cbuf = newbuffer(sizeof (wchar_t), errmsg);
if (*errmsg) goto pcserror;
for (p = wstr; *p; ++p)
if (*p == L'_') {
++p;
if (appearsin(*p, singleescapes)) {
if (*p == L'_') ch = L'_' ;
else if (*p == L's') ch = L' ' ;
else if (*p == L'b') ch = L'\\';
else if (*p == L'q') ch = L'\'';
else if (*p == L'Q') ch = L'\"';
else /* *p == 'x' */ {
/* FIXME _x metacharacter should allow wide characters input.*/
hex1 = hexdigtoint(p[1]);
hex2 = hexdigtoint(p[2]);
if (hex1 < 0 || hex2 < 0) goto pcsbadstr;
ch = 16 * hex1 + hex2;
p += 2;
}
if (!ch)
cset->flags |= CS_NUL;
else {
additem(cbuf, &ch, errmsg);
if (*errmsg) goto pcserror;
}
}
else {
if (*p == L'A') cset->flags |= CS_UCASE;
else if (*p == L'a') cset->flags |= CS_LCASE;
else if (*p == L'0') cset->flags |= CS_DIGIT;
else goto pcsbadstr;
}
}
else {
additem(cbuf, p,errmsg);
if (*errmsg) goto pcserror;
}
ch = '\0';
additem(cbuf, &ch, errmsg);
if (*errmsg) goto pcserror;
cset->inlist = copyitems(cbuf,errmsg);
if (*errmsg) goto pcserror;
pcscleanup:
if (cbuf) freebuffer(cbuf);
if (wstr) free(wstr);
return cset;
pcsbadstr:
swprintf(errmsg, errmsg_size, L"Bad charset syntax: %.*s\n", errmsg_size - 22, str);
pcserror:
if (cset) freecharset(cset);
cset = NULL;
goto pcscleanup;
}
static charset *csud(
int u, const charset *cset1, const charset *cset2, errmsg_t errmsg
)
/* Returns the union of cset1 and cset2 if u is 1, or the set */
/* difference cset1 - cset2 if u is 0. Returns NULL on failure. */
{
charset *csu;
buffer *inbuf = NULL, *outbuf = NULL;
wchar_t *lists[4], **list, *p, nullchar = L'\0';
csu = malloc(sizeof (charset));
if (!csu) {
wcscpy(errmsg,outofmem);
goto csuderror;
}
inbuf = newbuffer(sizeof (wchar_t), errmsg);
if (*errmsg) goto csuderror;
outbuf = newbuffer(sizeof (wchar_t), errmsg);
if (*errmsg) goto csuderror;
csu->inlist = csu->outlist = NULL;
csu->flags = u ? cset1->flags | cset2->flags
: cset1->flags & ~cset2->flags;
lists[0] = cset1->inlist;
lists[1] = cset1->outlist;
lists[2] = cset2->inlist;
lists[3] = cset2->outlist;
for (list = lists; list < lists + 4; ++list)
if (*list) {
for (p = *list; *p; ++p)
if (u ? csmember(*p, cset1) || csmember(*p, cset2)
: csmember(*p, cset1) && !csmember(*p, cset2)) {
if (!csmember(*p, csu)) {
additem(inbuf,p,errmsg);
if (*errmsg) goto csuderror;
}
}
else
if (csmember(*p, csu)) {
additem(outbuf,p,errmsg);
if (*errmsg) goto csuderror;
}
}
additem(inbuf, &nullchar, errmsg);
if (*errmsg) goto csuderror;
additem(outbuf, &nullchar, errmsg);
if (*errmsg) goto csuderror;
csu->inlist = copyitems(inbuf,errmsg);
if (*errmsg) goto csuderror;
csu->outlist = copyitems(outbuf,errmsg);
if (*errmsg) goto csuderror;
csudcleanup:
if (inbuf) freebuffer(inbuf);
if (outbuf) freebuffer(outbuf);
return csu;
csuderror:
if (csu) freecharset(csu);
csu = NULL;
goto csudcleanup;
}
/*
========================
idSnapShot::ReadDelta
========================
*/
bool idSnapShot::ReadDelta( idFile* file, int visIndex )
{
file->ReadBig( time );
int objectNum = 0;
uint16 delta = 0;
while( file->ReadBig( delta ) == sizeof( delta ) )
{
objectNum += delta;
if( objectNum >= 0xFFFF )
{
// full delta
return true;
}
objectState_t& state = FindOrCreateObjectByID( objectNum );
objectSize_t newsize = 0;
file->ReadBig( newsize );
if( newsize == SIZE_STALE )
{
NET_VERBOSESNAPSHOT_PRINT( "read delta: object %d goes stale\n", objectNum );
// sanity
bool oldVisible = ( state.visMask & ( 1 << visIndex ) ) != 0;
if( !oldVisible )
{
NET_VERBOSESNAPSHOT_PRINT( "ERROR: unexpected already stale\n" );
}
state.visMask &= ~( 1 << visIndex );
state.stale = true;
// We need to make sure we haven't freed stale objects.
assert( state.buffer.Size() > 0 );
// no more data
continue;
}
else if( newsize == SIZE_NOT_STALE )
{
NET_VERBOSESNAPSHOT_PRINT( "read delta: object %d no longer stale\n", objectNum );
// sanity
bool oldVisible = ( state.visMask & ( 1 << visIndex ) ) != 0;
if( oldVisible )
{
NET_VERBOSESNAPSHOT_PRINT( "ERROR: unexpected not stale\n" );
}
state.visMask |= ( 1 << visIndex );
state.stale = false;
// the latest state is packed in, get the new size and continue reading the new state
file->ReadBig( newsize );
}
if( newsize == 0 )
{
// object deleted
state.buffer._Release();
}
else
{
objectBuffer_t newbuffer( newsize );
objectSize_t compareSize = Min( newsize, state.buffer.Size() );
for( objectSize_t i = 0; i < compareSize; i++ )
{
uint8 delta = 0;
file->ReadBig<byte>( delta );
newbuffer[i] = state.buffer[i] + delta;
}
if( newsize > compareSize )
{
file->Read( newbuffer.Ptr() + compareSize, newsize - compareSize );
}
state.buffer = newbuffer;
state.changedCount++;
}
#ifdef SNAPSHOT_CHECKSUMS
if( state.buffer.Size() > 0 )
{
unsigned int checksum = 0;
file->ReadBig( checksum );
assert( checksum == MD5_BlockChecksum( state.buffer.Ptr(), state.buffer.Size() ) );
}
#endif
}
// partial delta
return false;
}
/*
========================
idSnapShot::ReadDeltaForJob
========================
*/
bool idSnapShot::ReadDeltaForJob( const char* deltaMem, int deltaSize, int visIndex, idSnapShot* templateStates )
{
bool report = net_verboseSnapshotReport.GetBool();
net_verboseSnapshotReport.SetBool( false );
lzwCompressionData_t lzwData;
idZeroRunLengthCompressor rleCompressor;
idLZWCompressor lzwCompressor( &lzwData );
int bytesRead = 0; // how many uncompressed bytes we read in. Used to figure out compression ratio
lzwCompressor.Start( ( uint8* )deltaMem, deltaSize );
// Skip past sequence and baseSequence
int sequence = 0;
int baseSequence = 0;
lzwCompressor.ReadAgnostic( sequence );
lzwCompressor.ReadAgnostic( baseSequence );
lzwCompressor.ReadAgnostic( time );
bytesRead += sizeof( int ) * 3;
int objectNum = 0;
uint16 delta = 0;
while( lzwCompressor.ReadAgnostic( delta, true ) == sizeof( delta ) )
{
bytesRead += sizeof( delta );
objectNum += delta;
if( objectNum >= 0xFFFF )
{
// full delta
if( net_verboseSnapshotCompression.GetBool() )
{
float compRatio = static_cast<float>( deltaSize ) / static_cast<float>( bytesRead );
idLib::Printf( "Snapshot (%d/%d). ReadSize: %d DeltaSize: %d Ratio: %.3f\n", sequence, baseSequence, bytesRead, deltaSize, compRatio );
}
return true;
}
objectState_t& state = FindOrCreateObjectByID( objectNum );
objectSize_t newsize = 0;
lzwCompressor.ReadAgnostic( newsize );
bytesRead += sizeof( newsize );
if( newsize == SIZE_STALE )
{
NET_VERBOSESNAPSHOT_PRINT( "read delta: object %d goes stale\n", objectNum );
// sanity
bool oldVisible = ( state.visMask & ( 1 << visIndex ) ) != 0;
if( !oldVisible )
{
NET_VERBOSESNAPSHOT_PRINT( "ERROR: unexpected already stale\n" );
}
state.visMask &= ~( 1 << visIndex );
state.stale = true;
// We need to make sure we haven't freed stale objects.
assert( state.buffer.Size() > 0 );
// no more data
continue;
}
else if( newsize == SIZE_NOT_STALE )
{
NET_VERBOSESNAPSHOT_PRINT( "read delta: object %d no longer stale\n", objectNum );
// sanity
bool oldVisible = ( state.visMask & ( 1 << visIndex ) ) != 0;
if( oldVisible )
{
NET_VERBOSESNAPSHOT_PRINT( "ERROR: unexpected not stale\n" );
}
state.visMask |= ( 1 << visIndex );
state.stale = false;
// the latest state is packed in, get the new size and continue reading the new state
lzwCompressor.ReadAgnostic( newsize );
bytesRead += sizeof( newsize );
}
objectState_t* objTemplateState = templateStates->FindObjectByID( objectNum );
if( newsize == 0 )
{
// object deleted: reset state now so next one to use it doesn't have old data
state.deleted = false;
state.stale = false;
state.changedCount = 0;
state.expectedSequence = 0;
state.visMask = 0;
state.buffer._Release();
state.createdFromTemplate = false;
if( objTemplateState != NULL && objTemplateState->buffer.Size() && objTemplateState->expectedSequence < baseSequence )
{
idLib::PrintfIf( net_ssTemplateDebug.GetBool(), "Clearing old template state[%d] [%d<%d]\n", objectNum, objTemplateState->expectedSequence, baseSequence );
objTemplateState->deleted = false;
objTemplateState->stale = false;
objTemplateState->changedCount = 0;
objTemplateState->expectedSequence = 0;
objTemplateState->visMask = 0;
objTemplateState->buffer._Release();
}
}
else
{
// new state?
bool debug = false;
if( state.buffer.Size() == 0 )
{
state.createdFromTemplate = true;
// Brand new state
if( objTemplateState != NULL && objTemplateState->buffer.Size() > 0 && sequence >= objTemplateState->expectedSequence )
{
idLib::PrintfIf( net_ssTemplateDebug.GetBool(), "\nAdding basestate for new object %d (for SS %d/%d. obj base created in ss %d) deltaSize: %d\n", objectNum, sequence, baseSequence, objTemplateState->expectedSequence, deltaSize );
state.buffer = objTemplateState->buffer;
if( net_ssTemplateDebug.GetBool() )
{
state.Print( "SPAWN STATE" );
debug = true;
PrintAlign( "DELTA STATE" );
}
}
else if( net_ssTemplateDebug.GetBool() )
{
idLib::Printf( "\nNew snapobject[%d] in snapshot %d/%d but no basestate found locally so creating new\n", objectNum, sequence, baseSequence );
}
}
else
{
state.createdFromTemplate = false;
}
// the buffer shrank or stayed the same
objectBuffer_t newbuffer( newsize );
rleCompressor.Start( NULL, &lzwCompressor, newsize );
objectSize_t compareSize = Min( state.buffer.Size(), newsize );
for( objectSize_t i = 0; i < compareSize; i++ )
{
byte b = rleCompressor.ReadByte();
newbuffer[i] = state.buffer[i] + b;
if( debug && InDebugRange( i ) )
{
idLib::Printf( "%02X", b );
}
}
// Catch leftover
if( newsize > compareSize )
{
rleCompressor.ReadBytes( newbuffer.Ptr() + compareSize, newsize - compareSize );
if( debug )
{
for( objectSize_t i = compareSize; i < newsize; i++ )
{
if( InDebugRange( i ) )
{
idLib::Printf( "%02X", newbuffer[i] );
}
}
}
}
state.buffer = newbuffer;
state.changedCount = sequence;
bytesRead += sizeof( byte ) * newsize;
if( debug )
{
idLib::Printf( "\n" );
state.Print( "NEW STATE" );
}
if( report )
{
idLib::Printf( " Obj %d Compressed: Size %d \n", objectNum, rleCompressor.CompressedSize() );
}
}
#ifdef SNAPSHOT_CHECKSUMS
extern uint32 SnapObjChecksum( const uint8 * data, int length );
if( state.buffer.Size() > 0 )
{
uint32 checksum = 0;
lzwCompressor.ReadAgnostic( checksum );
bytesRead += sizeof( checksum );
if( !verify( checksum == SnapObjChecksum( state.buffer.Ptr(), state.buffer.Size() ) ) )
{
idLib::Error( " Invalid snapshot checksum" );
}
}
#endif
}
// partial delta
return false;
}
void ImageSharpnessScorer::SetImage(unsigned char * buffer, int width, int height, int depth)
{
ImgBuffer newbuffer(width,height,depth);
newbuffer.SetPixels(buffer);
buffer_ = newbuffer;
}