static int xstrcmp(char *mask,char *text) { if(!is_pattern(mask)) return ((strcmp(mask,text)==0) ? 1 : 0); return match(mask,text); }
/*----------------------------------------------------------- * ParseNonTerminal * Cat the pattern on next terminal and * move the s pointer together and stop on next terminal *-----------------------------------------------------------*/ static void ParseNonTerminal(s_token *token_p, bool skip) { char *index; token_p->tt = T_EXP; if (skip==false) { /* expression is not in skip mode */ token_p->has_patterns=false; /* the pattern detected */ index = token_p->pattern; /* skip first test, allready tested */ while (index==token_p->pattern || indexOfTerminal(token_p->s[0])==-1) { if (token_p->has_patterns==false && is_pattern(token_p->s[0])) { token_p->has_patterns=true; /* the pattern detected */ } switch (token_p->type){ case TYPE_CSTR: case TYPE_HOST: index[0]=tolower(token_p->s[0]); break; default: index[0]=token_p->s[0]; } index++; token_p->s++; } index[0]='\0'; /*terminate pattern copy */ } else { while (indexOfTerminal(token_p->s[0])==-1) { token_p->s++; } } }
/** * @brief Predicate for a g_hash_table_find, true if pattern [key] matches * @brief hostname [userdata]. * * @param key_pattern Key of a hashtable (callback), interpreted to be a pattern * to match hostname against. * @param value_login Value of a hashtable (callback). * @param hostname Userdata, hostname to match pattern against. * * @return TRUE if key_pattern (glob-style, ? and * allowed) matches hostname. */ static gboolean pattern_matches (char *key_pattern, char *value_login, char *hostname) { #ifndef NDEBUG printf ("SSH-DEBUG: Testing if %s is pattern\n", key_pattern); #endif if (is_pattern (key_pattern) == FALSE) return FALSE; #ifndef NDEBUG printf ("SSH-DEBUG: Testing Pattern %s against %s\n", key_pattern, hostname); #endif if (g_pattern_match_simple (key_pattern, hostname) == TRUE) return TRUE; return FALSE; }
void glob(Array *array, std::vector<CharArray> &segments, size_t i, CharArray path) { auto join_path = [&](CharArray filename) -> CharArray { if(path.size()) return path + "/" + filename; else return filename; }; while((i < segments.size() - 1) && !is_pattern(segments[i])) { path = join_path(segments[i]); i++; } if(segments[i] == "**" && (i + 1 < segments.size())) { Platform::list_dir(File::expand_path(path), true, [&](const CharArray &filename, bool directory) { if(directory) glob(array, segments, i, join_path(filename)); }); glob(array, segments, i + 1, path); } else if(i + 1 < segments.size()) { Platform::list_dir(File::expand_path(path), true, [&](const CharArray &filename, bool directory) { if(directory && File::fnmatch(filename, segments[i])) glob(array, segments, i + 1, join_path(filename)); }); } else { Platform::list_dir(File::expand_path(path), true, [&](const CharArray &filename, bool) { if(File::fnmatch(filename, segments[i])) array->vector.push(String::get(join_path(filename))); }); } }
static int read_pages(struct ksm_pages *kp, pm_map_t **maps, size_t num_maps, uint8_t pr_flags) { size_t i, j, k; size_t len; uint64_t *pagemap; size_t map_len; uint64_t flags; pm_kernel_t *ker; int error; unsigned long vaddr; int fd; off_t off; char filename[MAX_FILENAME]; uint32_t *data; uint32_t hash; int rc = 0; struct ksm_page *cur_page; pid_t pid; if (num_maps == 0) return 0; pid = pm_process_pid(maps[0]->proc); ker = maps[0]->proc->ker; error = snprintf(filename, MAX_FILENAME, "/proc/%d/mem", pid); if (error < 0 || error >= MAX_FILENAME) { return -1; } data = malloc(pm_kernel_pagesize(ker)); if (data == NULL) { fprintf(stderr, "warning: not enough memory to malloc data buffer\n"); return -1; } fd = open(filename, O_RDONLY); if (fd < 0) { fprintf(stderr, "warning: could not open %s\n", filename); rc = -1; goto err_open; } for (i = 0; i < num_maps; i++) { error = pm_map_pagemap(maps[i], &pagemap, &map_len); if (error) { fprintf(stderr, "warning: could not read the pagemap of %d\n", pm_process_pid(maps[i]->proc)); continue; } for (j = 0; j < map_len; j++) { error = pm_kernel_flags(ker, PM_PAGEMAP_PFN(pagemap[j]), &flags); if (error) { fprintf(stderr, "warning: could not read flags for pfn at address 0x%016" PRIx64 "\n", pagemap[i]); continue; } if (!(flags & PM_PAGE_KSM)) { continue; } vaddr = pm_map_start(maps[i]) + j * pm_kernel_pagesize(ker); off = lseek(fd, vaddr, SEEK_SET); if (off == (off_t)-1) { fprintf(stderr, "warning: could not lseek to 0x%08lx\n", vaddr); continue; } len = read(fd, data, pm_kernel_pagesize(ker)); if (len != pm_kernel_pagesize(ker)) { fprintf(stderr, "warning: could not read page at 0x%08lx\n", vaddr); continue; } hash = hashword(data, pm_kernel_pagesize(ker) / sizeof(*data), 17); for (k = 0; k < kp->len; k++) { if (kp->pages[k].hash == hash) break; } if (k == kp->len) { if (kp->len == kp->size) { struct ksm_page *tmp = realloc(kp->pages, (kp->size + GROWTH_FACTOR) * sizeof(*kp->pages)); if (tmp == NULL) { fprintf(stderr, "warning: not enough memory to realloc pages struct\n"); free(pagemap); rc = -1; goto err_realloc; } memset(&tmp[k], 0, sizeof(tmp[k]) * GROWTH_FACTOR); kp->pages = tmp; kp->size += GROWTH_FACTOR; } rc = pm_kernel_count(ker, PM_PAGEMAP_PFN(pagemap[j]), &kp->pages[kp->len].count); if (rc) { fprintf(stderr, "error reading page count\n"); free(pagemap); goto err_count; } kp->pages[kp->len].hash = hash; kp->pages[kp->len].pattern = is_pattern((uint8_t *)data, pm_kernel_pagesize(ker)) ? (data[0] & 0xFF) : NO_PATTERN; kp->len++; } cur_page = &kp->pages[k]; if (pr_flags & PR_VERBOSE) { if (cur_page->vaddr_len > 0 && cur_page->vaddr[cur_page->vaddr_len - 1].pid == pid && cur_page->vaddr[cur_page->vaddr_len - 1].addr == vaddr - (cur_page->vaddr[cur_page->vaddr_len - 1].num_pages * pm_kernel_pagesize(ker))) { cur_page->vaddr[cur_page->vaddr_len - 1].num_pages++; } else { if (cur_page->vaddr_len == cur_page->vaddr_size) { struct vaddr *tmp = realloc(cur_page->vaddr, (cur_page->vaddr_size + GROWTH_FACTOR) * sizeof(*(cur_page->vaddr))); if (tmp == NULL) { fprintf(stderr, "warning: not enough memory to realloc vaddr array\n"); free(pagemap); rc = -1; goto err_realloc; } memset(&tmp[cur_page->vaddr_len], 0, sizeof(tmp[cur_page->vaddr_len]) * GROWTH_FACTOR); cur_page->vaddr = tmp; cur_page->vaddr_size += GROWTH_FACTOR; } cur_page->vaddr[cur_page->vaddr_len].addr = vaddr; cur_page->vaddr[cur_page->vaddr_len].num_pages = 1; cur_page->vaddr[cur_page->vaddr_len].pid = pid; cur_page->vaddr_len++; } } cur_page->vaddr_count++; } free(pagemap); } goto no_err; err_realloc: err_count: if (pr_flags & PR_VERBOSE) { for (i = 0; i < kp->len; i++) { free(kp->pages[i].vaddr); } } free(kp->pages); no_err: close(fd); err_open: free(data); return rc; }
// ************************************************************************************************ // Procédure principale. // ************************************************************************************************ int main(int argc,char *argv[]) { int touche=0; int erreurpattern=0; FILE *in; if(strcmp(argv[1],"-H")==0 or strcmp(argv[1],"/?")==0 or strcmp(argv[1],"?")==0 or strcmp(argv[1],"-HELP")==0 or argc<2) { printf("RegExp par Herve Thouzard Version 1.0 - 1997 °±² FREEWARE ²±°\n"); printf("Utilisation : REGEXP expression_r‚guliŠre fichier\n"); printf("Si vous ne pr‚cisez pas de fichier, le clavier sera pris comme entr‚e\npar d‚faut.\n"); printf("Vous disposez des caractŠres suivants pour composer des expressions\n" "r‚guliŠres :\n\n" " * Recherchera de 0 … N caractŠres.\n" " ? Recherchera 1 et 1 seul caractŠre. N'importe lequel.\n" " [azer] Recherchera 'a' ou 'z' ou 'e' ou 'r'.\n" " [!aze] Recherchera tout sauf 'a', 'z' et 'e'.\n\n"); printf("Les expressions entre crochets, peuvent ˆtre constitu‚s de s‚ries de lettres\n" "mais peuvent aussi contenir des indications de suites. Par exemple [a-m]\n" "indique au programme de choisir toutes les lettres allant de 'a' … 'm'\n" "(abcdefghijklm). On peut aussi faire [0-9A-Z] pour avoir :\n" "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ.\n\n"); touche=getch(); if(touche==27 or touche==113 or touche==81) exit(1); printf("Quelques exemples d'expressions r‚guliŠres :\n\n" " [t-w]??D*S Rechercher tout ce qui commence par 't' ou 'u' ou 'v' ou\n" " 'w', et qui contient aprŠs, deux lettres (peut importe\n" " lesquelles) qui est suivi par la lettre D, puis qui a un\n" " nombre quelconque de caractŠres. On pr‚cise enfin, que\n" " le mot doit se terminer par 'S'\n\n" " [t-w]??D*[G-T] Rechercher tout ce qui commence par 't' ou 'u' ou 'v' ou\n" " 'w', et qui contient aprŠs, deux lettres (peut importe\n" " lesquelles) qui est suivi par la lettre D, puis qui a un\n" " un nombre quelconque de caractŠres et qui se termine par\n" " les lettres 'g' ou 'h' ou 'i' ou 'j' .... jusqu'… 't'\n\n"); touche=getch(); if(touche==27 or touche==113 or touche==81) exit(1); printf("regexp W* Rechercher tout ce qui commence par W et qui contient\n" " ensuite un nombre quelconque de lettres. Cela peut ˆtre\n" " tout simplement la lettre 'W'.\n\n" " ??????? On demande de rechercher tous ce qui fait de 0 … 6\n" " caractŠres. WINDOWS en fait partie, ainsi que 'LETTRE'\n\n" " windo[!a-r] Rechercher tout ce qui commence par 'window' et qui ne\n" " se termine pas par les lettres allant de 'a' … 'r'.\n\n" " w*d*s Rechercher tout ce qui commence par 'w' et qui se\n" " termine par 's' et qui contient entre les deux (peut\n" " importe o—) la lettre 'd'.\n\n" " win[a-f]ows Rechercher tout ce qui commence par 'win' puis qui\n" " contient soit 'a' soit 'b' soit 'c' .... jusqu'…\n" " 'f' et qui se termine par 'ows'.\n\n" " win[abcdef]ows Mˆme exemple que pr‚c‚demment mais formul‚ autrement.\n\n" " w*s Recherche tout ce qui commence par 'w' et fini par 's'\n"); printf("\n\nQuelques exemples d'utilisation :\n\n"); printf("dir/b | regexp [!M]* ==> Affiche tous les fichiers qui ne commencent\n"); printf(" pas par M.\n"); printf("type autoexec.bat | regexp *SET* ==> Affiche toutes les lignes du fichier\n"); printf(" autoexec.bat qui contiennent un mot\n"); printf(" contenant 'SET'\n"); printf("on peut aussi faire regexp [!M]* autoexec.bat\n"); return(1); } if(argc==2) // On prend le clavier comme entrée standard. { in=stdin; } if(argc==3) // On a spécifié un fichier, donc, on le prend. { if((in=fopen(argv[2],"rt"))==NULL) { fprintf(stderr,"Erreur, Impossible d'ouvrir le fichier \"%s\".\n",argv[2]); exit(2); } } // On récupère l'expression régulière dans une variable de travail. // et on test la validité de l'expression. strcpy(expression,argv[1]); if(!is_pattern(expression)) { printf("%s n'est pas une expression r‚guliŠre.\n",expression); exit(3); } if(is_valid_pattern(expression,&erreurpattern)!=TRUE) { printf("D‚sol‚, mais votre expression r‚guliŠre n'est pas correcte !\n"); switch(erreurpattern) { case MATCH_LITERAL: printf("\tProblŠme sur un litt‚ral\n"); exit(4); case MATCH_RANGE: printf("\tProblŠme sur une construction du type [..]\n"); exit(4); case MATCH_ABORT: printf("\tProblŠme sur la fin du texte de l'expression\n"); exit(4); case MATCH_END: printf("\tProblŠme sur la fin de l'expression\n"); exit(4); case MATCH_PATTERN: switch(erreurpattern) { case PATTERN_ESC: printf("\tProblŠme avec une s‚quence d'‚chappement … la fin de l'expression\n"); exit(4); case PATTERN_RANGE: printf("\tProblŠme, pas de fin de limite dans la construction [..]\n"); exit(4); case PATTERN_CLOSE: printf("\tProblŠme, la construction est ouverte [..]\n"); exit(4); case PATTERN_EMPTY: printf("\tProblŠme, la construction [..] est vide.\n"); exit(4); default: printf("\tProblŠme interne avec la procedure is_valid_pattern()\n"); exit(4); } break; default: printf("ProblŠme, erreur interne avec la procedure matche()\n"); exit(4); } // ******************************************************************************************** } // printf("Expression recherchee :%s:\n",expression); fgets(ligne,30000,in); while(!feof(in)) { if(match(expression,ligne)==TRUE) printf("%s",ligne); fgets(ligne,30000,in); } fclose(in); return(0); }