/**
* @brief Verify that the searchAndReplace function correctly spot remain of an old value and replace them by a new value according to the current step in initialization phase.
*/
void verifySearchAndReplace() {
GRID grid;
grid.height = 5;
grid.width = 5;
int matrix[5][5] = {
{WALL, WALL, WALL, WALL, WALL},
{WALL, 1, 2, 2, WALL},
{WALL, 1, WALL, 2, WALL},
{WALL, 1, 1, 2, WALL},
{WALL, WALL, WALL, WALL, WALL}
};
grid.matrix = (int**) matrix;
searchAndReplace(&grid, 1, 2);
CU_ASSERT(grid.height == 5);
CU_ASSERT(grid.width == 5);
CU_ASSERT(grid.matrix[1][1] == 2);
CU_ASSERT(grid.matrix[1][2] == 2);
CU_ASSERT(grid.matrix[1][3] == 2);
CU_ASSERT(grid.matrix[2][1] == 2);
CU_ASSERT(grid.matrix[2][3] == 2);
CU_ASSERT(grid.matrix[3][1] == 2);
CU_ASSERT(grid.matrix[3][2] == 2);
CU_ASSERT(grid.matrix[3][3] == 2);
}
//---------------------------------------------------------------------------
int APIENTRY
ListLoadNext( HWND parentWin, HWND listWin, char* fileToLoad, int showFlags)
{
g_text = elfdump( fileToLoad );
if ( g_text.empty() ) {
return LISTPLUGIN_ERROR;
}
searchAndReplace( g_text, "\n", "\r\n" );
g_text_lo.resize( g_text.length() );
std::transform( g_text.begin(), g_text.end(), g_text_lo.begin(), ::tolower );
HFONT font;
if ( showFlags & lcp_ansi ) {
font = (HFONT)GetStockObject( ANSI_FIXED_FONT );
}
else {
font = (HFONT)GetStockObject( SYSTEM_FIXED_FONT );
}
SendMessage( listWin, WM_SETFONT, (WPARAM)font, MAKELPARAM( true, 0 ) );
SendMessage( listWin, WM_SETTEXT, 0, (LPARAM)g_text.c_str() );
PostMessage( parentWin, WM_COMMAND, MAKELONG( 0, itm_percent ), (LPARAM)listWin );
return LISTPLUGIN_OK;
}
void writeShader(osg::Shader* shader, const std::string& cppFileName, const std::string& variableName)
{
osgDB::ofstream fout(cppFileName.c_str());
if (!fout)
{
std::cout<<"Error: could not open file `"<<cppFileName<<"` for writing."<<std::endl;
}
std::string shaderSource = shader->getShaderSource();
searchAndReplace(shaderSource, "\r\n", "\n");
searchAndReplace(shaderSource, "\r", "\n");
searchAndReplace(shaderSource, "\"", "\\\"");
std::string variableString = std::string("char ")+variableName+std::string("[] = ");
std::string::size_type startOfLine = 0;
std::string::size_type endOfLine = shaderSource.find_first_of('\n', startOfLine);
if (endOfLine==std::string::npos)
{
fout<<variableString<<shaderSource<<"\\n\";"<<std::endl;
}
else
{
std::string padding(variableString.size(),' ');
fout<<variableString<<"\""<<shaderSource.substr(startOfLine,endOfLine-startOfLine)<<"\\n\""<<std::endl;
startOfLine = endOfLine+1;
endOfLine = shaderSource.find_first_of('\n', startOfLine);
while (endOfLine != std::string::npos)
{
fout<<padding<<"\""<<shaderSource.substr(startOfLine,endOfLine-startOfLine)<<"\\n\""<<std::endl;
startOfLine = endOfLine + 1;
endOfLine = shaderSource.find_first_of('\n', startOfLine);
}
fout<<padding<<"\""<<shaderSource.substr(startOfLine,endOfLine-startOfLine)<<"\\n\";"<<std::endl;
}
std::cout<<"Written shader to `"<<cppFileName<<"`"<<std::endl;
}
bool GLShader::buildLightShaderVariant(int lightType, int variantFlag)
{
const char *lightIds[MAX_LIGHTS] = {"0","1","2","3","4","5","6","7"};
const char *lightIdToken = "%LIGHTID%";
const char *lightLoopStartToken = "%LIGHTLOOP:START%";
const char *lightLoopEndToken = "%LIGHTLOOP:END%";
int lightLoopStartTokenLen = 17;
int lightLoopEndTokenLen = 15;
bool isMultiLight = light_multi[lightType];
std::string lightFrag;
std::string lightVert;
lightFrag.append(light_frag_str[lightType]);
lightVert.append(light_vert_str[lightType]);
searchAndReplace(lightFrag,"%hasColorMap%",(variantFlag & SHADER_VARIANT_COLOR)?"1":"0");
searchAndReplace(lightVert,"%hasColorMap%",(variantFlag & SHADER_VARIANT_COLOR)?"1":"0");
searchAndReplace(lightFrag,"%hasAlphaMap%",(variantFlag & SHADER_VARIANT_ALPHA)?"1":"0");
searchAndReplace(lightVert,"%hasAlphaMap%",(variantFlag & SHADER_VARIANT_ALPHA)?"1":"0");
searchAndReplace(lightFrag,"%hasSpecMap%",(variantFlag & SHADER_VARIANT_SPECULAR)?"1":"0");
searchAndReplace(lightVert,"%hasSpecMap%",(variantFlag & SHADER_VARIANT_SPECULAR)?"1":"0");
searchAndReplace(lightFrag,"%hasLumiMap%",(variantFlag & SHADER_VARIANT_LUMINOSITY)?"1":"0");
searchAndReplace(lightVert,"%hasLumiMap%",(variantFlag & SHADER_VARIANT_LUMINOSITY)?"1":"0");
searchAndReplace(lightFrag,"%hasBumpMap%",(variantFlag & SHADER_VARIANT_BUMP)?"1":"0");
searchAndReplace(lightVert,"%hasBumpMap%",(variantFlag & SHADER_VARIANT_BUMP)?"1":"0");
searchAndReplace(lightFrag,"%hasShadowMap0%",(variantFlag & SHADER_VARIANT_SHADOW0)?"1":"0");
searchAndReplace(lightVert,"%hasShadowMap0%",(variantFlag & SHADER_VARIANT_SHADOW0)?"1":"0");
searchAndReplace(lightFrag,"%hasShadowMap1%",(variantFlag & SHADER_VARIANT_SHADOW1)?"1":"0");
searchAndReplace(lightVert,"%hasShadowMap1%",(variantFlag & SHADER_VARIANT_SHADOW1)?"1":"0");
searchAndReplace(lightFrag,"%hasShadowMap2%",(variantFlag & SHADER_VARIANT_SHADOW2)?"1":"0");
searchAndReplace(lightVert,"%hasShadowMap2%",(variantFlag & SHADER_VARIANT_SHADOW2)?"1":"0");
searchAndReplace(lightFrag,"%hasShadowMap3%",(variantFlag & SHADER_VARIANT_SHADOW3)?"1":"0");
searchAndReplace(lightVert,"%hasShadowMap3%",(variantFlag & SHADER_VARIANT_SHADOW3)?"1":"0");
searchAndReplace(lightFrag,"%hasShadowMap4%",(variantFlag & SHADER_VARIANT_SHADOW4)?"1":"0");
searchAndReplace(lightVert,"%hasShadowMap4%",(variantFlag & SHADER_VARIANT_SHADOW4)?"1":"0");
searchAndReplace(lightFrag,"%hasShadowMap5%",(variantFlag & SHADER_VARIANT_SHADOW5)?"1":"0");
searchAndReplace(lightVert,"%hasShadowMap5%",(variantFlag & SHADER_VARIANT_SHADOW5)?"1":"0");
searchAndReplace(lightFrag,"%hasShadowMap6%",(variantFlag & SHADER_VARIANT_SHADOW6)?"1":"0");
searchAndReplace(lightVert,"%hasShadowMap6%",(variantFlag & SHADER_VARIANT_SHADOW6)?"1":"0");
searchAndReplace(lightFrag,"%hasShadowMap7%",(variantFlag & SHADER_VARIANT_SHADOW7)?"1":"0");
searchAndReplace(lightVert,"%hasShadowMap7%",(variantFlag & SHADER_VARIANT_SHADOW7)?"1":"0");
searchAndReplace(lightFrag,"%hasReflectionMap%",(variantFlag & SHADER_VARIANT_REFLECTION)?"1":"0");
searchAndReplace(lightVert,"%hasReflectionMap%",(variantFlag & SHADER_VARIANT_REFLECTION)?"1":"0");
searchAndReplace(lightFrag,"%hasEnvSphereMap%",(variantFlag & SHADER_VARIANT_ENVSPHEREMAP)?"1":"0");
searchAndReplace(lightVert,"%hasEnvSphereMap%",(variantFlag & SHADER_VARIANT_ENVSPHEREMAP)?"1":"0");
searchAndReplace(lightFrag,"%hasLightMap%",(variantFlag & SHADER_VARIANT_LIGHTMAP)?"1":"0");
searchAndReplace(lightVert,"%hasLightMap%",(variantFlag & SHADER_VARIANT_LIGHTMAP)?"1":"0");
searchAndReplace(lightFrag,"%hasParallaxMap%",(variantFlag & SHADER_VARIANT_PARALLAX)?"1":"0");
searchAndReplace(lightVert,"%hasParallaxMap%",(variantFlag & SHADER_VARIANT_PARALLAX)?"1":"0");
if (isMultiLight)
{
std::vector<unsigned int> loopStarts;
std::vector<unsigned int> loopEnds;
for (int i = 0; i < MAX_LIGHTS; i++)
{
GLShader *tmpShader = new GLShader();
std::string thisFrag;
std::string thisVert;
std::vector<std::string> lightVertLoops;
std::vector<std::string> lightFragLoops;
std::vector<std::string> lightVertLoopsAccum;
std::vector<std::string> lightFragLoopsAccum;
std::vector<unsigned int> startFragLoops;
std::vector<unsigned int> endFragLoops;
std::vector<unsigned int> startVertLoops;
std::vector<unsigned int> endVertLoops;
// printf("finding loops..");
findLoops(lightVert,lightLoopStartToken,lightLoopEndToken,startVertLoops,endVertLoops);
findLoops(lightFrag,lightLoopStartToken,lightLoopEndToken,startFragLoops,endFragLoops);
// printf("done.\n");
if (startVertLoops.size() != endVertLoops.size())
{
Logger::log(LOG_ERROR,"Error multilight type %d: Mismatched vertex shader light loop scopes\n",lightType);
return false;
}
if (startFragLoops.size() != endFragLoops.size())
{
Logger::log(LOG_ERROR,"Error multilight type %d: Mismatched fragment shader light loop scopes\n",lightType);
return false;
}
lightFragLoops.resize(startFragLoops.size());
lightVertLoops.resize(startVertLoops.size());
lightFragLoopsAccum.resize(startFragLoops.size());
lightVertLoopsAccum.resize(startVertLoops.size());
thisFrag.append(lightFrag);
thisVert.append(lightVert);
int numVertLoops = startVertLoops.size();
int numFragLoops = startFragLoops.size();
for (int j = 0; j < numVertLoops; j++)
{
lightVertLoops[j].append(lightVert.substr(startVertLoops[j], endVertLoops[j]-startVertLoops[j]+lightLoopEndTokenLen));
// printf("lightVertLoops %d: %s\n\n",j,lightVertLoops[j].c_str());
for (int k = 0; k <= i; k++)
{
std::string thisVertLoop;
thisVertLoop.append(lightVert.substr(startVertLoops[j]+lightLoopStartTokenLen, endVertLoops[j]-startVertLoops[j]-lightLoopStartTokenLen));
searchAndReplace(thisVertLoop,lightIdToken,lightIds[k]);
// printf("thisVertLoop %d: %s\n\n",j,thisVertLoop.c_str());
lightVertLoopsAccum[j].append(thisVertLoop);
}
// printf("lightVertLoopsAccum %d: %s\n\n",j,lightVertLoopsAccum[j].c_str());
}
for (int j = 0; j < numFragLoops; j++)
{
lightFragLoops[j].append(lightFrag.substr(startFragLoops[j], endFragLoops[j]-startFragLoops[j]+lightLoopEndTokenLen));
// printf("lightFragLoops %d: %s\n\n",j,lightFragLoops[j].c_str());
for (int k = 0; k <= i; k++)
{
std::string thisFragLoop;
thisFragLoop.append(lightFrag.substr(startFragLoops[j]+lightLoopStartTokenLen, endFragLoops[j]-startFragLoops[j]-lightLoopStartTokenLen));
searchAndReplace(thisFragLoop,lightIdToken,lightIds[k]);
lightFragLoopsAccum[j].append(thisFragLoop);
// printf("lightFragLoop %d: %s\n\n",j,thisFragLoop.c_str());
}
// printf("lightFragLoopsAccum %d: %s\n\n",j,lightFragLoopsAccum[j].c_str());
}
for (int j = 0; j < numFragLoops; j++)
{
searchAndReplace(thisFrag,lightFragLoops[j].c_str(),lightFragLoopsAccum[j].c_str());
}
for (int j = 0; j < numVertLoops; j++)
{
searchAndReplace(thisVert,lightVertLoops[j].c_str(),lightVertLoopsAccum[j].c_str());
}
//printf("building variant light shader %d, light #%d, variant flag %d\n\n",lightType,i,variantFlag);
if (!tmpShader->setup(thisVert.c_str(),thisFrag.c_str(),NULL))
{
//printf("light shader variant build failure.\n\n");
return false;
}
lightShader[lightType][variantFlag].push_back(tmpShader);
}
}
else
{
for (int i = 0; i < MAX_LIGHTS; i++)
{
GLShader *tmpShader = new GLShader();
std::string thisFrag;
std::string thisVert;
thisFrag.append(lightFrag);
thisVert.append(lightVert);
searchAndReplace(thisFrag,lightIdToken,lightIds[i]);
searchAndReplace(thisVert,lightIdToken,lightIds[i]);
//printf("building variant light shader %d, light #%d, variant flag %d\n\n",lightType,i,variantFlag);
if (!tmpShader->setup(thisVert.c_str(),thisFrag.c_str(),NULL))
{
//printf("light shader variant build failure.\n\n");
return false;
}
lightShader[lightType][variantFlag].push_back(tmpShader);
}
}
return true;
}
/* OS_CustomLog: v0.1, 2012/10/10*/
void OS_CustomLog(Eventinfo *lf,char* format)
{
char *log;
char *tmp_log;
char tmp_buffer[1024];
//Replace all the tokens:
os_strdup(format,log);
snprintf(tmp_buffer, 1024, "%d", lf->time);
tmp_log = searchAndReplace(log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_TIMESTAMP], tmp_buffer);
if(log)
{
os_free(log);
log=NULL;
}
snprintf(tmp_buffer, 1024, "%ld", __crt_ftell);
log = searchAndReplace(tmp_log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_FTELL], tmp_buffer);
if (tmp_log)
{
os_free(tmp_log);
tmp_log=NULL;
}
snprintf(tmp_buffer, 1024, "%s", (lf->generated_rule->alert_opts & DO_MAILALERT)?"mail " : "");
tmp_log = searchAndReplace(log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_RULE_ALERT_OPTIONS], tmp_buffer);
if(log)
{
os_free(log);
log=NULL;
}
snprintf(tmp_buffer, 1024, "%s",lf->hostname?lf->hostname:"None");
log = searchAndReplace(tmp_log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_HOSTNAME], tmp_buffer);
if (tmp_log)
{
os_free(tmp_log);
tmp_log=NULL;
}
snprintf(tmp_buffer, 1024, "%s",lf->location?lf->location:"None");
tmp_log = searchAndReplace(log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_LOCATION], tmp_buffer);
if(log)
{
os_free(log);
log=NULL;
}
snprintf(tmp_buffer, 1024, "%d", lf->generated_rule->sigid);
log = searchAndReplace(tmp_log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_RULE_ID], tmp_buffer);
if (tmp_log)
{
os_free(tmp_log);
tmp_log=NULL;
}
snprintf(tmp_buffer, 1024, "%d", lf->generated_rule->level);
tmp_log = searchAndReplace(log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_RULE_LEVEL], tmp_buffer);
if(log)
{
os_free(log);
log=NULL;
}
snprintf(tmp_buffer, 1024, "%s",lf->srcip?lf->srcip:"None");
log = searchAndReplace(tmp_log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_SRC_IP], tmp_buffer);
if (tmp_log)
{
os_free(tmp_log);
tmp_log=NULL;
}
snprintf(tmp_buffer, 1024, "%s",lf->srcuser?lf->srcuser:"******");
tmp_log = searchAndReplace(log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_DST_USER], tmp_buffer);
if(log)
{
os_free(log);
log=NULL;
}
char * escaped_log;
escaped_log = escape_newlines(lf->full_log);
log = searchAndReplace(tmp_log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_FULL_LOG],escaped_log );
if (tmp_log)
{
os_free(tmp_log);
tmp_log=NULL;
}
if(escaped_log)
{
os_free(escaped_log);
escaped_log=NULL;
}
snprintf(tmp_buffer, 1024, "%s",lf->generated_rule->comment?lf->generated_rule->comment:"");
tmp_log = searchAndReplace(log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_RULE_COMMENT], tmp_buffer);
if(log)
{
os_free(log);
log=NULL;
}
snprintf(tmp_buffer, 1024, "%s",lf->generated_rule->group?lf->generated_rule->group:"");
log = searchAndReplace(tmp_log, CustomAlertTokenName[CUSTOM_ALERT_TOKEN_RULE_GROUP], tmp_buffer);
if (tmp_log)
{
os_free(tmp_log);
tmp_log=NULL;
}
fprintf(_aflog,log);
fprintf(_aflog,"\n");
fflush(_aflog);
if(log)
{
os_free(log);
log=NULL;
}
return;
}
int readconfig(struct passwd *pwd, pam_handle_t * pamh, const char *user,
char *path, char *targetpath, char *encfs_options,
char *fuse_options)
{
FILE *conffile;
char line[BUFSIZE];
char username[USERNAME_MAX];
int parsed;
const char *tmp;
// Return 1 = error, 2 = silent error (ie already mounted)
if ((conffile = fopen(CONFIGFILE, "r")) == NULL)
{
_pam_log(LOG_ERR, "Failed to open conffile %s", CONFIGFILE);
return 0;
}
while (fgets(line, BUFSIZE, conffile) != NULL)
{
if (line[0] == '#')
continue;
parsed =
sscanf(line, "%s%s%s%s%s", username, path, targetpath,
encfs_options, fuse_options);
if (parsed == -1)
continue;
if (strcmp("drop_permissions", username) == 0)
{
drop_permissions = 1;
continue;
}
if (strcmp("encfs_default", username) == 0)
{
if (parsed == 2 && !strcmp("-",path) == 0)
strcpy(default_encfs_options, path);
continue;
}
if (strcmp("fuse_default", username) == 0)
{
if (parsed == 2 && !strcmp("-",path) == 0)
strcpy(default_fuse_options, path);
continue;
}
if (parsed == 5)
{
// Parsing user:
if (strcmp("-", encfs_options) == 0)
strcpy(encfs_options, "");
if (strcmp("-", fuse_options) == 0)
strcpy(fuse_options, "");
searchAndReplace(default_encfs_options);
searchAndReplace(encfs_options);
// Check if this is the right user / default user.
if ((strcmp("-",username) != 0) && (strcmp(user,username) != 0)
&& (strcmp("*",username) !=0))
continue;
if (strcmp("-",username) == 0) {
strcat(path, "/");
strcat(path, user);
// Todo check if dir exists and give better error msg.
}
// If username is '*', paths are relative to $HOME
if (strcmp("*", username) == 0
&& strcmp("-", targetpath) != 0)
{
if ((tmp = getHome(pwd, pamh)))
{
char home[PATH_MAX];
strcpy(home, tmp);
strcat(home, "/");
strcat(home, path);
strcpy(path, home);
strcpy(home, tmp);
strcat(home, "/");
strcat(home, targetpath);
strcpy(targetpath, home);
}
}
if (strcmp("-", targetpath) == 0)
{
// We do not have targetpath, construct one.
strcpy(targetpath, "");
if ((tmp = getHome(pwd, pamh)))
{
strcpy(targetpath, tmp);
}
}
// Done, check targetpath and return.
if (!targetpath || *targetpath == '\0')
{
_pam_log(LOG_ERR, "Can't get to HOME dir for user %s", user);
fclose(conffile);
return 0;
}
// Check if path exists, if we're "-" then we dont care, if not we give error.
if (is_dir(path))
{
// We may fail to stat this directory (EPERM) if it's mounted because of fuse's funky permission system.
if (!is_dir(targetpath))
{
if (checkmnt(targetpath))
{
// Doublecheck if we're mounted, for some reason we can't stat the dir even when root if it's mounted.
// we are mounted, but we return 1 anyway so we can store targetpath
fclose(conffile);
return 1;
}
_pam_log(LOG_ERR, "TargetPath for %s does not exist (%s)",
user, targetpath);
fclose(conffile);
return 0;
}
fclose(conffile);
return 1;
}
// Path does not exist, if we're a specified user give error, if not keep looking.
if ((strcmp("-", username) != 0)
&& (strcmp("*", username) != 0))
{
_pam_log(LOG_ERR, "Path for %s does not exist (%s)", user,
path);
fclose(conffile);
return 0;
}
continue;
}
continue;
}
fclose(conffile);
return 0;
}
