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);
}
