bool ZSurface::Load(int w, int h, int bpp, int pitch, u32 rmask, u32 gmask, u32 bmask, u32 amask, const u8* p, size_t s)
{
buf = zlibDecompress(p, s);
if(! buf.empty())
{
Set(SDL_CreateRGBSurfaceFrom(&buf[0], w, h, bpp, pitch, rmask, gmask, bmask, amask));
return true;
}
return false;
}
void testCompress(void)
{
static char* testpattern = "this is harry's test";
int c_size,
p_size,
size,
u_size;
char* buffer;
char* c_buffer;
char* errormsg;
char* u_buffer;
TRACE(99, "testCompress()", NULL);
/* each test tries a different buffer size*/
if (!strcmp(config -> testrun, "compress1"))
{ size = 1048576; }
else if (!strcmp(config -> testrun, "compress2"))
{ size = 524288; }
else if (!strcmp(config -> testrun, "compress3"))
{ size = BUFFERSIZE + 1; }
else if (!strcmp(config -> testrun, "compress4"))
{ size = BUFFERSIZE; }
else if (!strcmp(config -> testrun, "compress5"))
{ size = 128; }
else if (!strcmp(config -> testrun, "compress6"))
{ size = 32; }
else
{ return; }
buffer = memAlloc(__FILE__, __LINE__, size);
/* we fill our test buffer */
p_size = strlen(testpattern);
u_size = 0;
while (u_size + p_size + 1 < size)
{
/* Flawfinder: ignore */
memcpy(buffer + u_size, testpattern, p_size);
u_size += p_size;
}
zlibCompress(buffer, size, &c_buffer, &c_size, &errormsg);
fprintf(stderr, "buffer size: %d -> %d\n", size, c_size);
zlibDecompress(c_buffer, c_size, &u_buffer, &u_size, &errormsg);
fprintf(stderr, "buffer size: %d -> %d\n", c_size, u_size);
if (size == u_size)
{ fprintf(stderr, "buffer size ok\n"); }
else
{ fprintf(stderr, "buffer size error\n"); }
if (!memcmp(buffer, u_buffer, size))
{ fprintf(stderr, "buffer ok\n"); }
else
{ fprintf(stderr, "buffer error\n"); }
memFree(__FILE__, __LINE__, c_buffer, c_size);
memFree(__FILE__, __LINE__, u_buffer, u_size);
memFree(__FILE__, __LINE__, buffer, size);
}
void BaseClient::onPackageReceived(const NetPackageHeader& header, const unsigned char* contentP, const size_t& contentLen, boost::shared_ptr<NetConnection> connection)
{
if (contentLen <= 0 || NULL == connection)
{
return ;
}
ByteArray tmpData;
if (header.m_flag.compress == COMPRESS_ZLIB || header.m_flag.compress == COMPRESS_DOUBLE_ZLIB)
{
if (header.m_flag.compress == COMPRESS_DOUBLE_ZLIB && connection->m_compressType != COMPRESS_DOUBLE_ZLIB)
{
connection->m_compressType = COMPRESS_DOUBLE_ZLIB;
}
bool bOK = zlibDecompress(const_cast<unsigned char*>(contentP), contentLen, tmpData, 0);
if (tmpData.empty())
{
return;
}
if (bOK)
{
if (tmpData.size() <= 0)
{
return;
}
}
}
else if (header.m_flag.compress == COMPRESS_LZMA || header.m_flag.compress == COMPRESS_DOUBLE_LZMA)
{
if (header.m_flag.compress == COMPRESS_DOUBLE_LZMA && connection->m_compressType != COMPRESS_DOUBLE_LZMA)
{
connection->m_compressType = COMPRESS_DOUBLE_LZMA;
}
bool bOK = LzmaDecomp(const_cast<unsigned char*>(contentP), contentLen, tmpData, 0);
if (tmpData.empty())
{
return;
}
if (bOK)
{
if (tmpData.size() <= 0)
{
return;
}
}
}
switch (header.m_cmd)
{
case NET_CMD_RPC:
{
string status;
if (jsonHelper::getInstance()->getField(status, "status",tmpData))
{
r_int64 seq = header.m_seq;
CBTable::iterator ret = m_CBs.find(seq);
if (ret != m_CBs.end())
{
ByteArray param;
string error;
jsonHelper::getInstance()->getField(error, "error",tmpData);
if (jsonHelper::getInstance()->getSubJson(param, "param", tmpData))
{
ret->second(param, error);
{
boost::mutex::scoped_lock lock(m_mutex);
m_CBs.erase(seq);
}
}
}
}
}
break;
case NET_CMD_KEEPALIVE:
{
NetPackageHeader header(NET_CMD_KEEPALIVE_RESPONSE, 0, 0, 0);
header.m_length = sizeof(r_int32) + NET_PACKAGE_HEADER_LENGTH;
ByteArray bytes;
bytes.resize(sizeof(r_int32) + NET_PACKAGE_HEADER_LENGTH);
r_int32 pos = header.encode(bytes);
connection->sendData(bytes, bytes.size());
}
break;
case NET_CMD_KEEPALIVE_RESPONSE: //接收到心跳包反馈
break;
default:
break;
}
}
/* #############################################################################
*
* Description read, decrypt and parse the given filename
* Author Harry Brueckner
* Date 2005-03-18
* Arguments char* filename - filename to read
* char** errormsg - pointer to the GpgMe error message, if any
* PASSPHRASE_FN - passphrase callback function
* SHOWERROR_FN - callback function for error messages
* Return 1 on error, otherwise 0
*/
int xmlDataFileRead(char* filename, char** errormsg,
PASSPHRASE_FN passphrase_cb, SHOWERROR_FN showerror_cb)
{
xmlNode* node;
struct stat filestat;
off_t size;
int error = 0,
fd,
gpgsize = 0,
validate;
char* buffer = NULL;
char* gpgbuffer = NULL;
char* tmpbuffer = NULL;
TRACE(99, "xmlDataFileRead()", NULL);
/* we initialize the error message */
*errormsg = NULL;
fd = fileLockOpen(filename, O_RDONLY, -1, &tmpbuffer);
if (fd == -1)
{ /* unable to read the file, we start a new one */
showerror_cb(_("file error"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
if (fileExists(filename))
{ /* if the file exists and we can't read it it's a hard error and
* we must not continue; we don't need another error message since
* we already had one displayed.
*/
return 1;
}
/* we create a new, empty document */
xmldoc = xmlNewDoc(BAD_CAST "1.0");
node = xmlNewDocNode(xmldoc, NULL, BAD_CAST "root", NULL);
xmlDocSetRootElement(xmldoc, node);
createEditorsNode();
createTemplateNode();
/* we insert the current version and also create the created and
* modified entries.
*/
xmlVersionUpdate(1);
checkDtd(showerror_cb);
keyDefaults();
/* we created a new document, so it's changed */
runtime -> datachanged = 1;
}
else if (!fstat(fd, &filestat) &&
filestat.st_size)
{ /* we found a file and have to read it */
size = filestat.st_size;
buffer = memAlloc(__FILE__, __LINE__, size);
/* Flawfinder: ignore */
if (read(fd, buffer, size) != size)
{
memFree(__FILE__, __LINE__, buffer, size);
return 1;
}
close(fd);
if (config -> encryptdata)
{
error = gpgDecrypt(buffer, size, &gpgbuffer, &gpgsize,
passphrase_cb, showerror_cb);
if (error)
{ *errormsg = _("could not decrypt database file."); }
/* since we decrypted the file, we swap buffers */
memFree(__FILE__, __LINE__, buffer, size);
buffer = gpgbuffer;
size = gpgsize;
#ifdef TEST_OPTION
if (config -> testrun &&
!strcmp("decrypt", config -> testrun) &&
buffer)
{ printf("%s", buffer); }
#endif
/* TODO: add the same keys as used in the encrypted file;
* For now we just always add the default keys
*/
if (runtime -> realmhint)
{ /* if we have a realm, we add it to the default keys since we
* probably want to encrypt data for ourselves as well
*/
config -> defaultkeys = listAdd(config -> defaultkeys,
runtime -> realmhint);
}
keyDefaults();
}
else
{
/* if we run in unencrypted mode, we must add all default keys */
keyDefaults();
showerror_cb(_("warning"), _("the database file is read in unecrypted mode."));
}
if (!error &&
buffer[0] == '\x1f' && buffer[1] == '\x8b')
{ /* we have a gzipped buffer and must compress it */
error = zlibDecompress(buffer, size, &gpgbuffer, &gpgsize,
errormsg);
if (error)
{
tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
snprintf(tmpbuffer, STDBUFFERLENGTH,
_("error (%s) compressing file '%s'."),
*errormsg,
filename);
showerror_cb(_("compression error"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
memFree(__FILE__, __LINE__, buffer, size);
return 1;
}
memFree(__FILE__, __LINE__, buffer, size);
buffer = gpgbuffer;
size = gpgsize;
}
else
{
if (!error && config -> compression > 0)
{
tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
snprintf(tmpbuffer, STDBUFFERLENGTH,
_("database '%s' was not compressed."),
filename);
showerror_cb(_("warning"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
}
}
if (!error)
{
xmldoc = xmlReadMemory(buffer, size, filename, config -> encoding,
XML_PARSE_PEDANTIC | XML_PARSE_NONET | XML_PARSE_NOCDATA);
if (!xmldoc)
{
memFree(__FILE__, __LINE__, buffer, size);
tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
snprintf(tmpbuffer, STDBUFFERLENGTH,
_("failed to parse xml document '%s'."),
filename);
showerror_cb(_("file error"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
return 1;
}
}
if (buffer)
{ memFree(__FILE__, __LINE__, buffer, size); }
/* we update our document version */
if (!error)
{ xmlVersionUpdate(0); }
if (!error)
{
validate = checkDtd(showerror_cb);
if (validate != 1)
{
tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
snprintf(tmpbuffer, STDBUFFERLENGTH,
_("failed to validate xml document '%s'."),
filename);
showerror_cb(_("file error"), tmpbuffer);
memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
return 1;
}
}
}
else
{ /* the given file has size 0 */
error = 1;
}
return error;
}
