//=========================================================================== // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== quakefile_t *FindQuakeFiles( char *filter ) { char *str; char newfilter[_MAX_PATH]; char pakfilter[_MAX_PATH]; char filefilter[_MAX_PATH]; strcpy( newfilter, filter ); ConvertPath( newfilter ); strcpy( pakfilter, newfilter ); str = StringContains( pakfilter, ".pak", false ); if ( !str ) { str = StringContains( pakfilter, ".pk3", false ); } if ( str ) { str += strlen( ".pak" ); if ( *str ) { *str++ = '\0'; while ( *str == '\\' || *str == '/' ) str++; strcpy( filefilter, str ); return FindQuakeFilesWithPakFilter( pakfilter, filefilter ); } //end if } //end else return FindQuakeFilesWithPakFilter( NULL, newfilter ); } //end of the function FindQuakeFiles
static bool LineSatisfiesArch(const std::string &line, const std::string arch) { bool has_arch_tags = false; for (auto &&possible_arch : AllArches) { if (StringContains(line, possible_arch)) { has_arch_tags = true; break; } } return (has_arch_tags && StringContains(line, arch)) || !has_arch_tags; }
bool VersionScriptParser::SymbolInArchAndApiVersion(const std::string &line, const std::string &arch, int api) { // If the tags do not have an "introduced" requirement, the symbol is // exported. if (!StringContains(line, "introduced") && LineSatisfiesArch(line, arch)) { return true; } if (line == "future") { return api == FUTURE_API; } const std::string regex_match_string1 = " *introduced-" + arch + "=([0-9]+)"; const std::string regex_match_string2 = " *introduced=([0-9]+)"; std::smatch matcher1; std::smatch matcher2; std::regex match_clause1(regex_match_string1); std::regex match_clause2(regex_match_string2); int matched_api = -1; if (std::regex_search(line, matcher1, match_clause1)) { matched_api = std::stoi(matcher1.str(1)); } else if ((std::regex_search(line, matcher2, match_clause2)) && LineSatisfiesArch(line, arch)) { matched_api = std::stoi(matcher2.str(1)); } // If the arch specific tag / version specific tag was found and the api level // required was greater than the api level offered. return (matched_api <=0 || api >= matched_api); }
LineScope VersionScriptParser::GetLineScope(std::string &line, LineScope scope) { if (StringContains(line, "local:")) { scope = LineScope::local; } return scope; }
static int _fileSystemIsSupported( const char * fs ) { string_t st = StringGetFromVirtualFile( "/proc/filesystems" ) ; stringList_t stl = StringListStringSplit( st,'\n' ) ; StringListIterator it = StringListBegin( stl ) ; StringListIterator end = StringListEnd( stl ) ; string_t xt ; int r = 0 ; while( it != end ){ xt = *it ; it++ ; if( !StringStartsWith( xt,"nodev" ) ){ if( StringContains( xt,fs ) ){ r = 1 ; break ; } } } StringDelete( &st ) ; StringListDelete( &stl ) ; return r ; }
static int _zuluCryptUnmountVolume_0( string_t st,char ** m_point ) { int h ; stringList_t stl = StringListStringSplit( st,' ' ) ; StringListIterator it = StringListBegin( stl ) ; /* * zuluCryptDecodeMountEntry() is defined in mount_volume.c */ const char * mout_point = zuluCryptDecodeMountEntry( *( it + 1 ) ) ; if( StringContains( *( it + 2 ),"fuse" ) ){ /* * Dont know whats going on but FUSE based file systems do not seem to work with umount() */ h = _unmount( _unmount_fuse,mout_point ) ; }else{ h = _unmount( _unmount_rest,mout_point ) ; } if( h == 0 && m_point != NULL ){ *m_point = StringCopy_2( mout_point ) ; } StringListDelete( &stl ) ; return h ; }
bool VersionScriptParser::Parse() { std::ifstream symbol_ifstream(version_script_); if (!symbol_ifstream.is_open()) { llvm::errs() << "Failed to open version script file\n"; return false; } std::string line = ""; while (std::getline(symbol_ifstream, line)) { // Skip comment lines. if (line.c_str()[0] == '#') { continue; } if (StringContains(line, "{")) { if ((StringContains(line, "PRIVATE"))) { continue; } ParseInnerBlock(symbol_ifstream); } } return true; }
/* ovec: command line args assumed to contain all the options for the program * options must be in the form of key= value or key=value NOT key = value * both key and value may contain spaces but they have to be quoted at the * command line for this to work */ void CmdLineOptionsToYaml(const vector<string> &ovec, Node &options) { VecS key_val_pairs; StlFor(i, ovec) { if (!StringContains(ovec[i], '=')) throw runtime_error("Unexpected token in options: " + ovec[i]); string key; string value = ""; if (StringEndsWith(ovec[i], '=')) { key = ovec[i].substr(0, ovec[i].size() - 1); if (i < ovec.size() - 1 && !StringContains(ovec[i+1], '=')) { value = ovec[i+1]; ++i; } } else // the = must be in middle like foo=bar { size_t eq_pos = ovec[i].find('='); key = ovec[i].substr(0, eq_pos); value = ovec[i].substr(eq_pos + 1); } key_val_pairs.push_back(key + ": " + value); } string yaml_str = "{" + JoinFields(key_val_pairs, ", ") + "}"; YAML::Parse(yaml_str, options); }
int Launch(int arch, int java) { PROCESS_INFORMATION pInfo; char stdMsg[] = "Attempting to run with java set for"; BOOL result = FALSE; int opt = 0; DWORD err = 0; char *cmd[2]= {"-d64 -Xms1024M -Xmx2048M -jar minecraft.jar","-Xincgc -Xmx1024M -jar minecraft.jar"}; STARTUPINFO si; ZeroMemory(&si, sizeof(si)); if (arch == 64 && java == 64) { if (StringContains(javaBinPath, "(x86)") != 1) { printf("%s 64 bit architexture", stdMsg); opt = 0; } else { //Looks like its still stuck running in 32 bit mode opt = 1; } } else if (java == 86 ) { printf("%s 86 bit architexture", stdMsg); opt = 1; } else if (java == 0 && (arch == 64 || arch == 86)) { printf("Unable to detect java\nPlease visit %s and download the appropreite version\n", JAVA_URL); return 1; } else { printf("Something is f****d!\n"); return 1; } result = CreateProcess(javaBinPath, cmd[opt], NULL, NULL, FALSE,CREATE_DEFAULT_ERROR_MODE, NULL, NULL, &si, &pInfo); if (!result) { err = GetLastError(); printf("\nSomething is f****d! Error: %X\n",err); } return 0; }
bool VersionScriptParser::ParseInnerBlock(std::ifstream &symbol_ifstream) { std::string line = ""; LineScope scope = LineScope::global; while (std::getline(symbol_ifstream, line)) { if (line.find("}") != std::string::npos) { break; } if (line.c_str()[0] == '#') { continue; } scope = GetLineScope(line, scope); if (scope != LineScope::global || StringContains(line, "global:")) { continue; } ParseSymbolLine(line); } return true; }
void DebugMenu::Add(const String& path, IAction* action) { if (StringContains(path, "/")) { std::vector<String> paths = SplitString(path, "/"); action->name = paths.back(); paths.pop_back(); PathAction* pathAction = s_Instance->CreateOrFindPaths(paths); SP_ASSERT(pathAction); if (!pathAction->ContainsAction(action->name)) pathAction->actionList.push_back(action); else spdel action; } else { s_Instance->m_ActionList.push_back(action); } s_Instance->Refresh(); }
bool VersionScriptParser::ParseSymbolLine(const std::string &line) { //The symbol lies before the ; and the tags are after ; std::string::size_type pos = line.find(";"); if (pos == std::string::npos) { llvm::errs() << "Couldn't find end of symbol" << line <<"\n"; return false; } std::string symbol = line.substr(0, pos); std::string::size_type last_space = symbol.find_last_of(' '); symbol = symbol.substr(last_space + 1, pos); std::string tags = line.substr(pos + 1); if (SymbolExported(tags, arch_, api_)) { if (StringContains(tags, "var")) { AddToVars(symbol); } else { AddToFunctions(symbol); } } return true; }
void DebugMenu::Remove(const String& path) { if (StringContains(path, "/")) { std::vector<String> paths = SplitString(path, "/"); String name = paths.back(); paths.pop_back(); PathAction* pathAction = s_Instance->CreateOrFindPaths(paths); SP_ASSERT(pathAction); if (pathAction->ContainsAction(name)) { if (pathAction->actionList.size() == 1) { PathAction* parent = pathAction->parent; if (parent) { parent->DeleteChild(pathAction); } else { for (uint i = 0; i < s_Instance->m_ActionList.size(); i++) { if (s_Instance->m_ActionList[i] == pathAction) { spdel s_Instance->m_ActionList[i]; s_Instance->m_ActionList.erase(s_Instance->m_ActionList.begin() + i); break; } } } while (parent) { spdel pathAction; pathAction = pathAction->parent; } } else { ActionList& actionList = pathAction->actionList; for (uint i = 0; i < actionList.size(); i++) { if (actionList[i]->name == name) { actionList.erase(actionList.begin() + i); break; } } } } } else { ActionList& actions = s_Instance->m_ActionList; for (uint i = 0; i < actions.size(); i++) { if (actions[i]->name == path) { spdel actions[i]; actions.erase(actions.begin() + i); break; } } } s_Instance->Refresh(); }
void Webserver::ParseClientLine() { if(StringStartsWith(clientLine, "GET")) { ParseGetPost(); postSeen = false; getSeen = true; if(!clientRequest[0]) strncpy(clientRequest, INDEX_PAGE, STRING_LENGTH); return; } if(StringStartsWith(clientLine, "POST")) { ParseGetPost(); InitialisePost(); postSeen = true; getSeen = false; if(!clientRequest[0]) strncpy(clientRequest, INDEX_PAGE, STRING_LENGTH); return; } int bnd; if(postSeen && ( (bnd = StringContains(clientLine, "boundary=")) >= 0) ) { if(strlen(&clientLine[bnd]) >= POST_LENGTH - 4) { platform->Message(HOST_MESSAGE, "Post boundary buffer overflow.\n"); return; } postBoundary[0] = '-'; postBoundary[1] = '-'; strncpy(&postBoundary[2], &clientLine[bnd], POST_LENGTH - 3); strncat(postBoundary, "--", POST_LENGTH); //Serial.print("Got boundary: "); //Serial.println(postBoundary); return; } if(receivingPost && StringStartsWith(clientLine, "Content-Disposition:")) { bnd = StringContains(clientLine, "filename=\""); if(bnd < 0) { platform->Message(HOST_MESSAGE, "Post disposition gives no filename.\n"); return; } int i = 0; while(clientLine[bnd] && clientLine[bnd] != '"') { postFileName[i++] = clientLine[bnd++]; if(i >= POST_LENGTH) { i = 0; platform->Message(HOST_MESSAGE, "Post filename buffer overflow.\n"); } } postFileName[i] = 0; //Serial.print("Got file name: "); //Serial.println(postFileName); return; } }
//=========================================================================== // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== quakefile_t *FindQuakeFilesWithPakFilter(char *pakfilter, char *filter) { #ifdef _WIN32 WIN32_FIND_DATA filedata; HWND handle; struct _stat statbuf; int done; #else glob_t globbuf; struct stat statbuf; int j; #endif quakefile_t *qfiles, *lastqf, *qf; char pakfile[_MAX_PATH], filename[_MAX_PATH], *str; qfiles = NULL; lastqf = NULL; if (pakfilter && strlen(pakfilter)) { #ifdef _WIN32 handle = FindFirstFile(pakfilter, &filedata); done = (handle == INVALID_HANDLE_VALUE); while(!done) { _splitpath(pakfilter, pakfile, NULL, NULL, NULL); _splitpath(pakfilter, NULL, &pakfile[strlen(pakfile)], NULL, NULL); AppendPathSeperator(pakfile, _MAX_PATH); strcat(pakfile, filedata.cFileName); _stat(pakfile, &statbuf); #else glob(pakfilter, 0, NULL, &globbuf); for (j = 0; j < globbuf.gl_pathc; j++) { strcpy(pakfile, globbuf.gl_pathv[j]); stat(pakfile, &statbuf); #endif //if the file with .pak or .pk3 is a folder if (statbuf.st_mode & S_IFDIR) { strcpy(filename, pakfilter); AppendPathSeperator(filename, _MAX_PATH); strcat(filename, filter); qf = FindQuakeFilesWithPakFilter(NULL, filename); if (lastqf) lastqf->next = qf; else qfiles = qf; lastqf = qf; while(lastqf->next) lastqf = lastqf->next; } //end if else { #ifdef _WIN32 str = StringContains(pakfile, ".pk3", false); #else str = StringContains(pakfile, ".pk3", true); #endif if (str && str == pakfile + strlen(pakfile) - strlen(".pk3")) { qf = FindQuakeFilesInZip(pakfile, filter); } //end if else { qf = NULL; } //end else // if (qf) { if (lastqf) lastqf->next = qf; else qfiles = qf; lastqf = qf; while(lastqf->next) lastqf = lastqf->next; } //end if } //end else // #ifdef _WIN32 //find the next file done = !FindNextFile(handle, &filedata); } //end while #else } //end for globfree(&globbuf); #endif } //end if else { #ifdef _WIN32 handle = FindFirstFile(filter, &filedata); done = (handle == INVALID_HANDLE_VALUE); while(!done) { _splitpath(filter, filename, NULL, NULL, NULL); _splitpath(filter, NULL, &filename[strlen(filename)], NULL, NULL); AppendPathSeperator(filename, _MAX_PATH); strcat(filename, filedata.cFileName); #else glob(filter, 0, NULL, &globbuf); for (j = 0; j < globbuf.gl_pathc; j++) { strcpy(filename, globbuf.gl_pathv[j]); #endif // qf = malloc(sizeof(quakefile_t)); if (!qf) Error("out of memory"); memset(qf, 0, sizeof(quakefile_t)); strcpy(qf->pakfile, ""); strcpy(qf->filename, filename); strcpy(qf->origname, filename); qf->length = 0; qf->type = QuakeFileType(filename); //add the file ot the list qf->next = NULL; if (lastqf) lastqf->next = qf; else qfiles = qf; lastqf = qf; #ifdef _WIN32 //find the next file done = !FindNextFile(handle, &filedata); } //end while #else } //end for globfree(&globbuf); #endif } //end else return qfiles; } //end of the function FindQuakeFilesWithPakFilter
//=========================================================================== // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== int FileFilter(char *filter, char *filename, int casesensitive) { char buf[1024]; char *ptr; int i, found; while(*filter) { if (*filter == '*') { filter++; for (i = 0; *filter; i++) { if (*filter == '*' || *filter == '?') break; buf[i] = *filter; filter++; } //end for buf[i] = '\0'; if (strlen(buf)) { ptr = StringContains(filename, buf, casesensitive); if (!ptr) return false; filename = ptr + strlen(buf); } //end if } //end if else if (*filter == '?') { filter++; filename++; } //end else if else if (*filter == '[' && *(filter+1) == '[') { filter++; } //end if else if (*filter == '[') { filter++; found = false; while(*filter && !found) { if (*filter == ']' && *(filter+1) != ']') break; if (*(filter+1) == '-' && *(filter+2) && (*(filter+2) != ']' || *(filter+3) == ']')) { if (casesensitive) { if (*filename >= *filter && *filename <= *(filter+2)) found = true; } //end if else { if (toupper(*filename) >= toupper(*filter) && toupper(*filename) <= toupper(*(filter+2))) found = true; } //end else filter += 3; } //end if else { if (casesensitive) { if (*filter == *filename) found = true; } //end if else { if (toupper(*filter) == toupper(*filename)) found = true; } //end else filter++; } //end else } //end while if (!found) return false; while(*filter) { if (*filter == ']' && *(filter+1) != ']') break; filter++; } //end while filter++; filename++; } //end else if else { if (casesensitive) { if (*filter != *filename) return false; } //end if else { if (toupper(*filter) != toupper(*filename)) return false; } //end else filter++; filename++; } //end else } //end while return true; } //end of the function FileFilter
static string_t set_mount_options( m_struct * mst ) { /* * zuluCryptGetMountOptionsFromFstab() is defined in parse_fstab.c */ string_t opt = zuluCryptGetMountOptionsFromFstab( mst->device,MOUNTOPTIONS,mst->uid ) ; int fsFamily = fs_family( mst->fs ) ; const char * f[] = { "nouser","users","user","defaults","noauto","auto","nodev","dev", "noexec","exec","nosuid","suid","bind","mandlock","move","noatime","nodiratime","remount","silent", "synchronous",NULL } ; const char ** z = f ; const char * e ; if( opt == StringVoid ){ opt = String( "" ) ; StringAppend( opt,mst->fs_flags ) ; }else{ if( StringContains( opt,"ro" ) ){ mst->m_flags |= MS_RDONLY ; } StringMultipleAppend( opt,",",mst->fs_flags,END ) ; } _get_file_system_options_from_config_file( mst->device,opt ) ; if( fsFamily == 1 ){ if( !StringContains( opt,"dmask=" ) ){ StringAppend( opt,",dmask=0000" ) ; } if( !StringContains( opt,"umask=" ) ){ StringAppend( opt,",umask=0000" ) ; } if( !StringContains( opt,"uid=" ) ){ StringAppend( opt,",uid=" ) ; StringAppendInt( opt,mst->uid ) ; } if( !StringContains( opt,"gid=" ) ){ StringAppend( opt,",gid=" ) ; StringAppendInt( opt,mst->uid ) ; } if( !StringContains( opt,"fmask=" ) ){ StringAppend( opt,",fmask=0111" ) ; } if( StringsAreEqual( mst->fs,"vfat" ) ){ if( !StringContains( opt,"flush" ) ){ StringAppend( opt,",flush" ) ; } if( !StringContains( opt,"shortname=" ) ){ StringAppend( opt,",shortname=mixed" ) ; } } }else if( fsFamily == 2 ){ if( !StringContains( opt,"uid=" ) ){ StringAppend( opt,",uid=" ) ; StringAppendInt( opt,mst->uid ) ; } if( !StringContains( opt,"gid=" ) ){ StringAppend( opt,",gid=" ) ; StringAppendInt( opt,mst->uid ) ; } }else if( fsFamily == 3 ){ mst->m_flags |= MS_RDONLY ; }else{ /* * ext file systems and raiserfs among others go here * we dont set any options for them. */ ; } /* * remove mount options to leave only file system options */ while( 1 ){ e = *z ; z++ ; if( e == NULL ){ break ; }else{ StringRemoveString( opt,e ) ; } } /* * remove below two now because we are going to add them below,reason for removing them * and readding them is because we want to make sure they are at the beginning of the string */ StringRemoveString( opt,"ro" ) ; StringRemoveString( opt,"rw" ) ; if( mst->m_flags & MS_RDONLY ){ StringPrepend( opt,"ro," ) ; }else{ StringPrepend( opt,"rw," ) ; } mst->opts = _remove_duplicates( opt ) ; return opt; }
int main(int argc, char* argv[]) { for(int b = 1; b < argc; b++) { if(strcmp(argv[b], "--help") == 0) { return PrintHelp(); } } for(int a = 1; a < argc; a++) { if(strcmp(argv[a], "-b") == 0) { a++; if(a < argc) { back = std::stoi(argv[a]); } } else if(strcmp(argv[a], "-f") == 0) { a++; if(a < argc) { front = std::stoi(argv[a]); front++; } } else if(strcmp(argv[a], "-l") == 0) { line = true; } else { argz.push_back(argv[a]); } } //If front and back numbers are set, keep file into memory. if((front > 0) or (back > 0)) { keep = true; } if(argz.size() < 2) { printf("No file or not enough words.\n"); return PrintHelp(); } //Load first file. std::ifstream tfstream(argz[0]); if(tfstream.is_open()) { size_t file_index = -1; std::string temptxt; while(std::getline(tfstream, temptxt)) { file_index++; if(StringContains(temptxt, argz[1])) { index_l.push_back(file_index); lines.push_back(temptxt); } if(keep) { file_v.push_back(temptxt); } } tfstream.close(); } else { std::cout << "No such file '" << argz[0] << "'." << std::endl; return 1; } //Erase first two values. argz.erase(argz.begin(), argz.begin() + 1); //Remove and duplicate search items. std::sort(argz.begin(), argz.end()); argz.erase(std::unique(argz.begin(), argz.end()), argz.end()); if(!argz.empty()) { //Go through each arg and then for(const std::string &arg : argz) { std::vector<std::string> temp_v; std::vector<size_t> temp_v_index; for(size_t line_index = 0; line_index < lines.size(); line_index++) { if(StringContains(lines[line_index], arg)) { temp_v.push_back(lines[line_index]); temp_v_index.push_back(index_l[line_index]); } } lines = temp_v; index_l = temp_v_index; if(lines.empty()) { return 0; } } } for(size_t z = 0; z < index_l.size(); z++) { size_t f_index = -1; size_t b_index = -1; if(keep) { f_index = index_l[z] + front; b_index = index_l[z] - back; if(b_index < 0) { b_index = 0; } if(f_index > file_v.size()) { f_index = file_v.size(); f_index--; } } if(b_index != -1) { for(size_t t = b_index; t < index_l[z]; t++) { pline(t, file_v[t]); } } pline(index_l[z], lines[z]); if(f_index != -1) { bool first = true; //Weird hack required for a line skip. for(size_t t = index_l[z]; t < f_index; t++) { if(first) { first = false; } else { pline(t, file_v[t]); } } } if(keep) { printf("\n"); } } return 0; }