bool Condor_Auth_X509::CheckServerName(char const *fqh,char const *ip,ReliSock *sock,CondorError *errstack)
{
if( param_boolean("GSI_SKIP_HOST_CHECK",false) ) {
return true;
}
char const *server_dn = getAuthenticatedName();
if( !server_dn ) {
std::string msg;
formatstr(msg,"Failed to find certificate DN for server on GSI connection to %s",ip);
errstack->push("GSI", GSI_ERR_DNS_CHECK_ERROR, msg.c_str());
return false;
}
std::string skip_check_pattern;
if( param(skip_check_pattern,"GSI_SKIP_HOST_CHECK_CERT_REGEX") ) {
Regex re;
const char *errptr=NULL;
int erroffset=0;
std::string full_pattern;
formatstr(full_pattern,"^(%s)$",skip_check_pattern.c_str());
if( !re.compile(full_pattern.c_str(),&errptr,&erroffset) ) {
dprintf(D_ALWAYS,"GSI_SKIP_HOST_CHECK_CERT_REGEX is not a valid regular expression: %s\n",skip_check_pattern.c_str());
return false;
}
if( re.match(server_dn,NULL) ) {
return true;
}
}
ASSERT( errstack );
ASSERT( m_gss_server_name );
ASSERT( ip );
if( !fqh || !fqh[0] ) {
std::string msg;
formatstr(msg,"Failed to look up server host address for GSI connection to server with IP %s and DN %s. Is DNS correctly configured? This server name check can be bypassed by making GSI_SKIP_HOST_CHECK_CERT_REGEX match the DN, or by disabling all hostname checks by setting GSI_SKIP_HOST_CHECK=true or defining GSI_DAEMON_NAME.",ip,server_dn);
errstack->push("GSI", GSI_ERR_DNS_CHECK_ERROR, msg.c_str());
return false;
}
std::string connect_name;
gss_buffer_desc gss_connect_name_buf;
gss_name_t gss_connect_name;
OM_uint32 major_status = 0;
OM_uint32 minor_status = 0;
char const *connect_addr = sock->get_connect_addr();
std::string alias_buf;
if( connect_addr ) {
Sinful s(connect_addr);
char const *alias = s.getAlias();
if( alias ) {
dprintf(D_FULLDEBUG,"GSI host check: using host alias %s for %s %s\n",alias,fqh,sock->peer_ip_str());
alias_buf = alias;
fqh = alias_buf.c_str();
}
}
formatstr(connect_name,"%s/%s",fqh,sock->peer_ip_str());
gss_connect_name_buf.value = strdup(connect_name.c_str());
gss_connect_name_buf.length = connect_name.size()+1;
major_status = gss_import_name(&minor_status,
&gss_connect_name_buf,
GLOBUS_GSS_C_NT_HOST_IP,
&gss_connect_name);
free( gss_connect_name_buf.value );
if( major_status != GSS_S_COMPLETE ) {
std::string comment;
formatstr(comment,"Failed to create gss connection name data structure for %s.\n",connect_name.c_str());
print_log( major_status, minor_status, 0, comment.c_str() );
return false;
}
int name_equal = 0;
major_status = gss_compare_name( &minor_status,
m_gss_server_name,
gss_connect_name,
&name_equal );
gss_release_name( &major_status, &gss_connect_name );
if( !name_equal ) {
std::string msg;
formatstr(msg,"We are trying to connect to a daemon with certificate DN (%s), but the host name in the certificate does not match any DNS name associated with the host to which we are connecting (host name is '%s', IP is '%s', Condor connection address is '%s'). Check that DNS is correctly configured. If the certificate is for a DNS alias, configure HOST_ALIAS in the daemon's configuration. If you wish to use a daemon certificate that does not match the daemon's host name, make GSI_SKIP_HOST_CHECK_CERT_REGEX match the DN, or disable all host name checks by setting GSI_SKIP_HOST_CHECK=true or by defining GSI_DAEMON_NAME.\n",
server_dn,
fqh,
ip,
connect_addr ? connect_addr : sock->peer_description() );
errstack->push("GSI", GSI_ERR_DNS_CHECK_ERROR, msg.c_str());
}
return name_equal != 0;
}
void FormatHTMLChunk(TreeBuilder &treeBuilder,const char *buffer, size_t count)
{
RegexMatch match;
while (regexElementFinder.Match(buffer, count, match))
{
PrintMatches("link finder ", buffer, match);
FormatString(treeBuilder, buffer, match.End(1));
bool close = (match.Start(2) != match.End(2));
bool hasAttrs = (match.Start(4) != match.End(4));
string tagname(buffer + match.Start(3), match.Length(3));
size_t pos;
for (pos = 0; pos < tagname.length() && !isspace(tagname[pos]); ++pos)
{}
if (pos < tagname.length())
{
tagname.erase(pos, string::npos);
}
if (close)
{
treeBuilder.Pop(tagname);
}
else
{
ParseTreeNodePtr node(treeBuilder.NodeFactory(tagname));
treeBuilder.Push(node);
if (hasAttrs)
{
RegexMatch attrMatch;
const char *attrs = buffer + match.Start(4);
int attrLength = match.Length(4);
// printf("Attrs: %.*s\n", attrLength, attrs);
while (regexAttrMatch1.Match(attrs, attrLength, attrMatch)
|| regexAttrMatch2.Match(attrs, attrLength, attrMatch)
|| regexAttrMatch3.Match(attrs, attrLength, attrMatch))
{
PrintMatches("Attributes",attrs,attrMatch);
string attr(attrs + attrMatch.Start(1), attrMatch.Length(1));
treeBuilder.CurrentNode()->AddAttribute(attr.c_str());
// string val(attrs + attrMatch.Start(2), attrMatch.Length(2));
// treeBuilder.CurrentNode()->AddAttributeValue(val.c_str());
FormatAttribute(treeBuilder.CurrentNode(),
attrs + attrMatch.Start(2), attrMatch.Length(2));
attrs += attrMatch.End(3);
attrLength -= attrMatch.End(3);
}
if (match.Start(5) != match.End(5))
{
treeBuilder.Pop();
}
}
}
buffer += match.End(6);
count -= match.End(6);
}
FormatString(treeBuilder, buffer, count);
}
//parse apache access.log entry into components
bool ApacheCombinedLog::parseCommit(RCommit& commit) {
std::string line;
std::vector<std::string> matches;
if(!logf->getNextLine(line)) return false;
apache_entry_start.match(line, &matches);
if(matches.size()!=4) {
return 0;
}
//get details
commit.username = matches[0];
//std::string user = matches[1];
//parse timestamp
struct tm time_str;
std::string request_str = matches[3];
std::string datestr = matches[2];
apache_entry_date.match(datestr, &matches);
if(matches.size()!=8) {
return 0;
}
int day = atoi(matches[0].c_str());
int year = atoi(matches[2].c_str());
int hour = atoi(matches[3].c_str());
int minute = atoi(matches[4].c_str());
int second = atoi(matches[5].c_str());
// int zone = atoi(matches[7].c_str());
//negative timezone
// if(strcmp(matches[6].c_str(), "-")==0) {
// zone = -zone;
// }
int month=0;
for(int i=0;i<12;i++) {
if(matches[1] == months[i]) {
month=i;
break;
}
}
time_str.tm_year = year - 1900;
time_str.tm_mon = month;
time_str.tm_mday = day;
time_str.tm_hour = hour;
time_str.tm_min = minute;
time_str.tm_sec = second;
time_str.tm_isdst = -1;
commit.timestamp = mktime(&time_str);
matches.clear();
apache_entry_request.match(request_str, &matches);
if(matches.size() < 5) {
return false;
}
std::string rtype = matches[0];
std::string file = matches[1];
std::string proto = matches[2];
int code = atoi(matches[3].c_str());
int bytes = atol(matches[4].c_str());
//remove args from url
int argpos = file.rfind("?");
if(argpos != std::string::npos) {
file = file.substr(0,argpos);
}
if(file.size()==0) file = "/";
//name index pages
if(file[file.size()-1] == '/') {
file += "index.html";
}
std::string action = "A";
commit.addFile(file, action);
std::string refer;
std::string agent;
if(matches.size() > 5) {
std::string agentstr = matches[5];
matches.clear();
apache_entry_agent.match(agentstr, &matches);
if(matches.size()>1) {
refer = matches[0];
agent = matches[1];
}
}
return true;
}
void MachAttributes::init_machine_resources() {
// defines the space of local machine resources, and their quantity
m_machres_map.clear();
// this may be filled from resource inventory scripts
m_machres_attr.Clear();
// these are reserved for standard/fixed resources
std::set<string> fixedRes;
fixedRes.insert("cpu");
fixedRes.insert("cpus");
fixedRes.insert("disk");
fixedRes.insert("swap");
fixedRes.insert("mem");
fixedRes.insert("memory");
fixedRes.insert("ram");
// get the list of defined local resource names:
char* ptmp = param("MACHINE_RESOURCE_NAMES");
string resnames;
if (NULL != ptmp) {
// if admin defined MACHINE_RESOURCE_NAMES, then use this list
// as the source of expected custom machine resources
resnames = ptmp;
free(ptmp);
} else {
// otherwise, build the list of custom machine resources from
// all occurrences of MACHINE_RESOURCE_<resname>
std::set<string> resset;
Regex re;
int err = 0;
const char* pszMsg = 0;
const string prefix = "MACHINE_RESOURCE_";
const string invprefix = "INVENTORY_";
const string restr = prefix + "(.+)";
ASSERT(re.compile(restr.c_str(), &pszMsg, &err, PCRE_CASELESS));
std::vector<std::string> resdef;
const int n = param_names_matching(re, resdef);
for (int j = 0; j < n; ++j) {
string rname = resdef[j].substr(prefix.length());
string testinv = rname.substr(0, invprefix.length());
if (0 == strcasecmp(testinv.c_str(), invprefix.c_str())) {
// if something was defined via MACHINE_RESOURCE_INVENTORY_<rname>, strip "INVENTORY_"
rname = rname.substr(invprefix.length());
}
std::transform(rname.begin(), rname.end(), rname.begin(), ::tolower);
resset.insert(rname);
}
for (std::set<string>::iterator j(resset.begin()); j != resset.end(); ++j) {
resnames += " ";
resnames += *j;
}
}
// scan the list of local resources, to obtain their quantity and associated attributes (if any)
StringList reslist(resnames.c_str());
reslist.rewind();
while (const char* rnp = reslist.next()) {
string rname(rnp);
std::transform(rname.begin(), rname.end(), rname.begin(), ::tolower);
if (fixedRes.count(rname) > 0) {
EXCEPT("pre-defined resource name '%s' is reserved", rname.c_str());
}
// If MACHINE_RESOURCE_<rname> is present, use that and move on:
string pname;
formatstr(pname, "MACHINE_RESOURCE_%s", rname.c_str());
char* machresp = param(pname.c_str());
if (machresp) {
int v = param_integer(pname.c_str(), 0, 0, INT_MAX);
m_machres_map[rname] = v;
free(machresp);
continue;
}
// current definition of REMIND macro is not working with gcc
#pragma message("MACHINE_RESOURCE_INVENTORY_<rname> is deprecated, and will be removed when a solution using '|' in config files is fleshed out")
// if we didn't find MACHINE_RESOURCE_<rname>, then try MACHINE_RESOURCE_INVENTORY_<rname>
formatstr(pname, "MACHINE_RESOURCE_INVENTORY_%s", rname.c_str());
char* invscriptp = param(pname.c_str());
if (NULL == invscriptp) {
EXCEPT("Missing configuration for local machine resource %s", rname.c_str());
}
// if there is an inventory script, then attempt to execute it and use its output to
// identify the local resource quantity, and any associated attributes:
string invscript = invscriptp;
free(invscriptp);
ArgList invcmd;
StringList invcmdal(invscript.c_str());
invcmdal.rewind();
while (char* invarg = invcmdal.next()) {
invcmd.AppendArg(invarg);
}
FILE* fp = my_popen(invcmd, "r", FALSE);
if (NULL == fp) {
EXCEPT("Failed to execute local resource inventory script \"%s\"\n", invscript.c_str());
}
ClassAd invad;
char invline[1000];
while (fgets(invline, sizeof(invline), fp)) {
if (!invad.Insert(invline)) {
dprintf(D_ALWAYS, "Failed to insert \"%s\" into machine resource attributes: ignoring\n", invline);
}
}
my_pclose(fp);
// require the detected machine resource to be present as an attribute
string ccname(rname.c_str());
*(ccname.begin()) = toupper(*(ccname.begin()));
string detname;
formatstr(detname, "%s%s", ATTR_DETECTED_PREFIX, ccname.c_str());
int v = 0;
if (!invad.LookupInteger(detname.c_str(), v)) {
EXCEPT("Missing required attribute \"%s = <n>\" from output of %s\n", detname.c_str(), invscript.c_str());
}
// success
m_machres_map[rname] = v;
invad.Delete(rname.c_str());
m_machres_attr.Update(invad);
}
for (slotres_map_t::iterator j(m_machres_map.begin()); j != m_machres_map.end(); ++j) {
dprintf(D_ALWAYS, "Local machine resource %s = %d\n", j->first.c_str(), int(j->second));
}
}
//parse NCSA format access.log entry into components
bool NCSALog::parseLine(std::string& line, LogEntry& entry) {
std::vector<std::string> matches;
ls_ncsa_entry_start.match(line, &matches);
if(matches.size()!=5) {
return 0;
}
//get details
entry.vhost = matches[0];
entry.hostname = matches[1];
//entry.username = matches[1];
//parse timestamp
struct tm time_str;
int day, month, year, hour, minute, second;
std::string request_str = matches[4];
std::string datestr = matches[3];
matches.clear();
ls_ncsa_entry_date.match(datestr, &matches);
if(matches.size() != 6 && matches.size() != 8) {
return 0;
}
day = atoi(matches[0].c_str());
month = atoi(matches[1].c_str());
year = atoi(matches[2].c_str());
hour = atoi(matches[3].c_str());
minute = atoi(matches[4].c_str());
second = atoi(matches[5].c_str());
if(month) {
month--;
} else {
//parse non numeric month
for(int i=0;i<12;i++) {
if(strcmp(matches[1].c_str(), ls_ncsa_months[i])==0) {
month=i;
break;
}
}
}
//could not parse month (range 0-11 as used by mktime)
if(month<0 || month>11) return 0;
int tz_offset = 0;
//there is a timezone delta
if (matches.size() == 8) {
//convert zone to utc offset
int tz_hour = atoi(matches[7].substr(0,2).c_str());
int tz_min = atoi(matches[7].substr(2,2).c_str());
tz_offset = tz_hour * 3600 + tz_min * 60;
if(matches[6] == "-") {
tz_offset = -tz_offset;
}
}
time_str.tm_year = year - 1900;
time_str.tm_mon = month;
time_str.tm_mday = day;
time_str.tm_hour = hour;
time_str.tm_min = minute;
time_str.tm_sec = second;
time_str.tm_isdst = -1;
entry.timestamp = mktime(&time_str);
//apply utc offset
entry.timestamp -= tz_offset;
matches.clear();
ls_ncsa_entry_request.match(request_str, &matches);
if(matches.size() < 5) {
return 0;
}
// entry.method = matches[0];
entry.path = matches[1];
// entry.protocol = matches[2];
entry.response_code = matches[3].c_str();
entry.response_size = atol(matches[4].c_str());
if(matches.size() > 5) {
std::string agentstr = matches[5];
matches.clear();
ls_ncsa_entry_agent.match(agentstr, &matches);
if(matches.size()==3) {
entry.referrer = matches[0];
entry.user_agent = matches[1];
entry.pid = matches[2];
}
}
//successful if response code less than 400
int code = atoi(entry.response_code.c_str());
entry.setSuccess();
entry.setResponseColour();
return entry.validate();
}
bool PlayerOptions::FromOneModString( const RString &sOneMod, RString &sErrorOut )
{
ASSERT_M( NOTESKIN != NULL, "The Noteskin Manager must be loaded in order to process mods." );
RString sBit = sOneMod;
sBit.MakeLower();
Trim( sBit );
/* "drunk"
* "no drunk"
* "150% drunk"
* "*2 100% drunk": approach at 2x normal speed */
float level = 1;
float speed = 1;
vector<RString> asParts;
split( sBit, " ", asParts, true );
FOREACH_CONST( RString, asParts, s )
{
if( *s == "no" )
{
level = 0;
}
else if( isdigit((*s)[0]) || (*s)[0] == '-' )
{
/* If the last character is a *, they probably said "123*" when
* they meant "*123". */
if( s->Right(1) == "*" )
{
// XXX: We know what they want, is there any reason not to handle it?
// Yes. We should be strict in handling the format. -Chris
sErrorOut = ssprintf("Invalid player options \"%s\"; did you mean '*%d'?", s->c_str(), StringToInt(*s) );
return false;
}
else
{
level = StringToFloat( *s ) / 100.0f;
}
}
else if( *s[0]=='*' )
{
sscanf( *s, "*%f", &speed );
if( !isfinite(speed) )
speed = 1.0f;
}
}
sBit = asParts.back();
#define SET_FLOAT( opt ) { m_ ## opt = level; m_Speed ## opt = speed; }
const bool on = (level > 0.5f);
static Regex mult("^([0-9]+(\\.[0-9]+)?)x$");
vector<RString> matches;
if( mult.Compare(sBit, matches) )
{
StringConversion::FromString( matches[0], level );
SET_FLOAT( fScrollSpeed )
SET_FLOAT( fTimeSpacing )
m_fTimeSpacing = 0;
m_fMaxScrollBPM = 0;
}
else if( sscanf( sBit, "c%f", &level ) == 1 )
{
if( !isfinite(level) || level <= 0.0f )
level = CMOD_DEFAULT;
SET_FLOAT( fScrollBPM )
SET_FLOAT( fTimeSpacing )
m_fTimeSpacing = 1;
m_fMaxScrollBPM = 0;
}
// oITG's m-mods
else if( sscanf( sBit, "m%f", &level ) == 1 )
{
// OpenITG doesn't have this block:
/*
if( !isfinite(level) || level <= 0.0f )
level = CMOD_DEFAULT;
*/
SET_FLOAT( fMaxScrollBPM )
m_fTimeSpacing = 0;
}
else if( sBit == "clearall" )
{
Init();
m_sNoteSkin= NOTESKIN->GetDefaultNoteSkinName();
}
else if( sBit == "resetspeed" )
{
/* level is set to the values from Init() because all speed related
fields are being reset to initial values, and they each have different
initial values. -kyz */
level= 0;
SET_FLOAT(fMaxScrollBPM);
SET_FLOAT(fTimeSpacing);
level= 1.0f;
SET_FLOAT(fScrollSpeed);
level= CMOD_DEFAULT;
SET_FLOAT(fScrollBPM)
}
int main(int argc, char** argv) {
time_t currentTime = time(0);
fprintf(stderr, "Analysis started at: %s", ctime(¤tTime));
PARSE_PARAMETER(argc, argv);
PARAMETER_STATUS();
if (FLAG_REMAIN_ARG.size() > 0) {
fprintf(stderr, "Unparsed arguments: ");
for (unsigned int i = 0; i < FLAG_REMAIN_ARG.size(); i++) {
fprintf(stderr, " %s", FLAG_REMAIN_ARG[i].c_str());
}
fprintf(stderr, "\n");
abort();
}
REQUIRE_STRING_PARAMETER(FLAG_inVcf,
"Please provide input file using: --inVcf");
const char* fn = FLAG_inVcf.c_str();
VCFInputFile vin(fn);
// set range filters here
// e.g.
// vin.setRangeList("1:69500-69600");
vin.setRangeList(FLAG_rangeList.c_str());
vin.setRangeFile(FLAG_rangeFile.c_str());
// set people filters here
if (FLAG_peopleIncludeID.size() || FLAG_peopleIncludeFile.size()) {
vin.excludeAllPeople();
vin.includePeople(FLAG_peopleIncludeID.c_str());
vin.includePeopleFromFile(FLAG_peopleIncludeFile.c_str());
}
vin.excludePeople(FLAG_peopleExcludeID.c_str());
vin.excludePeopleFromFile(FLAG_peopleExcludeFile.c_str());
// let's write it out.
if (FLAG_updateId != "") {
int ret = vin.updateId(FLAG_updateId.c_str());
fprintf(stdout, "%d samples have updated id.\n", ret);
}
// load gene ranges
std::map<std::string, std::string> geneRange;
if (FLAG_geneName.size()) {
if (FLAG_geneFile.size() == 0) {
fprintf(stderr, "Have to provide --geneFile to extract by gene.\n");
abort();
}
LineReader lr(FLAG_geneFile);
std::vector<std::string> fd;
while (lr.readLineBySep(&fd, "\t ")) {
if (FLAG_geneName != fd[0]) continue;
fd[2] = chopChr(fd[2]); // chop "chr1" to "1"
if (geneRange.find(fd[0]) == geneRange.end()) {
geneRange[fd[0]] = fd[2] + ":" + fd[4] + "-" + fd[5];
} else {
geneRange[fd[0]] += "," + fd[2] + ":" + fd[4] + "-" + fd[5];
}
};
}
std::string range;
for (std::map<std::string, std::string>::iterator it = geneRange.begin();
it != geneRange.end(); it++) {
if (range.size() > 0) {
range += ",";
}
range += it->second;
};
fprintf(stderr, "range = %s\n", range.c_str());
vin.setRangeList(range.c_str());
Regex regex;
if (FLAG_annoType.size()) {
regex.readPattern(FLAG_annoType);
}
// print header
std::vector<std::string> names;
vin.getVCFHeader()->getPeopleName(&names);
printf("CHROM\tPOS");
for (unsigned int i = 0; i < names.size(); i++) {
printf("\t%s", names[i].c_str());
}
printf("\n");
// real working part
int nonVariantSite = 0;
while (vin.readRecord()) {
VCFRecord& r = vin.getVCFRecord();
VCFPeople& people = r.getPeople();
VCFIndividual* indv;
if (FLAG_variantOnly) {
bool hasVariant = false;
int geno;
int GTidx = r.getFormatIndex("GT");
for (size_t i = 0; i < people.size(); i++) {
indv = people[i];
geno = indv->justGet(GTidx).getGenotype();
if (geno != 0 && geno != MISSING_GENOTYPE) hasVariant = true;
}
if (!hasVariant) {
nonVariantSite++;
continue;
}
}
if (FLAG_annoType.size()) {
bool isMissing = false;
const char* tag = r.getInfoTag("ANNO", &isMissing).toStr();
if (isMissing) continue;
// fprintf(stdout, "ANNO = %s", tag);
bool match = regex.match(tag);
// fprintf(stdout, " %s \t", match ? "match": "noMatch");
// fprintf(stdout, " %s \n", exists ? "exists": "missing");
if (!match) {
continue;
}
}
fprintf(stdout, "%s\t%s", r.getChrom(), r.getPosStr());
for (size_t i = 0; i < people.size(); i++) {
indv = people[i];
fprintf(stdout, "\t%d", indv->justGet(0).getGenotype());
}
fprintf(stdout, "\n");
};
currentTime = time(0);
fprintf(stderr, "Analysis ends at: %s", ctime(¤tTime));
return 0;
};
void Font::LoadFontPageSettings( FontPageSettings &cfg, IniFile &ini, const CString &sTexturePath, const CString &sPageName, CString sChars )
{
cfg.m_sTexturePath = sTexturePath;
/* If we have any characters to map, add them. */
for( unsigned n=0; n<sChars.size(); n++ )
{
char c = sChars[n];
cfg.CharToGlyphNo[c] = n;
}
int iNumFramesWide, iNumFramesHigh;
RageTexture::GetFrameDimensionsFromFileName( sTexturePath, &iNumFramesWide, &iNumFramesHigh );
int iNumFrames = iNumFramesWide * iNumFramesHigh;
ini.RenameKey("Char Widths", "main");
// LOG->Trace("Loading font page '%s' settings from page name '%s'",
// TexturePath.c_str(), sPageName.c_str());
ini.GetValue( sPageName, "DrawExtraPixelsLeft", cfg.m_iDrawExtraPixelsLeft );
ini.GetValue( sPageName, "DrawExtraPixelsRight", cfg.m_iDrawExtraPixelsRight );
ini.GetValue( sPageName, "AddToAllWidths", cfg.m_iAddToAllWidths );
ini.GetValue( sPageName, "ScaleAllWidthsBy", cfg.m_fScaleAllWidthsBy );
ini.GetValue( sPageName, "LineSpacing", cfg.m_iLineSpacing );
ini.GetValue( sPageName, "Top", cfg.m_iTop );
ini.GetValue( sPageName, "Baseline", cfg.m_iBaseline );
ini.GetValue( sPageName, "DefaultWidth", cfg.m_iDefaultWidth );
ini.GetValue( sPageName, "AdvanceExtraPixels", cfg.m_iAdvanceExtraPixels );
ini.GetValue( sPageName, "TextureHints", cfg.m_sTextureHints );
/* Iterate over all keys. */
const XNode* pNode = ini.GetChild( sPageName );
if( pNode )
{
FOREACH_CONST_Attr( pNode, pAttr )
{
CString sName = pAttr->m_sName;
const CString &sValue = pAttr->m_sValue;
sName.MakeUpper();
/* If val is an integer, it's a width, eg. "10=27". */
if( IsAnInt(sName) )
{
cfg.m_mapGlyphWidths[atoi(sName)] = atoi( sValue );
continue;
}
/* "map codepoint=frame" maps a char to a frame. */
if( sName.substr(0, 4) == "MAP " )
{
/*
* map CODEPOINT=frame. CODEPOINT can be
* 1. U+hexval
* 2. an alias ("oq")
* 3. a game type followed by a game alias, eg "pump menuleft"
* 4. a character in quotes ("X")
*
* map 1=2 is the same as
* range unicode #1-1=2
*/
CString sCodepoint = sName.substr(4); /* "CODEPOINT" */
const Game* pGame = NULL;
if( sCodepoint.find_first_of(' ') != sCodepoint.npos )
{
/* There's a space; the first word should be a game type. Split it. */
unsigned pos = sCodepoint.find_first_of( ' ' );
CString gamename = sCodepoint.substr( 0, pos );
sCodepoint = sCodepoint.substr( pos+1 );
pGame = GameManager::StringToGameType(gamename);
if( pGame == NULL )
{
LOG->Warn( "Font definition '%s' uses unknown game type '%s'",
ini.GetPath().c_str(), gamename.c_str() );
continue;
}
}
wchar_t c;
if( sCodepoint.substr(0, 2) == "U+" && IsHexVal(sCodepoint.substr(2)) )
sscanf( sCodepoint.substr(2).c_str(), "%x", &c );
else if( sCodepoint.size() > 0 &&
utf8_get_char_len(sCodepoint[0]) == int(sCodepoint.size()) )
{
c = utf8_get_char( sCodepoint.c_str() );
if(c == wchar_t(-1))
LOG->Warn("Font definition '%s' has an invalid value '%s'.",
ini.GetPath().c_str(), sName.c_str() );
}
else if( !FontCharAliases::GetChar(sCodepoint, c) )
{
LOG->Warn("Font definition '%s' has an invalid value '%s'.",
ini.GetPath().c_str(), sName.c_str() );
continue;
}
cfg.CharToGlyphNo[c] = atoi( sValue );
continue;
}
if( sName.substr(0, 6) == "RANGE " )
{
/*
* range CODESET=first_frame or
* range CODESET #start-end=first_frame
* eg
* range CP1252=0 (default for 256-frame fonts)
* range ASCII=0 (default for 128-frame fonts)
*
* (Start and end are in hex.)
*
* Map two high-bit portions of ISO-8859- to one font:
* range ISO-8859-2 #80-FF=0
* range ISO-8859-3 #80-FF=128
*
* Map hiragana to 0-84:
* range Unicode #3041-3094=0
*/
vector<CString> asMatches;
static Regex parse("^RANGE ([A-Z\\-]+)( ?#([0-9A-F]+)-([0-9A-F]+))?$");
bool bMatch = parse.Compare( sName, asMatches );
ASSERT( asMatches.size() == 4 ); /* 4 parens */
if( !bMatch || asMatches[0].empty() )
RageException::Throw("Font definition '%s' has an invalid range '%s': parse error",
ini.GetPath().c_str(), sName.c_str() );
/* We must have either 1 match (just the codeset) or 4 (the whole thing). */
int iCount = -1;
int iFirst = 0;
if( !asMatches[2].empty() )
{
sscanf( asMatches[2].c_str(), "%x", &iFirst );
int iLast;
sscanf( asMatches[3].c_str(), "%x", &iLast );
if( iLast < iFirst )
RageException::Throw("Font definition '%s' has an invalid range '%s': %i < %i.",
ini.GetPath().c_str(), sName.c_str(), iLast < iFirst );
iCount = iLast - iFirst + 1;
}
CString sRet = cfg.MapRange( asMatches[0], iFirst, atoi(sValue), iCount );
if( !sRet.empty() )
RageException::Throw( "Font definition '%s' has an invalid range '%s': %s.",
ini.GetPath().c_str(), sName.c_str(), sRet.c_str() );
continue;
}
if( sName.substr(0, 5) == "LINE " )
{
/* line ROW=CHAR1CHAR2CHAR3CHAR4
* eg.
* line 0=ABCDEFGH
*
* This lets us assign characters very compactly and readably. */
CString sRowStr = sName.substr(5);
ASSERT( IsAnInt(sRowStr) );
const int iRow = atoi( sRowStr.c_str() );
const int iFirstFrame = iRow * iNumFramesWide;
if( iRow > iNumFramesHigh )
RageException::Throw( "The font definition \"%s\" tries to assign line %i, but the font is only %i characters high",
ini.GetPath().c_str(), iFirstFrame, iNumFramesHigh );
/* Decode the string. */
const wstring wdata( CStringToWstring(sValue) );
if( int(wdata.size()) > iNumFramesWide )
RageException::Throw( "The font definition \"%s\" assigns %i characters to row %i (\"%ls\"), but the font only has %i characters wide",
ini.GetPath().c_str(), wdata.size(), iRow, wdata.c_str(), iNumFramesWide );
for( unsigned i = 0; i < wdata.size(); ++i )
cfg.CharToGlyphNo[wdata[i]] = iFirstFrame+i;
}
}
}
bool SVNCommitLog::parseCommit(RCommit& commit) {
//fprintf(stderr,"parsing svn log\n");
std::string line;
if(!getNextLine(line)) return false;
//start of log entry
if(!svn_logentry_start.match(line)) {
//is this the start of the document
if(!svn_xml_tag.match(line)) return false;
//fprintf(stderr,"found xml tag\n");
//if so find the first logentry tag
bool found_logentry = false;
while(getNextLine(line)) {
if(svn_logentry_start.match(line)) {
found_logentry = true;
break;
}
}
if(!found_logentry) return false;
}
//fprintf(stderr,"found logentry\n");
logentry.clear();
logentry.append(line);
logentry.append("\n");
//fprintf(stderr,"found opening tag\n");
bool endfound = false;
while(getNextLine(line)) {
logentry.append(line);
logentry.append("\n");
if(svn_logentry_end.match(line)) {
//fprintf(stderr,"found closing tag\n");
endfound=true;
break;
}
}
//incomplete commit
if(!endfound) return false;
//fprintf(stderr,"read logentry\n");
TiXmlDocument doc;
if(!doc.Parse(logentry.c_str())) return false;
//fprintf(stderr,"try to parse logentry: %s\n", logentry.c_str());
TiXmlElement* leE = doc.FirstChildElement( "logentry" );
std::vector<std::string> entries;
if(!leE) return false;
//parse date
TiXmlElement* dateE = leE->FirstChildElement( "date" );
if(!dateE) return false;
std::string timestamp_str(dateE->GetText());
if(!svn_logentry_timestamp.match(timestamp_str, &entries))
return false;
struct tm time_str;
time_str.tm_year = atoi(entries[0].c_str()) - 1900;
time_str.tm_mon = atoi(entries[1].c_str()) - 1;
time_str.tm_mday = atoi(entries[2].c_str());
time_str.tm_hour = atoi(entries[3].c_str());
time_str.tm_min = atoi(entries[4].c_str());
time_str.tm_sec = atoi(entries[5].c_str());
time_str.tm_isdst = -1;
commit.timestamp = timegm(&time_str);
//parse author
TiXmlElement* authorE = leE->FirstChildElement("author");
if(authorE != 0) {
std::string author(authorE->GetText());
if(author.empty()) author = "Unknown";
commit.username = author;
}
TiXmlElement* pathsE = leE->FirstChildElement( "paths" );
//log entries sometimes dont have any paths
if(!pathsE) return true;
//parse changes
for(TiXmlElement* pathE = pathsE->FirstChildElement("path"); pathE != 0; pathE = pathE->NextSiblingElement()) {
//parse path
const char* kind = pathE->Attribute("kind");
const char* action = pathE->Attribute("action");
//check for action
if(action == 0) continue;
bool is_dir = false;
//if has the 'kind' attribute (old versions of svn dont have this), check if it is a dir
if(kind != 0 && strcmp(kind,"dir") == 0) {
//accept only deletes for directories
if(strcmp(action, "D") != 0) continue;
is_dir = true;
}
std::string file(pathE->GetText());
std::string status(action);
if(file.empty()) continue;
if(status.empty()) continue;
//append trailing slash if is directory
if(is_dir && file[file.size()-1] != '/') {
file = file + std::string("/");
}
commit.addFile(file, status);
}
//fprintf(stderr,"parsed logentry\n");
//read files
return true;
}
void Perl_stack::push(const Regex& regex) {
XPUSHs(sv_2mortal(SvREFCNT_inc(regex.get_SV())));
}
SandboxVector SandboxUtils::findSandboxes(Module& M) {
FunctionIntMap funcToOverhead;
FunctionIntMap funcToClearances;
map<Function*,string> funcToSandboxName;
map<string,FunctionSet> sandboxNameToEntryPoints;
StringSet ephemeralSandboxes;
SandboxVector sandboxes;
// function-level annotations of sandboxed code
Regex *sboxPerfRegex = new Regex("perf_overhead_\\(([0-9]{1,2})\\)", true);
SmallVector<StringRef, 4> matches;
if (GlobalVariable* lga = M.getNamedGlobal("llvm.global.annotations")) {
ConstantArray* lgaArray = dyn_cast<ConstantArray>(lga->getInitializer()->stripPointerCasts());
for (User::op_iterator i=lgaArray->op_begin(), e = lgaArray->op_end(); e!=i; i++) {
ConstantStruct* lgaArrayElement = dyn_cast<ConstantStruct>(i->get());
// get the annotation value first
GlobalVariable* annotationStrVar = dyn_cast<GlobalVariable>(lgaArrayElement->getOperand(1)->stripPointerCasts());
ConstantDataArray* annotationStrArray = dyn_cast<ConstantDataArray>(annotationStrVar->getInitializer());
StringRef annotationStrArrayCString = annotationStrArray->getAsCString();
GlobalValue* annotatedVal = dyn_cast<GlobalValue>(lgaArrayElement->getOperand(0)->stripPointerCasts());
if (isa<Function>(annotatedVal)) {
Function* annotatedFunc = dyn_cast<Function>(annotatedVal);
StringRef sandboxName;
if (annotationStrArrayCString.startswith(SANDBOX_PERSISTENT) || annotationStrArrayCString.startswith(SANDBOX_EPHEMERAL)) {
sandboxEntryPoints.insert(annotatedFunc);
outs() << INDENT_1 << "Found sandbox entrypoint " << annotatedFunc->getName() << "\n";
outs() << INDENT_2 << "Annotation string: " << annotationStrArrayCString << "\n";
if (annotationStrArrayCString.startswith(SANDBOX_PERSISTENT)) {
sandboxName = annotationStrArrayCString.substr(strlen(SANDBOX_PERSISTENT)+1);
}
else if (annotationStrArrayCString.startswith(SANDBOX_EPHEMERAL)) {
sandboxName = annotationStrArrayCString.substr(strlen(SANDBOX_EPHEMERAL)+1);
ephemeralSandboxes.insert(sandboxName);
}
outs() << INDENT_2 << "Sandbox name: " << sandboxName << "\n";
if (funcToSandboxName.find(annotatedFunc) != funcToSandboxName.end()) {
outs() << INDENT_1 << "*** Error: Function " << annotatedFunc->getName() << " is already an entrypoint for another sandbox\n";
}
else {
funcToSandboxName[annotatedFunc] = sandboxName;
sandboxNameToEntryPoints[sandboxName].insert(annotatedFunc);
}
}
else if (sboxPerfRegex->match(annotationStrArrayCString, &matches)) {
int overhead;
outs() << INDENT_2 << "Threshold set to " << matches[1].str() <<
"%\n";
matches[1].getAsInteger(0, overhead);
funcToOverhead[annotatedFunc] = overhead;
}
else if (annotationStrArrayCString.startswith(CLEARANCE)) {
StringRef className = annotationStrArrayCString.substr(strlen(CLEARANCE)+1);
outs() << INDENT_2 << "Sandbox has clearance for \"" << className << "\"\n";
ClassifiedUtils::assignBitIdxToClassName(className);
funcToClearances[annotatedFunc] |= (1 << ClassifiedUtils::getBitIdxFromClassName(className));
}
}
}
}
// TODO: sanity check overhead and clearance annotations
// Combine all annotation information for function-level sandboxes to create Sandbox instances
for (pair<string,FunctionSet> p : sandboxNameToEntryPoints) {
string sandboxName = p.first;
FunctionSet entryPoints = p.second;
int idx = assignBitIdxToSandboxName(sandboxName);
int overhead = 0;
int clearances = 0;
bool persistent = find(ephemeralSandboxes.begin(), ephemeralSandboxes.end(), sandboxName) == ephemeralSandboxes.end();
// set overhead and clearances; any of the entry points could be annotated
for (Function* entryPoint : entryPoints) {
if (funcToOverhead.find(entryPoint) != funcToOverhead.end()) {
overhead = funcToOverhead[entryPoint];
}
if (funcToClearances.find(entryPoint) != funcToClearances.end()) {
clearances = funcToClearances[entryPoint];
}
}
SDEBUG("soaap.util.sandbox", 3, dbgs() << INDENT_2 << "Creating new Sandbox instance for " << sandboxName << "\n");
sandboxes.push_back(new Sandbox(sandboxName, idx, entryPoints, persistent, M, overhead, clearances));
SDEBUG("soaap.util.sandbox", 3, dbgs() << INDENT_2 << "Created new Sandbox instance\n");
}
/*
for (map<Function*,string>::iterator I=funcToSandboxName.begin(), E=funcToSandboxName.end(); I!=E; I++) {
Function* entryPoint = I->first;
string sandboxName = I->second;
int idx = assignBitIdxToSandboxName(sandboxName);
int overhead = funcToOverhead[entryPoint];
int clearances = funcToClearances[entryPoint];
bool persistent = find(ephemeralSandboxes.begin(), ephemeralSandboxes.end(), entryPoint) == ephemeralSandboxes.end();
SDEBUG("soaap.util.sandbox", 3, dbgs() << INDENT_2 << "Creating new Sandbox instance\n");
sandboxes.push_back(new Sandbox(sandboxName, idx, entryPoint, persistent, M, overhead, clearances));
SDEBUG("soaap.util.sandbox", 3, dbgs() << INDENT_2 << "Created new Sandbox instance\n");
}
*/
// Handle sandboxed code regions, i.e. start_sandboxed_code(N) and end_sandboxed_code(N) blocks
if (Function* SboxStart = M.getFunction("llvm.annotation.i32")) {
for (User* U : SboxStart->users()) {
if (IntrinsicInst* annotCall = dyn_cast<IntrinsicInst>(U)) {
GlobalVariable* annotationStrVar = dyn_cast<GlobalVariable>(annotCall->getOperand(1)->stripPointerCasts());
ConstantDataArray* annotationStrValArray = dyn_cast<ConstantDataArray>(annotationStrVar->getInitializer());
StringRef annotationStrValCString = annotationStrValArray->getAsCString();
if (annotationStrValCString.startswith(SOAAP_SANDBOX_REGION_START)) {
StringRef sandboxName = annotationStrValCString.substr(strlen(SOAAP_SANDBOX_REGION_START)+1); //+1 because of _
SDEBUG("soaap.util.sandbox", 3, dbgs() << INDENT_3 << "Found start of sandboxed code region: "; annotCall->dump(););
InstVector sandboxedInsts;
findAllSandboxedInstructions(annotCall, sandboxName, sandboxedInsts);
int idx = assignBitIdxToSandboxName(sandboxName);
sandboxes.push_back(new Sandbox(sandboxName, idx, sandboxedInsts, false, M)); //TODO: obtain persistent/ephemeral information in a better way (currently we obtain it from the creation point)
}
}
namespace MCPP {
static const String name("Plugin Message Support");
static const Word priority=1;
static const String reg("REGISTER");
static const String unreg("UNREGISTER");
static const Regex is_builtin("^MC\\|");
static Vector<String> get_strings (const Vector<Byte> & buffer) {
// Decode
auto str=UTF8().Decode(buffer.begin(),buffer.end());
// Separate on NULL character
Vector<String> retr;
for (auto cp : str.CodePoints()) {
if (retr.Count()==0) retr.EmplaceBack();
if (cp=='\0') {
retr.EmplaceBack();
continue;
}
retr[retr.Count()-1] << cp;
}
return retr;
}
void PluginMessages::reg (SmartPointer<Client> client, Vector<Byte> data) {
auto channels=get_strings(data);
lock.Write([&] () mutable {
auto iter=clients.find(client);
if (iter==clients.end()) return;
for (auto & channel : channels) iter->second.insert(std::move(channel));
});
}
void PluginMessages::unreg (SmartPointer<Client> client, Vector<Byte> data) {
auto channels=get_strings(data);
lock.Write([&] () mutable {
auto iter=clients.find(client);
if (iter==clients.end()) return;
for (auto & channel : channels) iter->second.erase(channel);
});
}
void PluginMessages::handler (PacketEvent event) {
auto & packet=event.Data.Get<incoming>();
// Handle register/unregister separately
if (packet.Channel==MCPP::reg) {
reg(
std::move(event.From),
std::move(packet.Data)
);
return;
} else if (packet.Channel==MCPP::unreg) {
unreg(
std::move(event.From),
std::move(packet.Data)
);
return;
}
// Try and get associated handler
auto iter=callbacks.find(packet.Channel);
// If there's no associated handler,
// just pass
if (iter==callbacks.end()) return;
// Invoke handler
iter->second(PluginMessage{
std::move(event.From),
std::move(packet.Channel),
std::move(packet.Data)
});
}
Word PluginMessages::Priority () const noexcept {
return priority;
}
const String & PluginMessages::Name () const noexcept {
return name;
}
void PluginMessages::Install () {
auto & server=Server::Get();
server.Router(
incoming::PacketID,
incoming::State
)=[this] (PacketEvent event) mutable { handler(std::move(event)); };
server.OnConnect.Add([this] (SmartPointer<Client> client) mutable {
lock.Write([&] () mutable {
clients.emplace(
std::move(client),
std::unordered_set<String>()
);
});
});
server.OnDisconnect.Add([this] (SmartPointer<Client> client, const String &) mutable {
lock.Write([&] () mutable {
clients.erase(client);
});
});
server.OnShutdown.Add([this] () mutable { callbacks.clear(); });
}
void PluginMessages::Add (String channel, std::function<void (PluginMessage)> callback) {
auto iter=callbacks.find(channel);
// Replace handler if one already exists
if (iter==callbacks.end()) {
callbacks.emplace(
std::move(channel),
std::move(callback)
);
} else {
iter->second=std::move(callback);
}
}
Nullable<Promise<bool>> PluginMessages::Send (PluginMessage message) {
Nullable<Promise<bool>> retr;
if (message.Endpoint.IsNull()) return retr;
if (
is_builtin.IsMatch(message.Channel) ||
lock.Read([&] () mutable {
auto iter=clients.find(message.Endpoint);
return !((iter==clients.end()) || (iter->second.count(message.Channel)==0));
})
) {
outgoing packet;
packet.Channel=std::move(message.Channel);
packet.Data=std::move(message.Buffer);
retr.Construct(message.Endpoint->Send(packet));
}
return retr;
}
static Singleton<PluginMessages> singleton;
PluginMessages & PluginMessages::Get () noexcept {
return singleton.Get();
}
}
bool
Metric::evaluateDaemonAd(classad::ClassAd &metric_ad,classad::ClassAd const &daemon_ad,int max_verbosity,StatsD *statsd,ExtArray<MyString> *regex_groups,char const *regex_attr)
{
if( regex_attr ) {
name = regex_attr;
}
if( !evaluateOptionalString(ATTR_NAME,name,metric_ad,daemon_ad,regex_groups) ) return false;
metric_ad.EvaluateAttrInt(ATTR_VERBOSITY,verbosity);
if( verbosity > max_verbosity ) {
// avoid doing more work; this metric requires higher verbosity
return false;
}
std::string target_type_str;
if( !evaluateOptionalString(ATTR_TARGET_TYPE,target_type_str,metric_ad,daemon_ad,regex_groups) ) return false;
target_type.initializeFromString(target_type_str.c_str());
if( target_type.contains_anycase("machine_slot1") ) {
restrict_slot1 = true;
}
std::string my_type;
daemon_ad.EvaluateAttrString(ATTR_MY_TYPE,my_type);
if( !target_type.isEmpty() && !target_type.contains_anycase("any") ) {
if( restrict_slot1 && !strcasecmp(my_type.c_str(),"machine") ) {
int slotid = 1;
daemon_ad.EvaluateAttrInt(ATTR_SLOT_ID,slotid);
if( slotid != 1 ) {
return false;
}
bool dynamic_slot = false;
daemon_ad.EvaluateAttrBool(ATTR_SLOT_DYNAMIC,dynamic_slot);
if( dynamic_slot ) {
return false;
}
}
else if( !target_type.contains_anycase(my_type.c_str()) ) {
// avoid doing more work; this is not the right type of daemon ad
return false;
}
}
classad::Value requirements_val;
requirements_val.SetBooleanValue(true);
if( !evaluate(ATTR_REQUIREMENTS,requirements_val,metric_ad,daemon_ad,BOOLEAN,regex_groups,regex_attr) ) {
return false;
}
bool requirements = true;
if( !requirements_val.IsBooleanValue(requirements) || requirements!=true ) {
return false;
}
if( !regex_attr ) {
std::string regex;
if( !evaluateOptionalString(ATTR_REGEX,regex,metric_ad,daemon_ad,NULL) ) return false;
if( !regex.empty() ) {
Regex re;
const char *errptr=NULL;
int erroffset=0;
if( !re.compile(regex.c_str(),&errptr,&erroffset,PCRE_ANCHORED) ) {
EXCEPT("Invalid regex %s",regex.c_str());
}
for( classad::ClassAd::const_iterator itr = daemon_ad.begin();
itr != daemon_ad.end();
itr++ )
{
ExtArray<MyString> the_regex_groups;
if( re.match(itr->first.c_str(),&the_regex_groups) ) {
// make a new Metric for this attribute that matched the regex
counted_ptr<Metric> metric(statsd->newMetric());
metric->evaluateDaemonAd(metric_ad,daemon_ad,max_verbosity,statsd,&the_regex_groups,itr->first.c_str());
}
}
return false;
}
}
std::string aggregate_str;
if( !evaluateOptionalString(ATTR_AGGREGATE,aggregate_str,metric_ad,daemon_ad,regex_groups) ) return false;
aggregate = NO_AGGREGATE;
if( strcasecmp(aggregate_str.c_str(),"sum")==0 ) {
aggregate = SUM;
}
else if( strcasecmp(aggregate_str.c_str(),"avg")==0 ) {
aggregate = AVG;
}
else if( strcasecmp(aggregate_str.c_str(),"min")==0 ) {
aggregate = MIN;
}
else if( strcasecmp(aggregate_str.c_str(),"max")==0 ) {
aggregate = MAX;
}
else if( !aggregate_str.empty() ) {
EXCEPT("Invalid aggregate function %s",aggregate_str.c_str());
}
// set default stats grouping
if( isAggregateMetric() ) {
group = "HTCondor Pool";
}
else if( !strcasecmp(my_type.c_str(),"scheduler") ) {
group = "HTCondor Schedd";
}
else if( !strcasecmp(my_type.c_str(),"machine") ) {
group = "HTCondor Startd";
if( !statsd->publishPerExecuteNodeMetrics() ) {
return false;
}
}
else if( !strcasecmp(my_type.c_str(),"daemonmaster") ) {
group = "HTCondor Master";
if( !statsd->publishPerExecuteNodeMetrics() ) {
std::string machine_name;
daemon_ad.EvaluateAttrString(ATTR_MACHINE,machine_name);
if( statsd->isExecuteOnlyNode(machine_name) ) {
return false;
}
}
}
else {
formatstr(group,"HTCondor %s",my_type.c_str());
}
if( isAggregateMetric() ) {
// This is like GROUP BY in SQL.
// By default, group by the name of the metric.
aggregate_group = name;
if( !evaluateOptionalString(ATTR_AGGREGATE_GROUP,aggregate_group,metric_ad,daemon_ad,regex_groups) ) return false;
}
if( !evaluateOptionalString(ATTR_GROUP,group,metric_ad,daemon_ad,regex_groups) ) return false;
if( !evaluateOptionalString(ATTR_TITLE,title,metric_ad,daemon_ad,regex_groups) ) return false;
if( !evaluateOptionalString(ATTR_DESC,desc,metric_ad,daemon_ad,regex_groups) ) return false;
if( !evaluateOptionalString(ATTR_UNITS,units,metric_ad,daemon_ad,regex_groups) ) return false;
if( !evaluateOptionalString(ATTR_CLUSTER,cluster,metric_ad,daemon_ad,regex_groups) ) return false;
metric_ad.EvaluateAttrBool(ATTR_DERIVATIVE,derivative);
metric_ad.EvaluateAttrNumber(ATTR_SCALE,scale);
std::string type_str;
if( !evaluateOptionalString(ATTR_TYPE,type_str,metric_ad,daemon_ad,regex_groups) ) return false;
if( type_str.empty() ) {
type = AUTO;
}
else if( strcasecmp(type_str.c_str(),"string")==0 ) {
type = STRING;
}
else if( strcasecmp(type_str.c_str(),"int8")==0 ) {
type = INT8;
}
else if( strcasecmp(type_str.c_str(),"uint8")==0 ) {
type = UINT8;
}
else if( strcasecmp(type_str.c_str(),"int16")==0 ) {
type = INT16;
}
else if( strcasecmp(type_str.c_str(),"uint16")==0 ) {
type = UINT16;
}
else if( strcasecmp(type_str.c_str(),"int32")==0 ) {
type = INT32;
}
else if( strcasecmp(type_str.c_str(),"uint32")==0 ) {
type = UINT32;
}
else if( strcasecmp(type_str.c_str(),"float")==0 ) {
type = FLOAT;
}
else if( strcasecmp(type_str.c_str(),"double")==0 ) {
type = DOUBLE;
}
else if( strcasecmp(type_str.c_str(),"boolean")==0 ) {
type = BOOLEAN;
}
else {
EXCEPT("Invalid metric attribute type=%s for %s",type_str.c_str(),whichMetric().c_str());
return false;
}
value.SetUndefinedValue();
if( !evaluate(ATTR_VALUE,value,metric_ad,daemon_ad,type,regex_groups,regex_attr) ) {
return false;
}
if( value.IsUndefinedValue() ) {
if( regex_attr ) {
daemon_ad.EvaluateAttr(regex_attr,value);
}
else {
daemon_ad.EvaluateAttr(name,value);
}
}
if( value.IsUndefinedValue() ) {
return false;
}
if ( type == AUTO ) {
if (value.IsBooleanValue() ) {
type = BOOLEAN;
} else if ( value.IsIntegerValue() ) {
type = INT32;
} else if ( value.IsNumber() ) {
type = FLOAT;
} else if ( value.IsStringValue() ) {
type = STRING;
}
}
if( isAggregateMetric() ) {
machine = statsd->getDefaultAggregateHost();
}
else {
if( (!strcasecmp(my_type.c_str(),"machine") && restrict_slot1) || !strcasecmp(my_type.c_str(),"collector") ) {
// for STARTD_SLOT1 metrics, advertise by default as host.name, not slot1.host.name
// ditto for the collector, which typically has a daemon name != machine name, even though there is only one collector
daemon_ad.EvaluateAttrString(ATTR_MACHINE,machine);
}
else if( !strcasecmp(my_type.c_str(),"submitter") ) {
daemon_ad.EvaluateAttrString(ATTR_SCHEDD_NAME,machine);
}
else {
// use the daemon name for the metric machine name
daemon_ad.EvaluateAttrString(ATTR_NAME,machine);
}
}
if( !evaluateOptionalString(ATTR_MACHINE,machine,metric_ad,daemon_ad,regex_groups) ) return false;
statsd->getDaemonIP(machine,ip);
if( !evaluateOptionalString(ATTR_IP,ip,metric_ad,daemon_ad,regex_groups) ) return false;
if( isAggregateMetric() ) {
statsd->addToAggregateValue(*this);
}
else {
statsd->publishMetric(*this);
}
return true;
}
RegexParagraphList(const char *name, const char *regex, const char *listregex) :
RegexMatcher(name, regex),
regexListBreaker("List Breaker", listregex)
{
regexListBreaker.Compile();
}
void Gource::processCommit(RCommit& commit, float t) {
//find user of this commit or create them
RUser* user = 0;
//see if user already exists but if not wait until
//we actually use one of their files before adding them
std::map<std::string, RUser*>::iterator seen_user = users.find(commit.username);
if(seen_user != users.end()) user = seen_user->second;
//check user against filters, if found, discard commit
if(user == 0 && !gGourceSettings.user_filters.empty()) {
for(std::vector<Regex*>::iterator ri = gGourceSettings.user_filters.begin(); ri != gGourceSettings.user_filters.end(); ri++) {
Regex* r = *ri;
if(r->match(commit.username)) {
return;
}
}
}
//find files of this commit or create it
for(std::list<RCommitFile>::iterator it = commit.files.begin(); it != commit.files.end(); it++) {
RCommitFile& cf = *it;
RFile* file = 0;
std::map<std::string, RFile*>::iterator seen_file = files.find(cf.filename);
if(seen_file != files.end()) file = seen_file->second;
if(file == 0) {
//if we already have max files in circulation
//we cant add any more
if(files.size() >= gGourceSettings.max_files)
continue;
//check filename against filters
if(!gGourceSettings.file_filters.empty()) {
bool filtered_filename = false;
for(std::vector<Regex*>::iterator ri = gGourceSettings.file_filters.begin(); ri != gGourceSettings.file_filters.end(); ri++) {
Regex* r = *ri;
if(r->match(cf.filename)) {
filtered_filename = true;
break;
}
}
if(filtered_filename) continue;
}
int tagid = tag_seq++;
file = new RFile(cf.filename, cf.colour, vec2f(0.0,0.0), tagid);
files[cf.filename] = file;
tagfilemap[tagid] = file;
root->addFile(file);
while(root->getParent() != 0) {
debugLog("parent changed to %s\n", root->getPath().c_str());
root = root->getParent();
}
}
//create user if havent yet. do it here to ensure at least one of there files
//was added (incase we hit gGourceSettings.max_files)
if(user == 0) {
vec2f pos;
if(dir_bounds.area() > 0) {
pos = dir_bounds.centre();
} else {
pos = vec2f(0,0);
}
int tagid = tag_seq++;
user = new RUser(commit.username, pos, tagid);
users[commit.username] = user;
tagusermap[tagid] = user;
if(gGourceSettings.highlight_all_users) {
user->setHighlighted(true);
} else {
// set the highlighted flag if name matches a highlighted user
for(std::vector<std::string>::iterator hi = gGourceSettings.highlight_users.begin(); hi != gGourceSettings.highlight_users.end(); hi++) {
std::string highlight = *hi;
if(highlight.size() && user->getName() == highlight) {
user->setHighlighted(true);
break;
}
}
}
debugLog("added user %s, tagid = %d\n", commit.username.c_str(), tagid);
}
//create action
RAction* action = 0;
int commitNo = commit_seq++;
if(cf.action == "D") {
action = new RemoveAction(user, file, t);
} else {
if(cf.action == "A") {
action = new CreateAction(user, file, t);
} else {
action = new ModifyAction(user, file, t);
}
}
user->addAction(action);
}
}
namespace libdnf {
static const Regex RELDEP_REGEX =
Regex("^(\\S*)\\s*(<=|>=|<|>|=)?\\s*(.*)$", REG_EXTENDED);
static bool
getCmpFlags(int *cmp_type, std::string matchCmpType)
{
int subexpr_len = matchCmpType.size();
auto match_start = matchCmpType.c_str();
if (subexpr_len == 2) {
if (strncmp(match_start, "<=", 2) == 0) {
*cmp_type |= HY_LT;
*cmp_type |= HY_EQ;
}
else if (strncmp(match_start, ">=", 2) == 0) {
*cmp_type |= HY_GT;
*cmp_type |= HY_EQ;
}
else
return false;
} else if (subexpr_len == 1) {
if (*match_start == '<')
*cmp_type |= HY_LT;
else if (*match_start == '>')
*cmp_type |= HY_GT;
else if (*match_start == '=')
*cmp_type |= HY_EQ;
else
return false;
} else
return false;
return true;
}
bool
DependencySplitter::parse(const char * reldepStr)
{
enum { NAME = 1, CMP_TYPE = 2, EVR = 3, _LAST_ };
auto matchResult = RELDEP_REGEX.match(reldepStr, false, _LAST_);
if (!matchResult.isMatched() || matchResult.getMatchedLen(NAME) == 0) {
return false;
}
name = matchResult.getMatchedString(NAME);
evr = matchResult.getMatchedString(EVR);
cmpType = 0;
int evrLen = matchResult.getMatchedLen(EVR);
int cmpTypeLen = matchResult.getMatchedLen(CMP_TYPE);
if (cmpTypeLen < 1) {
if (evrLen > 0) {
// name contains the space char, e.g. filename like "hello world.jpg"
evr.clear();
name = reldepStr;
}
return true;
}
if (evrLen < 1)
return false;
return getCmpFlags(&cmpType, matchResult.getMatchedString(CMP_TYPE));
}
}
bool CVS2CLCommitLog::parseCommit(RCommit& commit) {
//fprintf(stderr,"parsing cvs2cl log\n");
std::string line;
if(!getNextLine(line)) return false;
//start of log entry
if(!cvs2cl_logentry_start.match(line)) {
//is this the start of the document
if(!cvs2cl_xml_tag.match(line)) return false;
//fprintf(stderr,"found xml tag\n");
//if so find the first logentry tag
bool found_logentry = false;
while(getNextLine(line)) {
if(cvs2cl_logentry_start.match(line)) {
found_logentry = true;
break;
}
}
if(!found_logentry) return false;
}
//fprintf(stderr,"found logentry\n");
logentry.clear();
logentry.append(line);
logentry.append("\n");
//fprintf(stderr,"found opening tag\n");
bool endfound = false;
while(getNextLine(line)) {
logentry.append(line);
logentry.append("\n");
if(cvs2cl_logentry_end.match(line)) {
//fprintf(stderr,"found closing tag\n");
endfound=true;
break;
}
}
//incomplete commit
if(!endfound) return false;
//fprintf(stderr,"read logentry\n");
TiXmlDocument doc;
if(!doc.Parse(logentry.c_str())) return false;
//fprintf(stderr,"try to parse logentry: %s\n", logentry.c_str());
TiXmlElement* leE = doc.FirstChildElement( "entry" );
std::vector<std::string> entries;
if(!leE) return false;
//parse date
TiXmlElement* dateE = leE->FirstChildElement( "isoDate" );
if(!dateE) return false;
std::string timestamp_str(dateE->GetText());
if(!cvs2cl_logentry_timestamp.match(timestamp_str, &entries))
return false;
struct tm time_str;
time_str.tm_year = atoi(entries[0].c_str()) - 1900;
time_str.tm_mon = atoi(entries[1].c_str()) - 1;
time_str.tm_mday = atoi(entries[2].c_str());
time_str.tm_hour = atoi(entries[3].c_str());
time_str.tm_min = atoi(entries[4].c_str());
time_str.tm_sec = atoi(entries[5].c_str());
time_str.tm_isdst = -1;
commit.timestamp = mktime(&time_str);
//parse author
TiXmlElement* authorE = leE->FirstChildElement("author");
if(authorE != 0) {
std::string author(authorE->GetText());
if(author.empty()) author = "Unknown";
commit.username = author;
}
//parse changes
for(TiXmlElement* fileE = leE->FirstChildElement("file"); fileE != 0; fileE = fileE->NextSiblingElement()) {
TiXmlElement* state = fileE->FirstChildElement("cvsstate");
TiXmlElement* name = fileE->FirstChildElement("name");
//check for state
if(name == 0 || state == 0) continue;
std::string status = strcmp(state->GetText(), "dead") == 0 ? "D" : "M";
std::string file(name->GetText());
if(file.empty()) continue;
commit.addFile(file, status);
}
//fprintf(stderr,"parsed logentry\n");
//read files
return true;
}
void GourceSettings::importGourceSettings(ConfFile& conffile, ConfSection* gource_settings) {
setGourceDefaults();
if(gource_settings == 0) gource_settings = conffile.getSection(default_section_name);
if(gource_settings == 0) {
gource_settings = conffile.addSection("gource");
}
ConfEntry* entry = 0;
//hide flags
std::vector<std::string> hide_fields;
if((entry = gource_settings->getEntry("hide")) != 0) {
if(!entry->hasValue()) conffile.missingValueException(entry);
std::string hide_string = entry->getString();
size_t sep;
while((sep = hide_string.find(",")) != std::string::npos) {
if(sep == 0 && hide_string.size()==1) break;
if(sep == 0) {
hide_string = hide_string.substr(sep+1, hide_string.size()-1);
continue;
}
std::string hide_field = hide_string.substr(0, sep);
hide_fields.push_back(hide_field);
hide_string = hide_string.substr(sep+1, hide_string.size()-1);
}
if(hide_string.size() > 0 && hide_string != ",") hide_fields.push_back(hide_string);
//validate field list
for(std::vector<std::string>::iterator it = hide_fields.begin(); it != hide_fields.end(); it++) {
std::string hide_field = (*it);
if( hide_field != "date"
&& hide_field != "users"
&& hide_field != "tree"
&& hide_field != "files"
&& hide_field != "usernames"
&& hide_field != "filenames"
&& hide_field != "dirnames"
&& hide_field != "bloom"
&& hide_field != "progress"
&& hide_field != "mouse"
&& hide_field != "root") {
std::string unknown_hide_option = std::string("unknown option hide ") + hide_field;
conffile.entryException(entry, unknown_hide_option);
}
}
}
//check hide booleans
for(std::map<std::string,std::string>::iterator it = arg_types.begin(); it != arg_types.end(); it++) {
if(it->first.find("hide-") == 0 && it->second == "bool") {
if(gource_settings->getBool(it->first)) {
std::string hide_field = it->first.substr(5, it->first.size()-5);
hide_fields.push_back(hide_field);
}
}
}
if(hide_fields.size()>0) {
for(std::vector<std::string>::iterator it = hide_fields.begin(); it != hide_fields.end(); it++) {
std::string hidestr = (*it);
if(hidestr == "date") hide_date = true;
else if(hidestr == "users") hide_users = true;
else if(hidestr == "tree") hide_tree = true;
else if(hidestr == "files") hide_files = true;
else if(hidestr == "usernames") hide_usernames = true;
else if(hidestr == "filenames") hide_filenames = true;
else if(hidestr == "dirnames") hide_dirnames = true;
else if(hidestr == "bloom") hide_bloom = true;
else if(hidestr == "progress") hide_progress = true;
else if(hidestr == "root") hide_root = true;
else if(hidestr == "mouse") {
hide_mouse = true;
hide_progress = true;
}
}
}
if((entry = gource_settings->getEntry("date-format")) != 0) {
if(!entry->hasValue()) conffile.missingValueException(entry);
date_format = entry->getString();
}
if(gource_settings->getBool("disable-auto-rotate")) {
disable_auto_rotate=true;
}
if(gource_settings->getBool("disable-auto-skip")) {
auto_skip_seconds = -1.0;
}
if(gource_settings->getBool("loop")) {
loop = true;
}
if((entry = gource_settings->getEntry("git-branch")) != 0) {
if(!entry->hasValue()) conffile.missingValueException(entry);
git_branch = entry->getString();
}
if(gource_settings->getBool("colour-images")) {
colour_user_images = true;
}
if((entry = gource_settings->getEntry("crop")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify crop (vertical,horizontal)");
std::string crop = entry->getString();
if(crop == "vertical") {
crop_vertical = true;
} else if (crop == "horizontal") {
crop_horizontal = true;
} else {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("log-format")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify log-format (format)");
log_format = entry->getString();
if(log_format == "cvs") {
conffile.entryException(entry, "please use either 'cvs2cl' or 'cvs-exp'");
}
if( log_format != "git"
&& log_format != "cvs-exp"
&& log_format != "cvs2cl"
&& log_format != "svn"
&& log_format != "custom"
&& log_format != "hg"
&& log_format != "bzr"
&& log_format != "apache") {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("default-user-image")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify default-user-image (image path)");
default_user_image = entry->getString();
}
if((entry = gource_settings->getEntry("user-image-dir")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify user-image-dir (directory)");
user_image_dir = entry->getString();
//append slash
if(user_image_dir[user_image_dir.size()-1] != '/') {
user_image_dir += std::string("/");
}
//get jpg and png images in dir
DIR *dp;
struct dirent *dirp;
user_image_map.clear();
if((dp = opendir(gGourceSettings.user_image_dir.c_str())) != 0) {
while ((dirp = readdir(dp)) != 0) {
std::string dirfile = std::string(dirp->d_name);
size_t extpos = 0;
if( (extpos=dirfile.rfind(".jpg")) == std::string::npos
&& (extpos=dirfile.rfind(".jpeg")) == std::string::npos
&& (extpos=dirfile.rfind(".png")) == std::string::npos) continue;
std::string image_path = gGourceSettings.user_image_dir + dirfile;
std::string name = dirfile.substr(0,extpos);
#ifdef __APPLE__
CFMutableStringRef help = CFStringCreateMutable(kCFAllocatorDefault, 0);
CFStringAppendCString(help, name.c_str(), kCFStringEncodingUTF8);
CFStringNormalize(help, kCFStringNormalizationFormC);
char data[4096];
CFStringGetCString(help,
data,
sizeof(data),
kCFStringEncodingUTF8);
name = data;
#endif
debugLog("%s => %s", name.c_str(), image_path.c_str());
user_image_map[name] = image_path;
}
closedir(dp);
}
}
if((entry = gource_settings->getEntry("caption-file")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify caption file (filename)");
caption_file = entry->getString();
}
if((entry = gource_settings->getEntry("caption-duration")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify caption duration (seconds)");
caption_duration = entry->getFloat();
if(caption_duration <= 0.0f) {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("caption-size")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify caption size");
caption_size = entry->getInt();
if(caption_size<1 || caption_size>100) {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("caption-offset")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify caption offset");
caption_offset = entry->getInt();
}
if((entry = gource_settings->getEntry("caption-colour")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify caption colour (FFFFFF)");
int r,g,b;
std::string colstring = entry->getString();
if(entry->isVec3()) {
caption_colour = entry->getVec3();
} else if(colstring.size()==6 && sscanf(colstring.c_str(), "%02x%02x%02x", &r, &g, &b) == 3) {
caption_colour = vec3(r,g,b);
caption_colour /= 255.0f;
} else {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("bloom-intensity")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify bloom-intensity (float)");
bloom_intensity = entry->getFloat();
if(bloom_intensity<=0.0f) {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("bloom-multiplier")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify bloom-multiplier (float)");
bloom_multiplier = entry->getFloat();
if(bloom_multiplier<=0.0f) {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("elasticity")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify elasticity (float)");
elasticity = entry->getFloat();
if(elasticity<=0.0f) {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("font-size")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify font size");
font_size = entry->getInt();
if(font_size<1 || font_size>100) {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("hash-seed")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify hash seed (integer)");
gStringHashSeed = entry->getInt();
}
if((entry = gource_settings->getEntry("font-colour")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify font colour (FFFFFF)");
int r,g,b;
std::string colstring = entry->getString();
if(entry->isVec3()) {
font_colour = entry->getVec3();
} else if(colstring.size()==6 && sscanf(colstring.c_str(), "%02x%02x%02x", &r, &g, &b) == 3) {
font_colour = vec3(r,g,b);
font_colour /= 255.0f;
} else {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("background-colour")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify background colour (FFFFFF)");
int r,g,b;
std::string colstring = entry->getString();
if(entry->isVec3()) {
background_colour = entry->getVec3();
} else if(colstring.size()==6 && sscanf(colstring.c_str(), "%02x%02x%02x", &r, &g, &b) == 3) {
background_colour = vec3(r,g,b);
background_colour /= 255.0f;
} else {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("highlight-colour")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify highlight colour (FFFFFF)");
int r,g,b;
std::string colstring = entry->getString();
if(entry->isVec3()) {
highlight_colour = entry->getVec3();
} else if(colstring.size()==6 && sscanf(colstring.c_str(), "%02x%02x%02x", &r, &g, &b) == 3) {
highlight_colour = vec3(r,g,b);
highlight_colour /= 255.0f;
} else {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("selection-colour")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify selection colour (FFFFFF)");
int r,g,b;
std::string colstring = entry->getString();
if(entry->isVec3()) {
selection_colour = entry->getVec3();
} else if(colstring.size()==6 && sscanf(colstring.c_str(), "%02x%02x%02x", &r, &g, &b) == 3) {
selection_colour = vec3(r,g,b);
selection_colour /= 255.0f;
} else {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("dir-colour")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify dir colour (FFFFFF)");
int r,g,b;
std::string colstring = entry->getString();
if(entry->isVec3()) {
dir_colour = entry->getVec3();
} else if(colstring.size()==6 && sscanf(colstring.c_str(), "%02x%02x%02x", &r, &g, &b) == 3) {
dir_colour = vec3(r,g,b);
dir_colour /= 255.0f;
} else {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("background-image")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify background image (image path)");
background_image = entry->getString();
}
if((entry = gource_settings->getEntry("title")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify title");
title = entry->getString();
}
if((entry = gource_settings->getEntry("logo")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify logo (image path)");
logo = entry->getString();
}
if((entry = gource_settings->getEntry("logo-offset")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify logo-offset (XxY)");
std::string logo_offset_str = entry->getString();
int posx = 0;
int posy = 0;
if(parseRectangle(logo_offset_str, posx, posy)) {
logo_offset = vec2(posx, posy);
} else {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("seconds-per-day")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify seconds-per-day (seconds)");
float seconds_per_day = entry->getFloat();
if(seconds_per_day<=0.0f) {
conffile.invalidValueException(entry);
}
// convert seconds-per-day to days-per-second
days_per_second = 1.0 / seconds_per_day;
}
if((entry = gource_settings->getEntry("auto-skip-seconds")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify auto-skip-seconds (seconds)");
auto_skip_seconds = entry->getFloat();
if(auto_skip_seconds <= 0.0) {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("file-idle-time")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify file-idle-time (seconds)");
std::string file_idle_str = entry->getString();
file_idle_time = (float) atoi(file_idle_str.c_str());
if(file_idle_time<0.0f || (file_idle_time == 0.0f && file_idle_str[0] != '0') ) {
conffile.invalidValueException(entry);
}
if(file_idle_time==0.0f) {
file_idle_time = 86400.0f;
}
}
if((entry = gource_settings->getEntry("user-idle-time")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify user-idle-time (seconds)");
user_idle_time = entry->getFloat();
if(user_idle_time < 0.0f) {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("time-scale")) != 0) {
if(!entry->hasValue())
conffile.entryException(entry, "specify time-scale (scale)");
time_scale = entry->getFloat();
if(time_scale <= 0.0f || time_scale > 4.0f) {
conffile.entryException(entry, "time-scale outside of range 0.0 - 4.0");
}
}
if((entry = gource_settings->getEntry("start-position")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify start-position (float,random)");
if(entry->getString() == "random") {
srand(time(0));
start_position = (rand() % 1000) / 1000.0f;
} else {
start_position = entry->getFloat();
if(start_position<=0.0 || start_position>=1.0) {
conffile.entryException(entry, "start-position outside of range 0.0 - 1.0 (non-inclusive)");
}
}
}
if((entry = gource_settings->getEntry("stop-position")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify stop-position (float)");
stop_position = entry->getFloat();
if(stop_position<=0.0 || stop_position>1.0) {
conffile.entryException(entry, "stop-position outside of range 0.0 - 1.0 (inclusive)");
}
}
if((entry = gource_settings->getEntry("stop-at-time")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify stop-at-time (seconds)");
stop_at_time = entry->getFloat();
if(stop_at_time <= 0.0) {
conffile.invalidValueException(entry);
}
}
if(gource_settings->getBool("key")) {
show_key = true;
}
if(gource_settings->getBool("ffp")) {
ffp = true;
}
if(gource_settings->getBool("realtime")) {
days_per_second = 1.0 / 86400.0;
}
if(gource_settings->getBool("dont-stop")) {
dont_stop = true;
}
if(gource_settings->getBool("stop-at-end")) {
stop_at_end = true;
}
//NOTE: this no longer does anything
if(gource_settings->getBool("stop-on-idle")) {
stop_on_idle = true;
}
if((entry = gource_settings->getEntry("max-files")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify max-files (number)");
max_files = entry->getInt();
if( max_files<0 || (max_files == 0 && entry->getString() != "0") ) {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("max-file-lag")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify max-file-lag (seconds)");
max_file_lag = entry->getFloat();
if(max_file_lag==0.0) {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("user-friction")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify user-friction (seconds)");
user_friction = entry->getFloat();
if(user_friction<=0.0) {
conffile.invalidValueException(entry);
}
user_friction = 1.0 / user_friction;
}
if((entry = gource_settings->getEntry("user-scale")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify user-scale (scale)");
user_scale = entry->getFloat();
if(user_scale<=0.0 || user_scale>100.0) {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("max-user-speed")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify max-user-speed (units)");
max_user_speed = entry->getFloat();
if(max_user_speed<=0) {
conffile.invalidValueException(entry);
}
}
if( gource_settings->getBool("highlight-users")
|| gource_settings->getBool("highlight-all-users")) {
highlight_all_users = true;
}
if(gource_settings->getBool("highlight-dirs")) {
highlight_dirs = true;
}
if((entry = gource_settings->getEntry("camera-mode")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify camera-mode (overview,track)");
camera_mode = entry->getString();
if(camera_mode != "overview" && camera_mode != "track") {
conffile.invalidValueException(entry);
}
}
if((entry = gource_settings->getEntry("padding")) != 0) {
if(!entry->hasValue()) conffile.entryException(entry, "specify padding (float)");
padding = entry->getFloat();
if(padding <= 0.0f || padding >= 2.0f) {
conffile.invalidValueException(entry);
}
}
// multi-value entries
if((entry = gource_settings->getEntry("highlight-user")) != 0) {
ConfEntryList* highlight_user_entries = gource_settings->getEntries("highlight-user");
for(ConfEntryList::iterator it = highlight_user_entries->begin(); it != highlight_user_entries->end(); it++) {
entry = *it;
if(!entry->hasValue()) conffile.entryException(entry, "specify highlight-user (user)");
highlight_users.push_back(entry->getString());
}
}
if((entry = gource_settings->getEntry("follow-user")) != 0) {
ConfEntryList* follow_user_entries = gource_settings->getEntries("follow-user");
for(ConfEntryList::iterator it = follow_user_entries->begin(); it != follow_user_entries->end(); it++) {
entry = *it;
if(!entry->hasValue()) conffile.entryException(entry, "specify follow-user (user)");
follow_users.push_back(entry->getString());
}
}
if(gource_settings->getBool("file-extensions")) {
file_extensions=true;
}
if((entry = gource_settings->getEntry("file-filter")) != 0) {
ConfEntryList* filters = gource_settings->getEntries("file-filter");
for(ConfEntryList::iterator it = filters->begin(); it != filters->end(); it++) {
entry = *it;
if(!entry->hasValue()) conffile.entryException(entry, "specify file-filter (regex)");
std::string filter_string = entry->getString();
Regex* r = new Regex(filter_string, 1);
if(!r->isValid()) {
delete r;
conffile.entryException(entry, "invalid file-filter regular expression");
}
file_filters.push_back(r);
}
}
if((entry = gource_settings->getEntry("user-filter")) != 0) {
ConfEntryList* filters = gource_settings->getEntries("user-filter");
for(ConfEntryList::iterator it = filters->begin(); it != filters->end(); it++) {
entry = *it;
if(!entry->hasValue()) conffile.entryException(entry, "specify user-filter (regex)");
std::string filter_string = entry->getString();
Regex* r = new Regex(filter_string, 1);
if(!r->isValid()) {
delete r;
conffile.entryException(entry, "invalid user-filter regular expression");
}
user_filters.push_back(r);
}
}
//validate path
if(gource_settings->hasValue("path")) {
path = gource_settings->getString("path");
default_path = false;
}
if(path == "-") {
if(log_format.size() == 0) {
throw ConfFileException("log-format required when reading from STDIN", "", 0);
}
#ifdef _WIN32
DWORD available_bytes;
HANDLE stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
while(PeekNamedPipe(stdin_handle, 0, 0, 0,
&available_bytes, 0) && available_bytes==0 && !std::cin.fail()) {
SDL_Delay(100);
}
#else
while(std::cin.peek() == EOF && !std::cin.fail()) SDL_Delay(100);
#endif
std::cin.clear();
}
//remove trailing slash and check if path is a directory
if(path.size() &&
(path[path.size()-1] == '\\' || path[path.size()-1] == '/')) {
path = path.substr(0,path.size()-1);
}
#ifdef _WIN32
//on windows, pre-open console window if we think this is a directory the
//user is trying to open, as system() commands will create a console window
//if there isn't one anyway.
bool isdir = false;
if(path.size()>0) {
struct stat fileinfo;
int rc = stat(path.c_str(), &fileinfo);
if(rc==0 && fileinfo.st_mode & S_IFDIR) isdir = true;
}
if(path.size()==0 || isdir) {
SDLAppCreateWindowsConsole();
}
#endif
}
void OpenLayersNode::AsHTML(HTMLOutputter &outputter)
{
static const char * str_width = "width";
static const char * str_height = "height";
static const char * str_px = "px";
attrs[string("mapnum")] = to_string(++mapNum);
set_default(attrs, str_width, to_string(640));
set_default(attrs, str_height, to_string(480));
if (debug) cout << "Outputing OpenLayers node " << mapNum << endl;
attrs[str_width] = attrs[str_width] + str_px;
attrs[str_height] = attrs[str_height] + str_px;
{
map<string, string> vars;
CopyMap(attrs, vars);
static const char *prefix =
"<div class=\"map\" id=\"map$mapnum\" style=\"width: $width; height: $height; direction: ltr;\"></div>"
"<script type=\"text/javascript\">\n"
"//<![CDATA[\n";
outputter.AddString(subst(prefix, vars));
outputter.AddString(subst(sections_preamble,vars));
}
bool markerlayer = false;
const char *buffer = text.data();
size_t bufferLength = text.length();
while (bufferLength && isspace(*buffer))
{
--bufferLength;
++buffer;
}
if (debug) cout << "Processing line (" << bufferLength << ") '" << string(buffer, bufferLength) << "'" << endl;
while (bufferLength)
{
RegexMatch match;
bool changed(false);
if (regex_kml.Match(buffer, bufferLength, match))
{
buffer += match.End(0); bufferLength -= match.End(0);
map<string, string> vars;
CopyMap(attrs, vars);
if (debug) cout << "Outputting kml URL '" << match.Match(2) << "'" << endl;
vars[string("kmlurl")] = match.Match(2);
outputter.AddString(subst(sections_KML, vars));
changed = true;
} else if (regex_gpstrack.Match(buffer, bufferLength, match)) {
buffer += match.End(0); bufferLength -= match.End(0);
map<string, string> vars;
CopyMap(attrs, vars);
vars[string("fromdate")] = match.Match(2);
vars[string("todate")] = match.Match(3);
vars[string("imgoffset")] = match.Match(4);
if (vars.find("imgoffset") == vars.end())
vars[string("imgoffset")] = string("14");
outputter.AddString(subst(sections_gpstracklayer, vars));
changed = true;
} else if (regex_dotkml.Match(buffer, bufferLength, match))
{
buffer += match.End(0); bufferLength -= match.End(0);
map<string, string> vars;
CopyMap(attrs, vars);
vars[string("kmlurl")] = match.Match(1);
outputter.AddString(subst(sections_KML, vars));
changed = true;
} else if (regex_gpx.Match(buffer, bufferLength, match))
{
buffer += match.End(0); bufferLength -= match.End(0);
map<string, string> vars;
CopyMap(attrs, vars);
vars[string("gpxurl")] = match.Match(2);
vars[string("gpxtitle")] = match.Match(3);
outputter.AddString(subst(sections_GPX, vars));
changed = true;
} else if (regex_dotgpx.Match(buffer, bufferLength, match))
{
buffer += match.End(0); bufferLength -= match.End(0);
map<string, string> vars;
CopyMap(attrs, vars);
vars[string("gpxurl")] = match.Match(1);
outputter.AddString(subst(sections_GPX, vars));
changed = true;
} else if (regex_georss.Match(buffer, bufferLength, match))
{
buffer += match.End(0); bufferLength -= match.End(0);
map<string, string> vars;
CopyMap(attrs, vars);
vars[string("georsslayer")] = match.Match(3);
vars[string("georssurl")] = match.Match(2) + match.Match(3);
outputter.AddString(subst(sections_GeoRSS, vars));
changed = true;
}
else if (regex_latloncsv.Match(buffer, bufferLength, match))
{
if (debug) cout << "Latlon csv " << match.Match(0) << endl;
buffer += match.End(0); bufferLength -= match.End(0);
string lat = match.Match(1);
string lon = match.Match(2);
string caption;
string title;
if (!match.Match(3).empty()) {
title = match.Match(4);
caption = "<p><b>" + match.Match(4) + "</b></p>";
}
while (regex_label.Match(buffer, bufferLength, match))
{
buffer += match.End(0); bufferLength -= match.End(0);
caption = caption + match.Match(1);
}
caption = JavaScriptQuote(caption);
title = JavaScriptQuote(title);
if (!markerlayer)
{
markerlayer = true;
map<string, string> vars;
CopyMap(attrs, vars);
outputter.AddString(subst(sections_markerlayerbegin, vars));
}
map<string, string> vars;
CopyMap(attrs, vars);
vars[string("caption")] = caption;
vars[string("title")] = title;
vars[string("lat")] = lat;
vars[string("lon")] = lon;
outputter.AddString(subst(sections_marker, vars));
changed = true;
}
else if (regex_lat_lon_title.Match(buffer, bufferLength, match))
{
if (debug) cout << "Latlon title " << match.Match(0) << endl;
buffer += match.End(0); bufferLength -= match.End(0);
string lat = match.Match(1);
string lon = match.Match(2);
string caption;
string title;
if (match.Count() > 3 && match.Start(3) != match.End(3))
{
title = match.Match(3);
caption = "<p><b>" + match.Match(3) + "</b></p>";
}
while (regex_label.Match(buffer, bufferLength, match))
{
buffer += match.End(0); bufferLength -= match.End(0);
caption = caption + match.Match(1);
}
caption = JavaScriptQuote(caption);
map<string, string> vars;
CopyMap(attrs, vars);
if (markerlayer)
{
markerlayer = true;
outputter.AddString(subst(sections_markerlayerbegin, vars));
}
vars[string("caption")] = caption;
vars[string("title")] = title;
vars[string("lat")] = lat;
vars[string("lon")] = lon;
outputter.AddString(subst(sections_marker, vars));
changed = true;
}
else if (regex_zoom_color.Match(buffer, bufferLength, match))
{
buffer += match.End(0); bufferLength -= match.End(0);
string zoomq = match.Match(1);
string huh = match.Match(2);
string color = match.Match(3);
map<string, string> vars;
CopyMap(attrs, vars);
vars[string("zoomq")] = zoomq;
vars[string("huh")] = huh;
vars[string("color")] = color;
outputter.AddString(subst(sections_vectorlayerpreamble, vars));
while (regex_latloncsv_no_label.Match(buffer, bufferLength, match))
{
buffer += match.End(0); bufferLength -= match.End(0);
vars[string("lat")] = match.Match(1);
vars[string("lon")] = match.Match(2);
outputter.AddString(subst(sections_vectorlayerpoint, vars));
}
vars.erase(vars.find("lat"));
vars.erase(vars.find("lon"));
outputter.AddString(subst(sections_vectorlayerpost, vars));
changed = true;
}
// THIS LOOKS WRONG!
else if (regex_latloncsv.Match(buffer, bufferLength, match))
{
buffer += match.End(0); bufferLength -= match.End(0);
string zoomq = match.Match(1);
string huh = match.Match(2);
string color = "#758BC5";
map<string, string> vars;
CopyMap(attrs, vars);
vars[string("zoomq")] = zoomq;
vars[string("huh")] = huh;
vars[string("color")] = color;
if (debug) cout << "Outputting latloncsv for " << match.Match(0) << endl;
outputter.AddString(subst(sections_vectorlayerpreamble, vars));
while (regex_latloncsv_no_label.Match(buffer, bufferLength, match))
{
buffer += match.End(0); bufferLength -= match.End(0);
vars[string("lat")] = match.Match(1);
vars[string("lon")] = match.Match(2);
outputter.AddString(subst(sections_vectorlayerpoint, vars));
vars.erase(vars.find(string("lat")));
vars.erase(vars.find(string("lon")));
}
outputter.AddString(subst(sections_vectorlayerpost, vars));
changed = true;
}
if (!changed)
{
cout << "Parse failure: '" << string(buffer, bufferLength) << "'" << endl;
break;
}
}
{
map<string, string> vars;
CopyMap(attrs, vars);
outputter.AddString(subst(sections_post, vars));
}
static const char *suffix =
"//]]>\n"
"</script>\n";
outputter.AddString(suffix);
}
