std::set<std::string> FileSniffer::getLastResult()
{
std::set<std::string> lastresult;
try{
std::string* resultfile = new std::string();
if(fexists(resultFilePath.c_str())) //Check if result text file exists
{
resultfile = loadFile(resultFilePath);
XmlReader rdr(*resultfile);
while(rdr.next())
{ //Scan through the xml and search for filepath tag
if(rdr.tag() == "listsize")
{
if(rdr.body() == "0")
break;
}
if(rdr.tag() == "filepath")
lastresult.insert(rdr.body());
}
delete resultfile;
}
}catch(std::exception& ex){
std::cout << "\n\n " << ex.what() << "\n\n"; }
return lastresult;
}
//////////////////////////////////////////////////////////////
///Checks if the specified path is the excluded paths
inline bool FileSniffer::isInExcluded(std::string path)
{
try{
std::string::reverse_iterator rit;
rit=path.rbegin();
if(!path.empty() && *rit=='.') //remove . and .. dirctories from paths
return true;
if(excludeFileExists == false) //return if excludefile does not exist
return false;
XmlReader rdr(*excludeFile);
std::string dirpath;
while(rdr.next())
{
if(rdr.tag() == "exclude") //get exclude paths
{
dirpath = rdr.body();
int found=path.find(dirpath); //check if current path is in the exclude list
if (found!=std::string::npos)
return true;
}
}
}catch(std::exception& ex){
std::cout << "\n\n " << ex.what() << "\n\n"; }
return false;
}
std::vector<grpprl> DocReader::GetCLXGrpprls()
{
std::vector<grpprl> vecResults;
WordFileReader rdr(m_sfr, GetTableStreamName(), GetStartComplexFilePart(), GetSizeComplexFilePart());
while (rdr.GetSize())
{
CplxPartHeader hdr;
WordFileReader rdr2 = rdr;
rdr.Read(&hdr, 5);
if (hdr.iType == 1) // a grpprl
{
rdr2 += 1;
vecResults.push_back(grpprl(rdr2));
rdr += hdr.iGrpplLen - 2;
}
else if (hdr.iType == 2) // piece table
{
rdr += hdr.iPctblLen;
}
else // we're in trouble - probably got the offsets wrong
{
_ASSERT(false);
}
}
return vecResults;
}
bool TGAImageDecoder::LoadRLE(DataStream* ds,ImageImpl* img) {
Byte* data = img->GetRawData()->GetDataPtr();
UInt32 pixels = img->GetWidth()*img->GetHeight();
const UInt32 bpp = img->GetBpp();
UInt32 c = 0;
BufferedReader rdr(ds,2048);
while (pixels && !rdr.Eof()) {
/// @todo warning endianless
rdr.Read(reinterpret_cast<Byte*> (&c),1);
if (c < 128) {
c++;
if (c>pixels) c = pixels;
data+=rdr.Read(data,c*bpp);
pixels -= c;
} else {
c-=127;
if (c>pixels) c = pixels;
Byte* data_c = data;
data+=rdr.Read(data,bpp);
for(UInt32 counter = 1; counter < c; counter++)
{
data=copy_data(data_c,data,bpp);
}
pixels-= c;
}
}
return pixels == 0;
}
int dmtcp::CkptSerializer::openMtcpCheckpointFile(const dmtcp::string& path){
int fd = openDmtcpCheckpointFile(path);
jalib::JBinarySerializeReaderRaw rdr(path, fd);
static ConnectionToFds cfd;
static ProcessInfo pInfo;
cfd.serialize(rdr);
pInfo.serialize(rdr);
return fd;
}
int main(int argc, char** argv){
CGE::LogOutputter* putty = new CGE::LogOutputter();
CGE::TraceManager::instance()->setTraceOutputter(putty);
if (argc <= 1){
return -1;
}
PdfReader rdr(argv[1]);
PdfDocument* doc = rdr.readDocument();
}
AnyValue JsonSerializer::deserialize(const std::string & str)
{
Json::Value root;
Json::CharReaderBuilder rbuilder;
rbuilder["collectComments"] = false;
std::unique_ptr<Json::CharReader> rdr(rbuilder.newCharReader());
if (!rdr->parse(str.data(), str.data() + str.size(), &root, nullptr))
throw std::runtime_error("Invalid json string");
return this->toAny(root);
}
rust_crate_cache::rust_sym::rust_sym(rust_dom *dom,
rust_crate const *curr_crate,
c_sym *crate_sym,
char const **path)
: val(0),
crate_sym(crate_sym),
dom(dom)
{
crate_sym->ref();
typedef rust_crate_reader::die die;
rust_crate const *crate = (rust_crate*)crate_sym->get_val();
if (!crate) {
dom->log(rust_log::CACHE,
"failed to resolve symbol, null crate symbol");
return;
}
rust_crate_reader rdr(dom, crate);
bool found_root = false;
bool found_leaf = false;
for (die d = rdr.dies.first_die();
!(found_root || d.is_null());
d = d.next_sibling()) {
die t1 = d;
die t2 = d;
for (char const **c = crate_rel(curr_crate, path);
(*c
&& !t1.is_null()
&& t1.find_child_by_name(crate_rel(curr_crate, *c), t2));
++c, t1=t2) {
dom->log(rust_log::DWARF|rust_log::CACHE,
"matched die <0x%" PRIxPTR
">, child '%s' = die<0x%" PRIxPTR ">",
t1.off, crate_rel(curr_crate, *c), t2.off);
found_root = found_root || true;
if (!*(c+1) && t2.find_num_attr(DW_AT_low_pc, val)) {
dom->log(rust_log::DWARF|rust_log::CACHE,
"found relative address: 0x%" PRIxPTR, val);
dom->log(rust_log::DWARF|rust_log::CACHE,
"plus image-base 0x%" PRIxPTR,
crate->get_image_base());
val += crate->get_image_base();
found_leaf = true;
break;
}
}
if (found_root || found_leaf)
break;
}
if (found_leaf) {
dom->log(rust_log::CACHE, "resolved symbol to 0x%" PRIxPTR, val);
} else {
dom->log(rust_log::CACHE, "failed to resolve symbol");
}
}
//////////////////////////////////////////////////////////////
///Loads database from xml file to a set
void FileSniffer::loadDatabase()
{
try{
databaseFile = loadFile(databaseFilePath);
XmlReader rdr(*databaseFile);
while(rdr.next()) //Scan through the xml and search for filepath tag
if(rdr.tag() == "filepath")
fileset.insert(rdr.body()); //insert filepaths into set
}catch(std::exception& ex){
std::cout << "\n\n " << ex.what() << "\n\n"; }
}
void MainWindow::diplayfile( const QString path ) const
{
Reader rdr( path );
ui->lbl_c_file->setText( fname );
ui->txt_c_file->clear();
for (int i = 0; i < rdr.getOutput().size(); i++ )
ui->txt_c_file->append( rdr.getOutput()[i] );
ui->btn_run->setEnabled( true );
ui->btn_edit_params->setEnabled( true );
}
int dmtcp::CkptSerializer::loadFromFile(const dmtcp::string& path,
dmtcp::ConnectionToFds *conToFds,
dmtcp::ProcessInfo *processInfo)
{
int fd = openDmtcpCheckpointFile(path);
JASSERT(fd != -1);
jalib::JBinarySerializeReaderRaw rdr(path, fd);
conToFds->serialize(rdr);
processInfo->serialize(rdr);
close_ckpt_to_read(fd);
return rdr.bytes() + strlen(DMTCP_FILE_HEADER);
}
bool TraceLineParser::SetFormat(const char * pszFormat, size_t cch, const std::vector<char>& separators)
{
cch = (cch == 0) ? strlen(pszFormat) : cch;
CStringReaderA rdr(pszFormat, cch);
_Separators.assign(separators.begin(), separators.end());
_Fields.resize(0);
if (!SetFormat(rdr, separators))
{
_Fields.resize(0);
return false;
}
return true;
}
void TraceLineParser::SetLineInfoField(LineInfo& res, FieldId id, const char * pszStart, const char * pszEnd)
{
switch(id)
{
case FieldId::Time:
res.Time.psz = pszStart;
res.Time.cch = pszEnd - pszStart;
break;
case FieldId::ThreadId:
{
CStringReaderA rdr(pszStart, pszEnd-pszStart);
int ibase = 10;
if (rdr.Length() > 2 && strncmp(rdr.P(), "0x", 2) == 0)
{
rdr.ReadChar();
rdr.ReadChar();
ibase = 16;
}
rdr.ReadUInt32(&res.Tid, ibase);
}
break;
case FieldId::User1:
res.User[0].psz = pszStart;
res.User[0].cch = pszEnd - pszStart;
break;
case FieldId::User2:
res.User[1].psz = pszStart;
res.User[1].cch = pszEnd - pszStart;
break;
case FieldId::User3:
res.User[2].psz = pszStart;
res.User[2].cch = pszEnd - pszStart;
break;
case FieldId::User4:
res.User[3].psz = pszStart;
res.User[3].cch = pszEnd - pszStart;
break;
case FieldId::Msg:
res.Msg.psz = pszStart;
res.Msg.cch = pszEnd - pszStart;
break;
case FieldId::None:
break;
default:
assert(false);
break;
}
}
int main()
{
std::cout << "\nTesting AuthXml Library";
std::cout << "\n=======================\n\n";
std::cout << " Creating a couple new users\n\n";
userList ulst;
user u1("user1","pass1",1);
user u2("user2","pass2",2);
user u3("admin","password",0);
ulst.addUser(u1);
ulst.addUser(u2);
ulst.addUser(u3);
std::cout << "Finding user1's access level, should be 1: " << ulst.getUserByUsername("user1").getAccesslevel() << "\n";
std::cout << "Finding user2's access level, should be 2: " << ulst.getUserByUsername("user2").getAccesslevel() << "\n";
AuthXml::writeXml("test.xml",ulst);
std::cout << "----------------------------------\n";
std::string line;
std::ifstream xmlFile ("test.xml");
std::string infile;
if (xmlFile.is_open())
{
while ( xmlFile.good() )
{
std::getline(xmlFile,line);
infile += line;
}
xmlFile.close();
}
std::cout << infile << std::endl;
XmlReader rdr(infile);
userList ulst2 = AuthXml::readXml(rdr);
std::cout << "\nPrinting user list\n";
std::cout << "----------------------------------\n";
ulst2.prettyPrintUserList();
return 0;
}
static inline
void
_os_debug_log_write(int level, char *str)
{
int fd = os_debug_log_globals()->logfd;
os_redirect_t rdr = os_debug_log_globals()->redirect;
// true = redirect has fully handled, don't log
if (os_slowpath(rdr) && os_fastpath(rdr(str))) {
return;
}
if (os_slowpath(fd >= 0)) {
if (os_fastpath(_os_debug_log_write_fd(level, str, fd))) {
return;
} else {
_os_debug_log_write_error();
os_debug_log_globals()->logfd = -1;
// Don't return, fall out to syslog().
}
}
_simple_asl_log(level, "com.apple.os_debug_log", str);
}
/////////////////////////////////////////////////////////////////////////////
// This function loads the modifier.bin data into the three tier list ///////
/////////////////////////////////////////////////////////////////////////////
void ModifierBin::Load_Modifier(char* buff, long len)
{
string st = buff; // Create retention string
stringstream rdr(st,ios::in); // Create string stream using rentention string
char buff2[255]; // Our data buffer
MOD_LIST list;
MOD_OBJ obj;
ModProperty prop;
// While ! END, get next line
for(; GetString(&rdr,buff2) && TestEnd(buff2); NULL)
{
if( !buff2[0] ) // Ignore null lines
continue;
// While ! END, get next line
for(strcpy(list.SectionTitle,buff2); GetString(&rdr,buff2) && TestEnd(buff2); NULL)
{
if( !buff2[0] )
continue;
for(strcpy(obj.ObjectName,buff2); GetString(&rdr,buff2) && TestEnd(buff2); NULL)
{
if( !buff2[0] )
continue;
prop.Load(buff2); // Load property into the object
obj.Properties.push_back(prop);
}
list.ElementList.push_back(obj); // Load object into the header list
obj.Properties.clear();
}
ModifierList.push_back(list); // Load header list into the master list
list.ElementList.clear();
}
}
extern "C" CDECL int
rust_start(uintptr_t main_fn, rust_crate const *crate, int argc, char **argv)
{
int ret;
{
rust_srv srv;
rust_dom dom(&srv, crate, "main");
command_line_args args(dom, argc, argv);
dom.log(rust_log::DOM, "startup: %d args", args.argc);
for (int i = 0; i < args.argc; ++i)
dom.log(rust_log::DOM,
"startup: arg[%d] = '%s'", i, args.argv[i]);
if (dom._log.is_tracing(rust_log::DWARF)) {
rust_crate_reader rdr(&dom, crate);
}
uintptr_t main_args[4] = { 0, 0, 0, (uintptr_t)args.args };
dom.root_task->start(crate->get_exit_task_glue(),
main_fn,
(uintptr_t)&main_args,
sizeof(main_args));
ret = dom.start_main_loop();
}
#if !defined(__WIN32__)
// Don't take down the process if the main thread exits without an
// error.
if (!ret)
pthread_exit(NULL);
#endif
return ret;
}
HRESULT GetRibbonText(BSTR * RibbonXml)
{
LPBYTE content = NULL;
DWORD content_length = 0;
ASSERT_RETURN_VALUE(LoadResourceFromModule(
AfxGetInstanceHandle(), MAKEINTRESOURCE(IDR_RESOURCE_H), L"TEXT", &content, &content_length), S_FALSE);
CMemFile mf(content, content_length);
CTextFileRead rdr(&mf);
CMapStringToString replacements;
CString line;
while (rdr.ReadLine(line))
{
CSimpleArray<CString> tokens;
CString token;
token.Preallocate(30);
for (LPCWSTR pos = line; *pos; ++pos)
{
if (*pos == ' ' || *pos == '\t')
{
if (!token.IsEmpty())
{
tokens.Add(token);
token = CString();
}
}
else
{
token += *pos;
}
}
if (!token.IsEmpty())
tokens.Add(token);
if (tokens.GetSize() != 3)
continue;
if (tokens[0] != "#define")
continue;
replacements[tokens[1]] = tokens[2];
}
CString ribbon = LoadTextFromModule(AfxGetInstanceHandle(), IDR_RIBBON);
for (int pos = 0; pos < ribbon.GetLength(); ++pos)
{
if (ribbon[pos] != '{')
continue;
int endpos = ribbon.Find('}', pos);
ASSERT_CONTINUE(endpos != -1);
CString token = ribbon.Mid(pos+1, endpos-pos-1);
CString token_found;
ASSERT_CONTINUE(replacements.Lookup(token, token_found));
ribbon.Delete(pos, endpos-pos+1);
ribbon.Insert(pos, token_found);
pos += (token_found.GetLength()-1);
}
*RibbonXml = ribbon.AllocSysString();
return S_OK;
}
int CDBAPI_CacheTest::Run(void)
{
cout << "Run CDBAPI_CacheTest test" << endl << endl;
try {
auto_ptr<ICache> blob_cache( MakeICache() );
if ( blob_cache.get() == NULL ) {
return 1;
}
int top = blob_cache->GetTimeStampPolicy();
blob_cache->SetTimeStampPolicy(top, 30);
blob_cache->Purge("", "", 30);
const char* szTest = "01234567890";
blob_cache->Store("key_1",
1,
"",
szTest,
strlen(szTest));
size_t blob_size = blob_cache->GetSize("key_1",
1,
"");
int s = strlen(szTest);
assert(blob_size == size_t(s));
char blob_buf[1024] = {0,};
blob_cache->Read("key_1",
1,
"",
blob_buf,
1024);
int cmp = strcmp(blob_buf, szTest);
assert(cmp == 0);
{
auto_ptr<IWriter> wrt(blob_cache->GetWriteStream("key_3", 1, "sk1"));
size_t bytes_written;
int s = strlen(szTest);
wrt->Write(szTest, s, &bytes_written);
wrt->Flush();
}
{
char str[1024] = {0,};
char* sp = str;
auto_ptr<IReader> rdr(blob_cache->GetReadStream("key_3", 1, "sk1"));
char buf[1024];
ERW_Result r;
size_t rd;
do {
r = rdr->Read(buf, 1, &rd);
if (r != eRW_Success)
break;
*sp++ = buf[0];
} while (rd > 0);
int c = strcmp(szTest, str);
assert(c == 0);
}
// dump huge BLOB
{
unsigned bsize = 10 * 1024 * 1024;
int* big_blob = new int[bsize];
for (unsigned i = 0; i < bsize; ++i) {
big_blob[i] = i;
}
{
auto_ptr<IWriter> wrt(blob_cache->GetWriteStream("key_big", 1, ""));
unsigned written = 0;
int* p = big_blob;
while (written < bsize) {
size_t bytes_written;
unsigned elements_to_write = 10;
unsigned chunk_size = elements_to_write * sizeof(int);
wrt->Write(p, chunk_size, &bytes_written);
p += elements_to_write;
written += elements_to_write;
assert(bytes_written == chunk_size);
} // while
wrt->Flush();
}
auto_ptr<IReader> rdr(blob_cache->GetReadStream("key_big", 1, ""));
ERW_Result r;
size_t rd;
unsigned int cnt = 0;
do {
int buf[1];
r = rdr->Read(buf, sizeof(int), &rd);
if (r != eRW_Success)
break;
if (cnt != (unsigned int)buf[0]) {
cerr << "BLOB comparison error element idx = " << cnt <<
" value=" << buf[0] << endl;
assert(cnt == (unsigned int)buf[0]);
}
cnt++;
} while (rd > 0);
}
blob_cache->Remove("key_big", 1, "");
} catch( CDB_Exception& dbe ) {
NcbiCerr << dbe.what() << " " << dbe.Message()
<< NcbiEndl;
return 1;
}
cout << endl;
cout << "TEST execution completed successfully!" << endl << endl;
return 0;
}
int main()
{
std::cout << "\n Testing XmlReader";
std::cout << "\n ===================\n";
std::string Prologue = "<?xml version=\"1.0\"?><!-- top level comment -->";
std::string test1 = Prologue;
test1 += "<parent att1='val1' att2='val2'><child1 /><child2>child2 body<child1 /></child2></parent>";
std::string test2 = Prologue;
test2 += "<Dir><path>/TestFile/Dir1</path><File><name>text1.txt</name><date>02/11/2012</date></File></Dir>";
XmlReader rdr(test1);
std::cout << "\n source = " << test1.c_str() << std::endl;
// testing helper function
std::cout << "\n Testing extractIdentifier";
std::cout << "\n ---------------------------";
std::string ident;
size_t position = 1;
do
{
ident = rdr.extractIdentifier(position);
std::cout << "\n " << ident.c_str();
} while(ident.size() > 0);
// testing typical use, step through each element extracting tags, attributes,
// bodies, and or entire element strings
std::cout << "\n testing next(), tag(), element(), body(), and attributes()";
std::cout << "\n -----------------------------------------------------------";
rdr.reset();
while(rdr.next())
{
std::cout << "\n tag: " << rdr.tag().c_str();
std::cout << "\n element: " << rdr.element().c_str();
std::cout << "\n body: " << rdr.body().c_str();
XmlReader::attribElems attribs = rdr.attributes();
for(size_t i=0; i<attribs.size(); ++i)
std::cout << "\n attributes: " << attribs[i].first.c_str() << ", " << attribs[i].second.c_str();
}
std::cout << "\n\n";
// testing typical use, step through each element extracting tags, attributes,
// bodies, and or entire element strings
rdr.xml() = test2;
std::cout << "\n source = " << rdr.xml().c_str() << std::endl;
std::cout << "\n testing next(), tag(), element(), body(), and attributes()";
std::cout << "\n -----------------------------------------------------------";
rdr.reset();
while(rdr.next())
{
std::cout << "\n tag: " << rdr.tag().c_str();
std::cout << "\n element: " << rdr.element().c_str();
std::cout << "\n body: " << rdr.body().c_str();
XmlReader::attribElems attribs = rdr.attributes();
for(size_t i=0; i<attribs.size(); ++i)
std::cout << "\n attributes: " << attribs[i].first.c_str() << ", " << attribs[i].second.c_str();
}
std::cout << "\n\n";
return 0;
}
/*
* program entry point
*/
int main( int argc, char** argv )
{
try
{
// execution options
::XmlUnion::Config::Settings config;
char* InputFileName1 = 0;
char* InputFileName2 = 0;
char* OutputFileName = 0;
// <editor-fold defaultstate="collapsed" desc="command line argument parsing">
// could be a bitmap file name or a configuration option
for ( int i = 1; i < argc; ++i )
{
::std::string arg( argv[i] );
// if '-c'...
if ( arg == "-c" )
{
// if there's a file name following...
if ( ++i < argc )
{
// try to parse the configuration file
try
{
::XmlUnion::Config::Reader rdr( argv[i] );
config = rdr.Parse();
}
catch ( ::std::runtime_error& e )
{
::std::cerr << e.what() << "\n";
return 2;
}
catch ( ... )
{
::std::cerr << "Error reading configuration file\n";
return 2;
}
continue;
}
}
// input file name first
if ( ! arg.empty() && ! InputFileName1 )
{
InputFileName1 = argv[i];
continue;
}
// output file name next
if ( ! arg.empty() && ! InputFileName2 )
{
InputFileName2 = argv[i];
continue;
}
// output file name next
if ( ! arg.empty() && ! OutputFileName )
{
OutputFileName = argv[i];
continue;
}
// something unrecognized
throw ::std::runtime_error( ::std::string( "Invalid command line parameter: " ) + arg );
}
if ( ! InputFileName1 || ! InputFileName2 )
throw ::std::runtime_error( "Invalid command line parameters: two different files must be specified" );
// </editor-fold>
// Reader for the first input document
::File::Reader rdr1;
rdr1.open( InputFileName1 );
// Reader for the second input document
::File::Reader rdr2;
rdr2.open( InputFileName2 );
::XmlUnion::App app( rdr1, rdr2 );
app.Process( config );
::File::Writer wrt;
if ( OutputFileName )
wrt.open( OutputFileName );
else
if ( config.OutputFile.empty() )
wrt.open( stdout );
else
wrt.open( config.OutputFile.c_str() );
app.OutputXmlDoc.Write( wrt );
}
catch ( ::std::runtime_error& ex )
{
::std::cerr << ex.what() << "\n";
return 2;
}
catch (...)
{
::std::cerr << "Unexpected error with no explanation thrown\n";
return 3;
}
// equal. return success
return 0;
}
void Serial::configDma(Dma::Stream *write, Dma::Stream *read)
{
Device::configDma(write, read);
if (Device::mDmaWrite != nullptr)
{
mDmaWrite->config(Dma::Stream::Direction::MemoryToPeripheral, false, true, Dma::Stream::DataSize::Byte, Dma::Stream::DataSize::Byte, Dma::Stream::BurstLength::Single, Dma::Stream::BurstLength::Single);
mDmaWrite->setAddress(Dma::Stream::End::Peripheral, reinterpret_cast<System::BaseAddress>(tdr()));
mDmaWrite->configFifo(Dma::Stream::FifoThreshold::ThreeQuater);
mBase->CR3.DMAT = 1;
}
else
{
mBase->CR3.DMAT = 0;
}
if (Device::mDmaRead != nullptr)
{
mDmaRead->config(Dma::Stream::Direction::PeripheralToMemory, false, true, Dma::Stream::DataSize::Byte, Dma::Stream::DataSize::Byte, Dma::Stream::BurstLength::Single, Dma::Stream::BurstLength::Single);
mDmaRead->setAddress(Dma::Stream::End::Peripheral, reinterpret_cast<System::BaseAddress>(rdr()));
mDmaRead->configFifo(Dma::Stream::FifoThreshold::Disable);
mBase->CR3.DMAR = 1;
}
else
{
mBase->CR3.DMAR = 0;
}
}
AnyValue BsonSerializer::deserialize(const std::string & str)
{
Bundle res;
std::vector<uint8_t> data(str.begin(), str.end());
BufferReader rdr(data);
if (rdr.getSize() < 4)
throw std::invalid_argument("Document must be at least 4 byte long");
rdr.readInt32();
while (true)
{
uint8_t field_type = rdr.readUInt8();
if (field_type == 0x00)
break;
std::string name = rdr.readCString();
if (field_type == 0x01)
{
res.set(name, rdr.readDouble());
}
else if (field_type == 0x02)
{
int32_t len = rdr.readInt32();
res.set(name, rdr.readString(len - 1));
rdr.readUInt8(); // skip trailing 0
}
else if (field_type == 0x03)
{
// Document
int32_t len = rdr.peekInt32();
const uint8_t* ptr = rdr.readBytes(len);
std::string document(ptr, ptr + len);
res.set(name, this->deserialize(document));
}
else if (field_type == 0x04)
{
// Array
int32_t len = rdr.peekInt32();
const uint8_t* ptr = rdr.readBytes(len);
std::string document(ptr, ptr + len);
std::vector<AnyValue> bdocres;
for (auto& elem : this->deserialize(document).as<Bundle>()) bdocres.push_back(elem.second);
res.set(name, bdocres);
}
else if (field_type == 0x05)
{
// Binary Data
int32_t len = rdr.readInt32();
rdr.readUInt8(); // Subtype
// TODO: What to do with subtype ?
auto ptr = rdr.readBytes(len);
res.set(name, std::vector<uint8_t>(ptr, ptr + len));
}
else if (field_type == 0x06)
{
// Deprecated
}
else if (field_type == 0x07)
{
// ObjectID
// We don't know what to do with it in standard implementations.
rdr.readBytes(12);
}
else if (field_type == 0x08)
{
// Boolean
res.set(name, (rdr.readUInt8() == 1));
}
else if (field_type == 0x09)
{
// UTC Date int64
res.set(name, rdr.readInt64());
}
else if (field_type == 0x0A)
{
res.set(name, nullptr);
}
else if (field_type == 0x0B)
{
rdr.readCString();
rdr.readCString();
}
else if (field_type == 0x0C)
{
// DB Pointer
// Deprecated
int32_t len = rdr.readInt32();
rdr.readBytes(len + 12);
}
else if (field_type == 0x0D)
{
// Javascript code
// Is this a good idea ?
Bundle js;
int32_t len = rdr.readInt32();
js.set("js", rdr.readString(len));
rdr.readUInt8(); // skip trailing 0
js.set("scope", Bundle());
res.set(name, js);
}
else if (field_type == 0x0E)
{
// Deprecated
int32_t len = rdr.readInt32();
rdr.readBytes(len);
}
else if (field_type == 0x0F)
{
// Javascript code with scope
// Is this a good idea ?
Bundle js;
rdr.readInt32(); // code length
int32_t jslen = rdr.readInt32();
js.set("js", rdr.readString(jslen));
rdr.readUInt8(); // skip trailing 0
int32_t doclen = rdr.peekInt32();
auto docptr = rdr.readBytes(doclen);
js.set("scope", this->deserialize(std::string(docptr, docptr + doclen)));
res.set(name, js);
}
else if (field_type == 0x10)
{
// INT32
res.set(name, rdr.readInt32());
}
else if (field_type == 0x11)
{
// Timestamp
res.set(name, rdr.readInt64());
}
else if (field_type == 0x12)
{
// Int64
res.set(name, rdr.readInt64());
}
else if (field_type == 0xFF)
{
// Min key
}
else if (field_type == 0x7F)
{
// Max key
}
}
return res;
}
MetadataFromBlr::MetadataFromBlr(unsigned aBlrLength, const unsigned char* aBlr, unsigned aLength)
{
if (aBlrLength == 0)
return;
BlrReader rdr(aBlr, aBlrLength);
const UCHAR byte = rdr.getByte();
if (byte != blr_version4 && byte != blr_version5)
{
(Arg::Gds(isc_dsql_error) <<
Arg::Gds(isc_sqlerr) << Arg::Num(-804) <<
Arg::Gds(isc_wroblrver2) << Arg::Num(blr_version4) << Arg::Num(blr_version5) << Arg::Num(byte)
).raise();
}
if (rdr.getByte() != blr_begin || rdr.getByte() != blr_message)
{
(Arg::Gds(isc_sqlerr) << Arg::Num(-804) <<
Arg::Gds(isc_dsql_sqlda_err)
#ifdef DEV_BUILD
<< Arg::Gds(isc_random) << "Missing blr_begin / blr_message"
#endif
).raise();
}
rdr.getByte(); // skip the message number
unsigned count = rdr.getWord();
fb_assert(!(count & 1));
count /= 2;
unsigned offset = 0;
items.grow(count);
for (unsigned index = 0; index < count; index++)
{
Item* item = &items[index];
item->scale = 0;
item->subType = 0;
switch (rdr.getByte())
{
case blr_text:
item->type = SQL_TEXT;
item->charSet = CS_dynamic;
item->length = rdr.getWord();
break;
case blr_varying:
item->type = SQL_VARYING;
item->charSet = CS_dynamic;
item->length = rdr.getWord();
break;
case blr_text2:
item->type = SQL_TEXT;
item->charSet = rdr.getWord();
item->length = rdr.getWord();
break;
case blr_varying2:
item->type = SQL_VARYING;
item->charSet = rdr.getWord();
item->length = rdr.getWord();
break;
case blr_short:
item->type = SQL_SHORT;
item->length = sizeof(SSHORT);
item->scale = rdr.getByte();
break;
case blr_long:
item->type = SQL_LONG;
item->length = sizeof(SLONG);
item->scale = rdr.getByte();
break;
case blr_int64:
item->type = SQL_INT64;
item->length = sizeof(SINT64);
item->scale = rdr.getByte();
break;
case blr_quad:
item->type = SQL_QUAD;
item->length = sizeof(SLONG) * 2;
item->scale = rdr.getByte();
break;
case blr_float:
item->type = SQL_FLOAT;
item->length = sizeof(float);
break;
case blr_double:
case blr_d_float:
item->type = SQL_DOUBLE;
item->length = sizeof(double);
break;
case blr_timestamp:
item->type = SQL_TIMESTAMP;
item->length = sizeof(SLONG) * 2;
break;
case blr_sql_date:
item->type = SQL_TYPE_DATE;
item->length = sizeof(SLONG);
break;
case blr_sql_time:
item->type = SQL_TYPE_TIME;
item->length = sizeof(SLONG);
break;
case blr_blob2:
item->type = SQL_BLOB;
item->length = sizeof(ISC_QUAD);
item->subType = rdr.getWord();
item->charSet = rdr.getWord();
break;
case blr_bool:
item->type = SQL_BOOLEAN;
item->length = sizeof(UCHAR);
break;
default:
(Arg::Gds(isc_sqlerr) << Arg::Num(-804) <<
Arg::Gds(isc_dsql_sqlda_err)
#ifdef DEV_BUILD
<< Arg::Gds(isc_random) << "Wrong BLR type"
#endif
).raise();
}
if (rdr.getByte() != blr_short || rdr.getByte() != 0)
{
(Arg::Gds(isc_sqlerr) << Arg::Num(-804) <<
Arg::Gds(isc_dsql_sqlda_err)
#ifdef DEV_BUILD
<< Arg::Gds(isc_random) << "Wrong BLR type for NULL indicator"
#endif
).raise();
}
item->finished = true;
}
makeOffsets();
if (rdr.getByte() != (UCHAR) blr_end || length != aLength)
{
(Arg::Gds(isc_sqlerr) << Arg::Num(-804) <<
Arg::Gds(isc_dsql_sqlda_err)
#ifdef DEV_BUILD
<< Arg::Gds(isc_random) << (length != aLength ? "Invalid message length" : "Missing blr_end")
#endif
).raise();
}
}
int CTestTransmission::Run(void)
{
LOG_POST("Test IReader/IWriter transmission");
const int test_buf_size = 1024;
unsigned char buf[test_buf_size * 10];
unsigned char buf2[test_buf_size * 10];
// ---------------------------------------
// write the test sequence
ERW_Result res;
size_t sz;
{{
CTestMemWriter wrt(buf, sizeof(buf));
s_SaveTestData(&wrt, test_buf_size/2);
sz = wrt.SizeWritten();
assert(sz == test_buf_size/2);
}}
// ---------------------------------------
// read the whole test sequence
{{
#if defined(NCBI_XCODE_BUILD) && defined(__OPTIMIZE__) && NCBI_COMPILER_VERSION == 421
// Our Xcode builds use gcc-4.2 -Os, which passes in a
// CTestMemWriter(!) object without this workaround. :-/
unique_ptr<CTestMemReader> rdr(new CTestMemReader(buf, sz));
s_ReadCheck1(rdr.get(), buf, buf2, sz * 2, sz);
#else
CTestMemReader rdr(buf, sz);
s_ReadCheck1(&rdr, buf, buf2, sz * 2, sz);
#endif
}}
// ---------------------------------------
// read the test sequence char by char
{{
CTestMemReader rdr(buf, sz);
for (size_t i = 0; i < sz * 2; ++i) {
buf2[i] = 0;
size_t read;
res = rdr.Read(buf2 + i, 1, &read);
if (res == eRW_Eof) {
assert(i == sz);
assert(read == 0);
break;
}
assert(read == 1);
assert(res == eRW_Success);
assert (buf2[i] == buf[i]);
}
}}
// ---------------------------------------
// read the test sequence by 7 char
{{
CTestMemReader rdr(buf, sz);
size_t read = 0;
for (size_t i = 0; i < sz * 2; i+=read) {
unsigned char buf3[10] = {0,};
res = rdr.Read(buf3, 7, &read);
if (res == eRW_Eof) {
assert(read == 0);
break;
}
assert(read <= 7);
assert(res == eRW_Success);
for (size_t j = 0; j < read; ++j) {
assert(buf3[j] == (unsigned char)(i + j));
}
}
}}
// Transmission test
memset(buf, 0, sizeof(buf));
memset(buf2, 0, sizeof(buf2));
{{
CTestMemWriter wrt(buf, sizeof(buf));
CTransmissionWriter twrt(&wrt);
char b = 35;
twrt.Write(&b, 1);
CTestMemReader rdr(buf, sz);
CTransmissionReader trdr(&rdr);
char c = 0;
trdr.Read(&c, 1);
assert(b==c);
}}
size_t tsize = 3;
size_t byte_size;
{{
CTestMemWriter wrt(buf, sizeof(buf));
CTransmissionWriter twrt(&wrt);
s_SaveTestData(&twrt, tsize);//test_buf_size/2);
byte_size = wrt.SizeWritten();
}}
// ---------------------------------------
// read the whole test sequence
{{
CTestMemReader rdr(buf, byte_size);
CTransmissionReader trdr(&rdr);
s_ReadCheck1(&trdr, buf, buf2, sz * 2, tsize);//test_buf_size/2);
}}
memset(buf, 0, sizeof(buf));
memset(buf2, 0, sizeof(buf2));
tsize = test_buf_size/2;
{{
CTestMemWriter wrt(buf, sizeof(buf));
CTransmissionWriter twrt(&wrt);
s_SaveTestData(&twrt, tsize);
byte_size = wrt.SizeWritten();
}}
// ---------------------------------------
// read the whole test sequence
{{
CTestMemReader rdr(buf, byte_size);
CTransmissionReader trdr(&rdr);
s_ReadCheck1(&trdr, buf, buf2, tsize * 2, tsize);
}}
// ---------------------------------------
// read the test sequence char by char
{{
CTestMemReader rdr(buf, byte_size);
CTransmissionReader trdr(&rdr);
size_t i;
for (i = 0; i < tsize * 2; ++i) {
buf2[i] = 0;
size_t read;
res = trdr.Read(buf2 + i, 1, &read);
if (res == eRW_Eof) {
assert(i == sz);
assert(read == 0);
break;
}
assert(read == 1);
assert(res == eRW_Success);
unsigned char ch = (unsigned char) i;
assert (buf2[i] == ch);
}
assert(i == tsize);
}}
// ---------------------------------------
// read the test sequence by 7 char
{{
CTestMemReader rdr(buf, byte_size);
CTransmissionReader trdr(&rdr);
size_t read = 0;
size_t total_read = 0;
for (size_t i = 0; i < tsize * 2; i+=read) {
unsigned char buf3[10] = {0,};
res = trdr.Read(buf3, 7, &read);
if (res == eRW_Eof) {
assert(read == 0);
break;
}
total_read += read;
assert(read <= 7);
assert(res == eRW_Success);
for (size_t j = 0; j < read; ++j) {
assert(buf3[j] == (unsigned char)(i + j));
}
}
assert(total_read = tsize);
}}
// ---------------------------
// test eof packet
{{
CTestMemWriter wrt(buf, sizeof(buf));
char b = 35;
{
CTransmissionWriter twrt(&wrt, eNoOwnership, CTransmissionWriter::eSendEofPacket);
twrt.Write(&b, 1);
}
CTestMemReader rdr(buf, sz);
CTransmissionReader trdr(&rdr);
char c = 0;
trdr.Read(&c, 1);
assert(b==c);
res = trdr.Read(&c,1);
assert(res==eRW_Eof);
}}
LOG_POST("OK");
return 0;
}
STDMETHODIMP CAdRotator::get_GetAdvertisement(BSTR bstrVirtualPath, BSTR * pVal)
{
SCODE rc = E_FAIL;
try
{
USES_CONVERSION;
CContext cxt;
rc = cxt.Init( CContext::get_Server );
if ( !FAILED(rc) )
{
CComBSTR bstrPhysicalPath;
// determine the physical path
if ( ( rc = cxt.Server()->MapPath( bstrVirtualPath, &bstrPhysicalPath ) ) == S_OK )
{
_TCHAR* szPath = OLE2T( bstrPhysicalPath );
CAdFilePtr pAdFile = AdFile( szPath );
if ( pAdFile.IsValid() )
{
// refresh the ad file (make sure it's up to date)
pAdFile->Refresh();
// block all writers
CReader rdr( *pAdFile );
// if the border hasn't been set, use the default from the ad file
short nBorder;
if ( m_nBorder < 0 )
{
nBorder = pAdFile->Border();
}
else
{
nBorder = m_nBorder;
}
CAdDescPtr pAd = pAdFile->RandomAd();
if ( pAd.IsValid() )
{
// write out the HTML line for this ad
StringOutStream ss;
if ( m_bClickable && ( pAd->m_strLink.size() > 1 ) )
{
// use the href format
ss << _T("<A HREF=\"") << pAdFile->Redirector()
<< _T("?url=") << pAd->m_strLink
<< _T("&image=") << pAd->m_strGif
<< _T("\" ") << m_strTargetFrame << _T(">");
}
// now fill in the rest
ss << _T("<IMG SRC=\"") << pAd->m_strGif
<< _T("\" ALT=\"") << pAd->m_strAlt
<< _T("\" WIDTH=") << pAdFile->Width()
<< _T(" HEIGHT=") << pAdFile->Height();
if ( pAdFile->HSpace() != CAdFile::defaultHSpace )
{
ss << _T(" HSPACE=") << pAdFile->HSpace();
}
if ( pAdFile->VSpace() != CAdFile::defaultVSpace )
{
ss << _T(" VSPACE=") << pAdFile->VSpace();
}
ss << _T(" BORDER=") << nBorder << _T(">");
if ( m_bClickable && ( pAd->m_strLink.size() > 1 ) )
{
// put the trailing tag on
ss << _T("</A>");
}
String str = ss.toString();
if ( pVal )
{
if ( *pVal )
{
::SysFreeString( *pVal );
}
*pVal = T2BSTR( str.c_str() );
THROW_IF_NULL( *pVal );
rc = S_OK;
}
else
{
rc = E_POINTER;
}
}
}
}
}
else
{
_ASSERT(0);
RaiseException( IDS_ERROR_NOSVR );
} // end if got server
}
catch ( alloc_err& )
{
rc = E_OUTOFMEMORY;
}
catch ( ... )
{
rc = E_FAIL;
}
return rc;
}