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; }