// Get header info from options and store in map for processing with
// metadata.
void LasWriter::fillForwardList()
{
static const StringList header = {
"dataformat_id", "major_version", "minor_version", "filesource_id",
"global_encoding", "project_id", "system_id", "software_id",
"creation_doy", "creation_year"
};
static const StringList scale = { "scale_x", "scale_y", "scale_z" };
static const StringList offset = { "offset_x", "offset_y", "offset_z" };
static StringList all;
all.insert(all.begin(), header.begin(), header.end());
all.insert(all.begin(), scale.begin(), scale.end());
all.insert(all.begin(), offset.begin(), offset.end());
// Build the forward list, replacing special keywords with the proper
// field names.
for (auto& name : m_forwardSpec)
{
if (name == "all")
{
m_forwards.insert(all.begin(), all.end());
m_forwardVlrs = true;
}
else if (name == "header")
m_forwards.insert(header.begin(), header.end());
else if (name == "scale")
m_forwards.insert(scale.begin(), scale.end());
else if (name == "offset")
m_forwards.insert(offset.begin(), offset.end());
else if (name == "format")
m_forwards.insert("dataformat_id");
else if (name == "vlr")
m_forwardVlrs = true;
else if (Utils::contains(all, name))
m_forwards.insert(name);
else
{
std::ostringstream oss;
oss << "Error in 'forward' option. Unknown field for "
"forwarding: '" << name << "'.";
throw pdal_error(oss.str());
}
}
}
void et::findSubfolders(const std::string& folder, bool recursive, StringList& list)
{
StringList folderList;
ET_STRING_TYPE normalizedFolder = ET_STRING_TO_PARAM_TYPE(addTrailingSlash(folder));
ET_STRING_TYPE foldersSearchPath = normalizedFolder + allFilesMask;
WIN32_FIND_DATA folders = { };
HANDLE folderSearch = FindFirstFile(foldersSearchPath.c_str(), &folders);
if (folderSearch != INVALID_HANDLE_VALUE)
{
do
{
ET_STRING_TYPE name(folders.cFileName);
bool isFolder = (folders.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY;
if (isFolder && (name != currentFolder) && (name != previousFolder))
{
folderList.push_back(ET_STRING_TO_OUTPUT_TYPE(normalizedFolder +
name + ET_STRING_FROM_CONST_CHAR("\\")));
}
}
while (FindNextFile(folderSearch, &folders));
FindClose(folderSearch);
}
if (recursive)
{
for (const std::string& i : folderList)
findSubfolders(i, true, list);
}
list.insert(list.end(), folderList.begin(), folderList.end());
}
void et::findSubfolders(const std::string& folder, bool recursive, StringList& list)
{
std::string normalizedFolder = addTrailingSlash(folder);
std::string foldersSearchPath = normalizedFolder + "*.*";
StringList folderList;
WIN32_FIND_DATA folders = { };
HANDLE folderSearch = FindFirstFile(foldersSearchPath.c_str(), &folders);
if (folderSearch != INVALID_HANDLE_VALUE)
{
do
{
if (strcmp(folders.cFileName, ".") && strcmp(folders.cFileName, "..") &&
((folders.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY))
{
std::string folderName(folders.cFileName);
folderList.push_back(normalizedFolder + folderName + "\\");
}
}
while (FindNextFile(folderSearch, &folders));
FindClose(folderSearch);
}
if (recursive)
{
for (const std::string& i : folderList)
findSubfolders(i, true, list);
}
list.insert(list.end(), folderList.begin(), folderList.end());
}
int main ()
{
// Create a list of critters.
StringList critters;
// Insert a few critters.
critters.insert (critters.begin (), "antelope");
critters.insert (critters.begin (), "bear");
critters.insert (critters.begin (), "cat");
// Print out the list.
std::cout << critters << '\n';
// Change cat to cougar.
*std::find (critters.begin (),critters.end (), "cat") = "cougar";
std::cout << critters << '\n';
// Put a zebra at the beginning, an ocelot ahead of antelope,
// and a rat at the end.
critters.push_front ("zebra");
critters.insert (std::find (critters.begin (), critters.end (),
"antelope"), "ocelot");
critters.push_back ("rat");
std::cout << critters << '\n';
// Sort the list (Use list's sort function since the
// generic algorithm requires a random access iterator
// and list only provides bidirectional)
critters.sort ();
std::cout << critters << '\n';
// Now let's erase half of the critters.
StringList::size_type half = critters.size () / 2;
for (StringList::size_type i = 0; i != half; ++i)
critters.erase (critters.begin ());
std::cout << critters << '\n';
return 0;
}
void
Slice::ObjCGenerator::MetaDataVisitor::setMetaData(const ContainedPtr& cont, const StringList& metadata)
{
StringList localMetaData = cont->getMetaData();
for(StringList::const_iterator p = localMetaData.begin(); p != localMetaData.end();)
{
string s = *p++;
if(s.find(_objcPrefix) == 0)
{
localMetaData.remove(s);
}
}
localMetaData.insert(localMetaData.end(), metadata.begin(), metadata.end());
cont->setMetaData(localMetaData);
}
StringList EntityDefinitionManager::builtinDefinitionFiles() {
StringList result;
IO::FileManager fileManager;
const String resourcePath = fileManager.resourceDirectory();
const String defPath = fileManager.appendPathComponent(resourcePath, "Defs");
const StringList defFiles = fileManager.directoryContents(defPath, "def");
const StringList fgdFiles = fileManager.directoryContents(defPath, "fgd");
result.insert(result.end(), defFiles.begin(), defFiles.end());
result.insert(result.end(), fgdFiles.begin(), fgdFiles.end());
std::sort(result.begin(), result.end());
return result;
}
int
main(int argc, char **argv)
{
StringList stringList;
StringList::iterator pos;
stringList.push_back(&a);
stringList.push_back(&b);
pos = stringList.begin();
stringList.insert(pos, &c);
for (pos = stringList.begin(); pos != stringList.end(); ++pos) {
cout << *pos << endl;
string *s = *pos;
cout << s->c_str() << (*pos)->c_str() << endl;
}
for (pos = stringList.begin(); pos != stringList.end(); ) {
cout << *pos << endl;
pos = stringList.erase(pos);
}
}
StringList ProgramFactory::loadProgramSources(const std::string& file, std::string& vertex_shader,
std::string& geom_shader, std::string& frag_shader, const StringList& defines)
{
StringList sources;
std::string filename = application().resolveFileName(file);
if (!fileExists(filename))
{
log::error("Unable to find file: %s", file.c_str());
return sources;
}
StringList resultDefines = defines;
std::string vertex_source;
std::string geometry_source;
std::string fragment_source;
std::string s;
InputStream progFile(filename, StreamMode_Binary);
while (!(progFile.stream().eof() || progFile.stream().fail()))
{
getline(progFile.stream(), s);
trim(s);
std::string id = s.substr(0, s.find(':'));
trim(id);
lowercase(id);
if (id == "vs")
vertex_source = s.substr(s.find_first_of(':') + 1);
if (id == "gs")
geometry_source = s.substr(s.find_first_of(':') + 1);
if (id == "fs")
fragment_source = s.substr(s.find_first_of(':') + 1);
if (id == "defines")
{
StringList aDefines = parseDefinesString(s.substr(s.find_first_of(':') + 1));
resultDefines.insert(resultDefines.end(), aDefines.begin(), aDefines.end());
}
}
normalizeFilePath(trim(vertex_source));
normalizeFilePath(trim(geometry_source));
normalizeFilePath(trim(fragment_source));
std::string programFolder = getFilePath(filename);
std::string fName = programFolder + vertex_source;
if (!fileExists(fName))
fName = application().resolveFileName(fName);
if (!fileExists(fName))
fName = application().resolveFileName(vertex_source);
if (fileExists(fName))
{
sources.push_back(fName);
vertex_shader = loadTextFile(fName);
ET_ASSERT((vertex_shader.size() > 1) && "Vertex shader source should not be empty");
}
if (!geometry_source.empty())
{
fName = programFolder + geometry_source;
if (!fileExists(fName))
fName = application().resolveFileName(fName);
if (!fileExists(fName))
fName = application().resolveFileName(geometry_source);
if (fileExists(fName))
{
geom_shader = loadTextFile(fName);
sources.push_back(fName);
}
}
fName = programFolder + fragment_source;
if (!fileExists(fName))
fName = application().resolveFileName(fName);
if (!fileExists(fName))
fName = application().resolveFileName(fragment_source);
if (fileExists(fName))
{
sources.push_back(fName);
frag_shader = loadTextFile(fName);
ET_ASSERT((frag_shader.size() > 1) && "Fragment shader source should not be empty");
}
return sources;
}
// Read a stream a line at a time, and parse it to fill out the print mask,
// header, group_by, where expression, and projection attributes.
//
int SetAttrListPrintMaskFromStream (
SimpleInputStream & stream, // in: fetch lines from this stream until nextline() returns NULL
const CustomFormatFnTable & FnTable, // in: table of custom output functions for SELECT
AttrListPrintMask & mask, // out: columns and headers set in SELECT
printmask_headerfooter_t & headfoot, // out: header and footer flags set in SELECT or SUMMARY
printmask_aggregation_t & aggregate, // out: aggregation mode in SELECT
std::vector<GroupByKeyInfo> & group_by, // out: ordered set of attributes/expressions in GROUP BY
std::string & where_expression, // out: classad expression from WHERE
StringList & attrs, // out ClassAd attributes referenced in mask or group_by outputs
std::string & error_message) // out, if return is non-zero, this will be an error message
{
ClassAd ad; // so we can GetExprReferences
enum section_t { NOWHERE=0, SELECT, SUMMARY, WHERE, GROUP};
enum cust_t { PRINTAS_STRING, PRINTAS_INT, PRINTAS_FLOAT };
bool label_fields = false;
const char * labelsep = " = ";
const char * prowpre = NULL;
const char * pcolpre = " ";
const char * pcolsux = NULL;
const char * prowsux = "\n";
mask.SetAutoSep(prowpre, pcolpre, pcolsux, prowsux);
error_message.clear();
aggregate = PR_NO_AGGREGATION;
printmask_headerfooter_t usingHeadFoot = (printmask_headerfooter_t)(HF_CUSTOM | HF_NOSUMMARY);
section_t sect = SELECT;
tokener toke("");
while (toke.set(stream.nextline())) {
if ( ! toke.next())
continue;
if (toke.matches("#")) continue;
if (toke.matches("SELECT")) {
while (toke.next()) {
if (toke.matches("FROM")) {
if (toke.next()) {
if (toke.matches("AUTOCLUSTER")) {
aggregate = PR_FROM_AUTOCLUSTER;
} else {
std::string aa; toke.copy_token(aa);
formatstr_cat(error_message, "Warning: Unknown header argument %s for SELECT FROM\n", aa.c_str());
}
}
} else if (toke.matches("UNIQUE")) {
aggregate = PR_COUNT_UNIQUE;
} else if (toke.matches("BARE")) {
usingHeadFoot = HF_BARE;
} else if (toke.matches("NOTITLE")) {
usingHeadFoot = (printmask_headerfooter_t)(usingHeadFoot | HF_NOTITLE);
} else if (toke.matches("NOHEADER")) {
usingHeadFoot = (printmask_headerfooter_t)(usingHeadFoot | HF_NOHEADER);
} else if (toke.matches("NOSUMMARY")) {
usingHeadFoot = (printmask_headerfooter_t)(usingHeadFoot | HF_NOSUMMARY);
} else if (toke.matches("LABEL")) {
label_fields = true;
} else if (label_fields && toke.matches("SEPARATOR")) {
if (toke.next()) { std::string tmp; toke.copy_token(tmp); collapse_escapes(tmp); labelsep = mask.store(tmp.c_str()); }
} else if (toke.matches("RECORDPREFIX")) {
if (toke.next()) { std::string tmp; toke.copy_token(tmp); collapse_escapes(tmp); prowpre = mask.store(tmp.c_str()); }
} else if (toke.matches("RECORDSUFFIX")) {
if (toke.next()) { std::string tmp; toke.copy_token(tmp); collapse_escapes(tmp); prowsux = mask.store(tmp.c_str()); }
} else if (toke.matches("FIELDPREFIX")) {
if (toke.next()) { std::string tmp; toke.copy_token(tmp); collapse_escapes(tmp); pcolpre = mask.store(tmp.c_str()); }
} else if (toke.matches("FIELDSUFFIX")) {
if (toke.next()) { std::string tmp; toke.copy_token(tmp); collapse_escapes(tmp); pcolsux = mask.store(tmp.c_str()); }
} else {
std::string aa; toke.copy_token(aa);
formatstr_cat(error_message, "Warning: Unknown header argument %s for SELECT\n", aa.c_str());
}
}
mask.SetAutoSep(prowpre, pcolpre, pcolsux, prowsux);
sect = SELECT;
continue;
} else if (toke.matches("WHERE")) {
sect = WHERE;
if ( ! toke.next()) continue;
} else if (toke.matches("GROUP")) {
sect = GROUP;
if ( ! toke.next() || (toke.matches("BY") && ! toke.next())) continue;
} else if (toke.matches("SUMMARY")) {
usingHeadFoot = (printmask_headerfooter_t)(usingHeadFoot & ~HF_NOSUMMARY);
while (toke.next()) {
if (toke.matches("STANDARD")) {
// attrs.insert(ATTR_JOB_STATUS);
} else if (toke.matches("NONE")) {
usingHeadFoot = (printmask_headerfooter_t)(usingHeadFoot | HF_NOSUMMARY);
} else {
std::string aa; toke.copy_token(aa);
formatstr_cat(error_message, "Unknown argument %s for SELECT\n", aa.c_str());
}
}
sect = SUMMARY;
continue;
}
switch (sect) {
case SELECT: {
toke.mark();
std::string attr;
std::string name;
int opts = FormatOptionAutoWidth | FormatOptionNoTruncate;
const char * fmt = "%v";
int wid = 0;
CustomFormatFn cust;
bool got_attr = false;
while (toke.next()) {
const Keyword * pkw = SelectKeywords.find_match(toke);
if ( ! pkw)
continue;
// next token is a keyword, if we havent set the attribute yet
// it's everything up to the current token.
int kw = pkw->value;
if ( ! got_attr) {
toke.copy_marked(attr);
got_attr = true;
}
switch (kw) {
case kw_AS: {
if (toke.next()) {
toke.copy_token(name);
if (toke.is_quoted_string()) { collapse_escapes(name); }
} else {
expected_token(error_message, "column name after AS", "SELECT", stream, toke);
}
toke.mark_after();
} break;
case kw_PRINTF: {
if (toke.next()) {
std::string val; toke.copy_token(val);
fmt = mask.store(val.c_str());
} else {
expected_token(error_message, "format after PRINTF", "SELECT", stream, toke);
}
} break;
case kw_PRINTAS: {
if (toke.next()) {
const CustomFormatFnTableItem * pcffi = FnTable.find_match(toke);
if (pcffi) {
cust = pcffi->cust;
//cust_type = pcffi->cust;
const char * pszz = pcffi->extra_attribs;
if (pszz) {
size_t cch = strlen(pszz);
while (cch > 0) { attrs.insert(pszz); pszz += cch+1; cch = strlen(pszz); }
}
} else {
std::string aa; toke.copy_token(aa);
formatstr_cat(error_message, "Unknown argument %s for PRINTAS\n", aa.c_str());
}
} else {
expected_token(error_message, "function name after PRINTAS", "SELECT", stream, toke);
}
} break;
case kw_NOSUFFIX: {
opts |= FormatOptionNoSuffix;
} break;
case kw_NOPREFIX: {
opts |= FormatOptionNoPrefix;
} break;
case kw_LEFT: {
opts |= FormatOptionLeftAlign;
} break;
case kw_RIGHT: {
opts &= ~FormatOptionLeftAlign;
} break;
case kw_TRUNCATE: {
opts &= ~FormatOptionNoTruncate;
} break;
case kw_WIDTH: {
if (toke.next()) {
std::string val; toke.copy_token(val);
if (toke.matches("AUTO")) {
opts |= FormatOptionAutoWidth;
} else {
wid = atoi(val.c_str());
//if (wid) opts &= ~FormatOptionAutoWidth;
//PRAGMA_REMIND("TJ: decide how LEFT & RIGHT interact with pos and neg widths."
}
} else {
expected_token(error_message, "number or AUTO after WIDTH", "SELECT", stream, toke);
}
} break;
default:
unexpected_token(error_message, "SELECT", stream, toke);
break;
} // switch
} // while
if ( ! got_attr) { attr = toke.content(); }
trim(attr);
if (attr.empty() || attr[0] == '#') continue;
const char * lbl = name.empty() ? attr.c_str() : name.c_str();
if (label_fields) {
// build a format string that contains the label
std::string label(lbl);
if (labelsep) { label += labelsep; }
if (fmt) { label += fmt; }
else {
label += "%";
if (wid) {
if (opts & FormatOptionNoTruncate)
formatstr_cat(label, "%d", wid);
else
formatstr_cat(label, "%d.%d", wid, wid < 0 ? -wid : wid);
}
label += cust ? "s" : "v";
}
lbl = mask.store(label.c_str());
fmt = lbl;
wid = 0;
} else {
if ( ! wid) { wid = 0 - (int)strlen(lbl); }
mask.set_heading(lbl);
lbl = NULL;
}
if (cust) {
mask.registerFormat (lbl, wid, opts, cust, attr.c_str());
} else {
mask.registerFormat(fmt, wid, opts, attr.c_str());
}
ad.GetExprReferences(attr.c_str(), NULL, &attrs);
}
break;
case WHERE: {
toke.copy_to_end(where_expression);
trim(where_expression);
}
break;
case SUMMARY: {
}
break;
case GROUP: {
toke.mark();
GroupByKeyInfo key;
// in case we end up finding no keywords, copy the remainder of the line now as the expression
toke.copy_to_end(key.expr);
bool got_expr = false;
while (toke.next()) {
const Keyword * pgw = GroupKeywords.find_match(toke);
if ( ! pgw)
continue;
// got a keyword
int gw = pgw->value;
if ( ! got_expr) {
toke.copy_marked(key.expr);
got_expr = true;
}
switch (gw) {
case gw_AS: {
if (toke.next()) { toke.copy_token(key.name); }
toke.mark_after();
} break;
case gw_DECENDING: {
key.decending = true;
toke.mark_after();
} break;
case gw_ASCENDING: {
key.decending = false;
toke.mark_after();
} break;
default:
unexpected_token(error_message, "GROUP BY", stream, toke);
break;
} // switch
} // while toke.next
trim(key.expr);
if (key.expr.empty() || key.expr[0] == '#')
continue;
if ( ! ad.GetExprReferences(key.expr.c_str(), NULL, &attrs)) {
formatstr_cat(error_message, "GROUP BY expression is not valid: %s\n", key.expr.c_str());
} else {
group_by.push_back(key);
}
}
break;
default:
break;
}
}
headfoot = usingHeadFoot;
return 0;
}
void CryptoManager::loadCertificates() throw() {
if(!BOOLSETTING(USE_TLS))
return;
SSL_CTX_set_verify(serverContext, SSL_VERIFY_NONE, 0);
SSL_CTX_set_verify(clientContext, SSL_VERIFY_NONE, 0);
SSL_CTX_set_verify(clientVerContext, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, 0);
SSL_CTX_set_verify(serverVerContext, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, 0);
const string& cert = SETTING(TLS_CERTIFICATE_FILE);
const string& key = SETTING(TLS_PRIVATE_KEY_FILE);
if(cert.empty() || key.empty()) {
LogManager::getInstance()->message(STRING(NO_CERTIFICATE_FILE_SET));
return;
}
if(File::getSize(cert) == -1 || File::getSize(key) == -1) {
// Try to generate them...
try {
generateCertificate();
} catch(const CryptoException& e) {
LogManager::getInstance()->message(STRING(CERTIFICATE_GENERATION_FAILED) + e.getError());
}
}
if(SSL_CTX_use_certificate_file(serverContext, SETTING(TLS_CERTIFICATE_FILE).c_str(), SSL_FILETYPE_PEM) != SSL_SUCCESS) {
LogManager::getInstance()->message(STRING(FAILED_TO_LOAD_CERTIFICATE));
return;
}
if(SSL_CTX_use_certificate_file(clientContext, SETTING(TLS_CERTIFICATE_FILE).c_str(), SSL_FILETYPE_PEM) != SSL_SUCCESS) {
LogManager::getInstance()->message(STRING(FAILED_TO_LOAD_CERTIFICATE));
return;
}
if(SSL_CTX_use_certificate_file(serverVerContext, SETTING(TLS_CERTIFICATE_FILE).c_str(), SSL_FILETYPE_PEM) != SSL_SUCCESS) {
LogManager::getInstance()->message(STRING(FAILED_TO_LOAD_CERTIFICATE));
return;
}
if(SSL_CTX_use_certificate_file(clientVerContext, SETTING(TLS_CERTIFICATE_FILE).c_str(), SSL_FILETYPE_PEM) != SSL_SUCCESS) {
LogManager::getInstance()->message(STRING(FAILED_TO_LOAD_CERTIFICATE));
return;
}
if(SSL_CTX_use_PrivateKey_file(serverContext, SETTING(TLS_PRIVATE_KEY_FILE).c_str(), SSL_FILETYPE_PEM) != SSL_SUCCESS) {
LogManager::getInstance()->message(STRING(FAILED_TO_LOAD_PRIVATE_KEY));
return;
}
if(SSL_CTX_use_PrivateKey_file(clientContext, SETTING(TLS_PRIVATE_KEY_FILE).c_str(), SSL_FILETYPE_PEM) != SSL_SUCCESS) {
LogManager::getInstance()->message(STRING(FAILED_TO_LOAD_PRIVATE_KEY));
return;
}
if(SSL_CTX_use_PrivateKey_file(serverVerContext, SETTING(TLS_PRIVATE_KEY_FILE).c_str(), SSL_FILETYPE_PEM) != SSL_SUCCESS) {
LogManager::getInstance()->message(STRING(FAILED_TO_LOAD_PRIVATE_KEY));
return;
}
if(SSL_CTX_use_PrivateKey_file(clientVerContext, SETTING(TLS_PRIVATE_KEY_FILE).c_str(), SSL_FILETYPE_PEM) != SSL_SUCCESS) {
LogManager::getInstance()->message(STRING(FAILED_TO_LOAD_PRIVATE_KEY));
return;
}
StringList certs = File::findFiles(SETTING(TLS_TRUSTED_CERTIFICATES_PATH), "*.pem");
StringList certs2 = File::findFiles(SETTING(TLS_TRUSTED_CERTIFICATES_PATH), "*.crt");
certs.insert(certs.end(), certs2.begin(), certs2.end());
for(StringIter i = certs.begin(); i != certs.end(); ++i) {
if(
SSL_CTX_load_verify_locations(clientContext, i->c_str(), NULL) != SSL_SUCCESS ||
SSL_CTX_load_verify_locations(clientVerContext, i->c_str(), NULL) != SSL_SUCCESS ||
SSL_CTX_load_verify_locations(serverContext, i->c_str(), NULL) != SSL_SUCCESS ||
SSL_CTX_load_verify_locations(serverVerContext, i->c_str(), NULL) != SSL_SUCCESS
) {
LogManager::getInstance()->message("Failed to load trusted certificate from " + *i);
}
}
certsLoaded = true;
}
