ANTICHAT — форум по информационной безопасности, OSINT и технологиям

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <glib.h>


typedef void (*LPSEARCHFUNC)(LPCTSTR lpszFileName);
BOOL SearchFiles(
        LPCTSTR lpszFileName,                
        LPSEARCHFUNC lpSearchFunc,           
        BOOL bInnerFolders );     
                                            

char file[MAX_PATH];

BOOL SearchFiles(LPCTSTR lpszFileName, LPSEARCHFUNC lpSearchFunc, BOOL bInnerFolders)
{
    LPTSTR part;
   char tmp[MAX_PATH]; // временный массив
    char name[MAX_PATH];

   HANDLE hSearch = NULL;
   WIN32_FIND_DATA wfd;
    memset(&wfd, 0, sizeof(WIN32_FIND_DATA));

    // сначало поиск внутри вложенных папках ...
    if(bInnerFolders)
    {
        if(GetFullPathName(lpszFileName, MAX_PATH, tmp, &part) == 0) return FALSE;
        strcpy(name, part);
        strcpy(part, "*.*");

        // если папки существуют, то делаем поиск
        wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
        if (!((hSearch = FindFirstFile(tmp, &wfd)) == INVALID_HANDLE_VALUE))
        do
        {
            // в каждой папке есть две папки с именами "." и ".."
            // и эти папки мы не трогаем

            // пропускаем папки "." и ".."
            if (!strncmp(wfd.cFileName, ".", 1) || !strncmp(wfd.cFileName, "..", 2))            
           continue;
       
            if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) // если мы нашли папку
            {
                char next[MAX_PATH];
                if(GetFullPathName(lpszFileName, MAX_PATH, next, &part) == 0) return FALSE;
                strcpy(part, wfd.cFileName);
                strcat(next, "\\");
                strcat(next, name);

                SearchFiles(next, lpSearchFunc, TRUE);
            }
        }
        while (FindNextFile(hSearch, &wfd)); // ищем следующий файл

        FindClose (hSearch); // заканчиваем поиск
    }

   if ((hSearch = FindFirstFile(lpszFileName, &wfd)) == INVALID_HANDLE_VALUE) 
       return TRUE; // в противном случае выходим
   do
   if (!(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) // если мы нашли файл
   {
        if(GetFullPathName(lpszFileName, MAX_PATH, file, &part) == 0) return FALSE;
        strcpy(part, wfd.cFileName);

        lpSearchFunc(file);
   }
   while (FindNextFile(hSearch, &wfd)); // ищем следующий файл
   FindClose (hSearch); // заканчиваем поиск

    return TRUE;
}

int yes;
char entries;
int entriesf;
int failopen;
int all_files;
int except;

static void
print_ip(const gchar *string);

void __cdecl show_info()
{
	int len, ret;
	char *cv, *pfmt;
	pfmt = strrchr(file, '\\');
	if (!pfmt)
		__asm int 3;
	len = _scprintf("f %d s %d a %d x %d %s", failopen, yes, all_files, except, pfmt);
	if (-1 == len)
		__asm int 3;
	cv = malloc(len + 1);
	if (!cv)
		__asm int 3;
	ret = sprintf(cv, "f %d s %d a %d x %d %s", failopen, yes, all_files, except, pfmt);
	if (-1 == ret)
		__asm int 3;
	ret = SetConsoleTitle(cv);
	if (!ret)
		__asm int 3;
	free(cv);
}

void DoSomething(LPCTSTR name)
{
	HANDLE hFile = INVALID_HANDLE_VALUE, hMap = NULL;
	DWORD dwFileSize;
	CHAR *base = NULL;
	show_info(++all_files);
	__try
	{
		hFile = CreateFile(name, GENERIC_READ,
			FILE_SHARE_READ, NULL, OPEN_EXISTING,
			FILE_ATTRIBUTE_NORMAL, NULL);
		if (hFile == INVALID_HANDLE_VALUE)
		{
			show_info(++failopen);
			__leave;
		}
		dwFileSize = GetFileSize(hFile, NULL);
		if (dwFileSize == INVALID_FILE_SIZE)
			__leave;
		hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, dwFileSize, NULL);
	    if (!hMap)
			__leave;
		base = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, dwFileSize);
	    if (!base)
			__leave;
		
		print_ip(base);
	}
	__finally
	{
		if (base)
			UnmapViewOfFile(base);
		if (hMap)
			CloseHandle(hMap);
		if (hFile != INVALID_HANDLE_VALUE)
			CloseHandle(hFile);
	}
	if (entriesf && entries == 'y')
	{
		puts(name);
		entriesf ^= entriesf;
	}
	return;
}

#define _124KB 126976
static char regexp[_124KB];

static void
print_ip(const gchar *string)
{
  GRegex *regex;
  GMatchInfo *match_info;
     
  regex = g_regex_new (regexp, 0, 0, NULL);
  __try
    {
	  g_regex_match (regex, string, 0, &match_info);
    }
  __except(EXCEPTION_EXECUTE_HANDLER)
    {
	  show_info(++except);
	  g_regex_unref(regex);
	  return;
    }
  while (g_match_info_matches (match_info))
    {
      gchar *word = g_match_info_fetch (match_info, 0);
      g_print ("%s\n", word);
      g_free (word);
      g_match_info_next (match_info, NULL);
	  entriesf = 1;
	  show_info(++yes);
    }
  g_match_info_free (match_info);
  g_regex_unref (regex);
}

int main(void)
{
	printf("echo entries (y/n) -> ");
	scanf("%c", &entries);
	fflush(stdin);
	printf("enter regexp -> ");
	gets(regexp);
	SearchFiles("C:\\*.*", DoSomething, TRUE);
}

std::string hello = "Hello World!";
replace(hello, "o", "_");
std::cout << hello << "\n";
выведет: Hell_ W_rld!

и ещё

std::string hello = "Hello Worlld!";
replace(hello, "ll", "$");
std::cout << hello << "\n";
выведет: He$o Wor$d!

#include <iostream>
#include <string>

void replace (std::string& source, std::string findWhat, std::string replaceWith) {
    if (source == "" || findWhat == "")
        return;
    if (source == findWhat) {
        source = replaceWith;
        return;
    }
    size_t findWhatIndex = 0;
    size_t startIndex = 0;
    size_t findLength = findWhat.length();
    bool flag = false;
    for (size_t i = 0; i < source.length(); i++) {
        if (flag) {
            if (source.at(i) == findWhat.at(findWhatIndex) && findWhatIndex < (findLength - 1))
                ++findWhatIndex;
            else if (source.at(i) == findWhat.at(findWhatIndex) && findWhatIndex == (findLength - 1)) {
                source = source.replace(startIndex, findLength, replaceWith);
                findWhatIndex = 0;
                startIndex = 0;
                flag = false;
            }
            else {
                findWhatIndex = 0;
                startIndex = 0;
                flag = false;
            }
        }
        else {
            if (source.at(i) == findWhat.at(0) && findLength == 1)
                source = source.replace(i, 1, replaceWith);
            else if (source.at(i) == findWhat.at(0)) {
                startIndex = i;
                ++findWhatIndex;
                flag = true;
            }
        }
    }
}