bool ValidateRegEx(const char *regex) { pcre *rx = CompileRegex(regex); bool regex_valid = rx != NULL; pcre_free(rx); return regex_valid; }
Rlist *RlistFromSplitRegex(const char *string, const char *regex, size_t max_entries, bool allow_blanks) { assert(string); if (!string) { return NULL; } const char *sp = string; size_t entry_count = 0; int start = 0; int end = 0; Rlist *result = NULL; Buffer *buffer = BufferNewWithCapacity(CF_MAXVARSIZE); pcre *rx = CompileRegex(regex); if (rx) { while ((entry_count < max_entries) && StringMatchWithPrecompiledRegex(rx, sp, &start, &end)) { if (end == 0) { break; } BufferClear(buffer); BufferAppend(buffer, sp, start); if (allow_blanks || BufferSize(buffer) > 0) { RlistAppendScalar(&result, BufferData(buffer)); entry_count++; } sp += end; } pcre_free(rx); } if (entry_count < max_entries) { BufferClear(buffer); size_t remaining = strlen(sp); BufferAppend(buffer, sp, remaining); if ((allow_blanks && sp != string) || BufferSize(buffer) > 0) { RlistAppendScalar(&result, BufferData(buffer)); } } BufferDestroy(buffer); return result; }
Item *SelectProcesses(const Item *processes, const char *process_name, ProcessSelect a, bool attrselect) { Item *result = NULL; if (processes == NULL) { return result; } char *names[CF_PROCCOLS]; int start[CF_PROCCOLS]; int end[CF_PROCCOLS]; GetProcessColumnNames(processes->name, &names[0], start, end); pcre *rx = CompileRegex(process_name); if (rx) { for (Item *ip = processes->next; ip != NULL; ip = ip->next) { int s, e; if (StringMatchWithPrecompiledRegex(rx, ip->name, &s, &e)) { if (NULL_OR_EMPTY(ip->name)) { continue; } if (attrselect && !SelectProcess(ip->name, names, start, end, a)) { continue; } pid_t pid = ExtractPid(ip->name, names, end); if (pid == -1) { Log(LOG_LEVEL_VERBOSE, "Unable to extract pid while looking for %s", process_name); continue; } PrependItem(&result, ip->name, ""); result->counter = (int)pid; } } pcre_free(rx); } for (int i = 0; i < CF_PROCCOLS; i++) { free(names[i]); } return result; }
static bool IsValidVariableName(const char *var_name) { // must be removed at some point (global), but for now this offers an attractive speedup static pcre *rx = NULL; if (!rx) { rx = CompileRegex("[a-zA-Z0-9_\200-\377.]+(\\[.+\\])*"); } return StringMatchFullWithPrecompiledRegex(rx, var_name); }
static bool IsValidVariableName(const char *var_name) { /* TODO: remove at some point (global, leaked), but for now * this offers an attractive speedup. */ static pcre *rx = NULL; if (!rx) { rx = CompileRegex("[a-zA-Z0-9_\200-\377.]+(\\[.+\\])*"); /* Known leak, see TODO. */ } return StringMatchFullWithPrecompiledRegex(rx, var_name); }
bool StringMatchFull(const char *regex, const char *str) { pcre *pattern = CompileRegex(regex); if (pattern == NULL) { return false; } bool ret = StringMatchFullWithPrecompiledRegex(pattern, str); pcre_free(pattern); return ret; }
bool StringMatch(const char *regex, const char *str, int *start, int *end) { pcre *pattern = CompileRegex(regex); if (pattern == NULL) { return false; } bool ret = StringMatchWithPrecompiledRegex(pattern, str, start, end); pcre_free(pattern); return ret; }
int BlockTextMatch(EvalContext *ctx, const char *regexp, const char *teststring, int *start, int *end) { pcre *rx = CompileRegex(regexp); if (rx == NULL) { return 0; } if (RegExMatchSubString(ctx, rx, teststring, start, end)) { return true; } else { return false; } }
/* * Splits string on regex, returns a list of (at most max) fragments. * * NOTE: in contrast with RlistFromSplitRegex() this one will produce at most max number of elements; * last element will contain everything that lefts from original string (we use everything after * the (max-1)-th separator as the final list element, including any separators that may be embedded in it) */ Rlist *RlistFromRegexSplitNoOverflow(const char *string, const char *regex, int max) { Rlist *liststart = NULL; char node[CF_MAXVARSIZE]; int start, end; int count = 0; assert(max > 0); // ensured by FnCallStringSplit() before calling us assert(string != NULL); // ensured by FnCallStringSplit() before calling us const char *sp = string; // We will avoid compiling regex multiple times. pcre *pattern = CompileRegex(regex); if (pattern == NULL) { Log(LOG_LEVEL_DEBUG, "Error compiling regex from '%s'", regex); return NULL; } while (count < max - 1 && StringMatchWithPrecompiledRegex(pattern, sp, &start, &end)) { assert(start < CF_MAXVARSIZE); memcpy(node, sp, start); node[start] = '\0'; RlistAppendScalar(&liststart, node); count++; sp += end; } assert(count < max); RlistAppendScalar(&liststart, sp); pcre_free(pattern); return liststart; }
Class *ClassTableMatch(const ClassTable *table, const char *regex) { ClassTableIterator *it = ClassTableIteratorNew(table, NULL, true, true); Class *cls = NULL; pcre *pattern = CompileRegex(regex); if (pattern == NULL) { // TODO: perhaps pcre has can give more info on this error? Log(LOG_LEVEL_ERR, "Unable to pcre compile regex '%s'", regex); return false; } while ((cls = ClassTableIteratorNext(it))) { bool matched; if (cls->ns) { char *class_expr = ClassRefToString(cls->ns, cls->name); matched = StringMatchFullWithPrecompiledRegex(pattern, class_expr); free(class_expr); } else { matched = StringMatchFullWithPrecompiledRegex(pattern, cls->name); } if (matched) { break; } } pcre_free(pattern); ClassTableIteratorDestroy(it); return cls; }
int FullTextMatch(EvalContext *ctx, const char *regexp, const char *teststring) { pcre *rx; if (strcmp(regexp, teststring) == 0) { return true; } rx = CompileRegex(regexp); if (rx == NULL) { return false; } if (RegExMatchFullString(ctx, rx, teststring)) { return true; } else { return false; } }
/* * Format of passwd file on AIX is: * * user1: * password = hash * lastupdate = 12783612 * user2: * password = hash * lastupdate = 12783612 * <...> */ static bool GetAIXShadowHash(const char *puser, const char **result) { FILE *fptr = fopen("/etc/security/passwd", "r"); if (fptr == NULL) { return false; } // Not super pretty with a static variable, but it is how POSIX functions // getspnam() and friends do it. static char hash_buf[CF_BUFSIZE]; bool ret = false; char *buf = NULL; size_t bufsize = 0; size_t puser_len = strlen(puser); char name_regex_str[strlen(puser) + 3]; pcre *name_regex = CompileRegex("^(\\S+):"); pcre *hash_regex = CompileRegex("^\\s+password\\s*=\\s*(\\S+)"); bool in_user_section = false; while (true) { ssize_t read_result = CfReadLine(&buf, &bufsize, fptr); if (read_result < 0) { if (feof(fptr)) { errno = 0; } goto end; } int submatch_vec[6]; int pcre_result = pcre_exec(name_regex, NULL, buf, strlen(buf), 0, 0, submatch_vec, 6); if (pcre_result >= 0) { if (submatch_vec[3] - submatch_vec[2] == puser_len && strncmp(buf + submatch_vec[2], puser, puser_len) == 0) { in_user_section = true; } else { in_user_section = false; } continue; } else if (pcre_result != PCRE_ERROR_NOMATCH) { errno = EINVAL; goto end; } if (!in_user_section) { continue; } pcre_result = pcre_exec(hash_regex, NULL, buf, strlen(buf), 0, 0, submatch_vec, 6); if (pcre_result >= 0) { memcpy(hash_buf, buf + submatch_vec[2], submatch_vec[3] - submatch_vec[2]); *result = hash_buf; ret = true; goto end; } else if (pcre_result != PCRE_ERROR_NOMATCH) { errno = EINVAL; goto end; } } end: pcre_free(name_regex); pcre_free(hash_regex); free(buf); fclose(fptr); return ret; }
// === CODE === int main(int argc, char *argv[]) { setbuf(stdin, NULL); setbuf(stdout, NULL); // $X $Y $DIRECTION [$MULTIPLIER=1] $OUTCOME CompileRegex(&gRegex_move, "([0-9]+) ([0-9]+) ([A-Z]+)( [0-9]+)? (.*)", REG_EXTENDED); // (KILLS|DIES|BOTHDIE) $ATTACKER_RANK $DEFENDER_RANK CompileRegex(&gRegex_res, "([A-Z_]+) (.) (.)", REG_EXTENDED); { int colour_id; char colour[6]; char opponent[128]; fscanf(stdin, "%s %s %i %i", colour, opponent, &giBoardWidth, &giBoardHeight); if( strcmp(colour, "RED") == 0 ) colour_id = COLOUR_RED; else if( strcmp(colour, "BLUE") == 0 ) colour_id = COLOUR_BLUE; else { fprintf(stderr, "Oops... nutty manager, colour = %s\n", colour); colour_id = COLOUR_RED; } DEBUG("colour=%i, opponent='%s', dims = %ix%i", colour_id, opponent, giBoardWidth, giBoardHeight); AI_Initialise(colour_id, opponent); } gaBoardState = malloc(giBoardWidth*giBoardHeight); for( ;; ) { tMove mymove, opponent_move; char line[32]; // DEBUG("Waiting for move"); ASSERT( fgets(line, sizeof(line), stdin) != NULL ); // DEBUG("pm line = '%s'", line); if( strcmp(line, "\n") == 0 ) continue ; if( strcmp(line, "START\n") == 0 ) { // DEBUG("New game"); ReadBoardState(stdin, gaBoardState); // TODO: Check if this hasn't happened before opponent_move.x = 0; opponent_move.y = 0; opponent_move.dist = 0; opponent_move.dir = 0; } else if( strncmp(line, "QUIT", 4) == 0 ) { // TODO: Result? break ; } else if( strcmp(line, "VICTORY_FLAG\n") == 0 ) { // I win! break; } else { // DEBUG("GetMove"); GetMove(line, &opponent_move); // DEBUG("Read board state"); ReadBoardState(stdin, gaBoardState); } DEBUG("Opposing move %i,%i dir %i dist %i", opponent_move.x, opponent_move.y, opponent_move.dir, opponent_move.dist); // Silly opponent, you lost if( opponent_move.result == RESULT_VICTORY ) break; // Determine move AI_HandleMove(0, &opponent_move); AI_DoMove(&mymove); DEBUG("Chose move %i,%i %i %i", mymove.x, mymove.y, mymove.dir, mymove.dist); printf("%i %i %s %i\n", mymove.x, mymove.y, DIR_NAMES[mymove.dir], mymove.dist); // Get result of the move ASSERT( fgets(line, sizeof(line), stdin) != NULL ); // DEBUG("res line = '%s'", line); // GetMove(line, &mymove); AI_HandleMove(1, &mymove); // I WON! if( mymove.result == RESULT_VICTORY ) break; // DEBUG("Move over"); } return 0; }
int DeleteItemGeneral(Item **list, const char *string, ItemMatchType type) { if (list == NULL) { return false; } pcre *rx = NULL; if (type == ITEM_MATCH_TYPE_REGEX_COMPLETE_NOT || type == ITEM_MATCH_TYPE_REGEX_COMPLETE) { rx = CompileRegex(string); if (!rx) { return false; } } Item *ip = *list, *last = NULL; CYCLE_DECLARE(ip, slow, toggle); while (ip != NULL) { if (ip->name != NULL) { bool match = false, flip = false; switch (type) { case ITEM_MATCH_TYPE_LITERAL_START_NOT: flip = true; /* and fall through */ case ITEM_MATCH_TYPE_LITERAL_START: match = (strncmp(ip->name, string, strlen(string)) == 0); break; case ITEM_MATCH_TYPE_LITERAL_COMPLETE_NOT: flip = true; /* and fall through */ case ITEM_MATCH_TYPE_LITERAL_COMPLETE: match = (strcmp(ip->name, string) == 0); break; case ITEM_MATCH_TYPE_LITERAL_SOMEWHERE_NOT: flip = true; /* and fall through */ case ITEM_MATCH_TYPE_LITERAL_SOMEWHERE: match = (strstr(ip->name, string) != NULL); break; case ITEM_MATCH_TYPE_REGEX_COMPLETE_NOT: flip = true; /* and fall through */ case ITEM_MATCH_TYPE_REGEX_COMPLETE: match = StringMatchFullWithPrecompiledRegex(rx, ip->name); break; } if (flip) { match = !match; } if (match) { if (ip == *list) { *list = ip->next; } else { assert(ip != NULL); assert(last != NULL); assert(last->next == ip); last->next = ip->next; } free(ip->name); free(ip->classes); free(ip); if (rx) { pcre_free(rx); } return true; } } last = ip; ip = ip->next; CYCLE_CHECK(ip, slow, toggle); } if (rx) { pcre_free(rx); } return false; }