int scandir(const char *dir, struct dirent ***namelist,
              int(*filter)(const struct dirent *),
              int(*compar)(const struct dirent **, const struct dirent **));

int fnmatch(const char *pattern, const char *string, int flags);

struct static_fn
{
   const char* pattern_;
   static int filter(const dirent * param)
   {
      //...
      int i = fnmatch(pattern_, ...);
      //...
   }
};

//...

static_fn::pattern_ = "123";
scandir("c;\\test", ..., &static_fn::filter, ...);

...
// Где-то во время инициализации...
DWORD dwSlot = ::TlsAlloc(); 

...

// Наша функция-фильтр
int filter( const struct dirent * )
{
    const char * szPattern = reinterpret_cast<const char *>( ::TlsGetValue( dwSlot ) );
    // Используем szPattern, в том числе и отправляем его в fnmatch
    // ...
}

...

// Сохраняем текущее значение tls слота на случай, если кто-то выше по стеку тоже его использует (в том числе и этот фрагмент кода)
void * pOldTlsValue = ::TlsGetValue( dwSlot );

// Задаем маску
const char * szPattern = "*.txt";
::TlsSetValue( dwSlot, const_cast<char *>( szPattern ) );

// Вызываем scandir - filter получит маску из слота
::scandir( ..., ..., &::filter, ... );

// Восстанавливаем старое значение слота
::TlsSetValue( dwSlot, pOldTlsValue );

GA>int scandir(const char *dir, struct dirent ***namelist,
GA>              int(*filter)(const struct dirent *),
GA>              int(*compar)(const struct dirent **, const struct dirent **));

GA>

class ThunkFunc {
public:
    typedef bool TParamlessCallback();
    typedef void* TParam;
    typedef bool TCallback( TParam );

    static TParamlessCallback* GetCallback( TCallback* foo, TParam param )
    {
        assert( foo != 0 );
        ThunkFunc* curr = firstFree;
        assert( curr != 0 );
        firstFree = curr->next;
        TParamlessCallback* res = curr->getFuction( foo, param );
        assert( res != 0 && allocated[res] == 0 );
        allocated[res] = curr;
        return res;
    }
    static void FreeCallback( TParamlessCallback* res )
    {
        assert( res != 0 );
        ThunkFunc* curr = allocated[res];
        assert( curr != 0 );
        allocated[res] = 0;
        curr->insertMeAsFree();
    }
    static int FreeCallbacksCount()
    {
        int count = 0;
        for( ThunkFunc* curr = firstFree; curr != 0; curr = curr->next )
            count++;
        return count;
        
    }
    static int TotallRegisteredCollbaks() { return regCount; }

protected:
    ThunkFunc() : next( 0 ) { }
    
    virtual TParamlessCallback* getFuction( TCallback*, TParam ) = 0;
    virtual void freeFunction() = 0;
    virtual bool isFree() const = 0;

    void regMe()
    {
        insertMeAsFree();
        regCount++;
    }

private:
    ThunkFunc* next;
    typedef std::map<TParamlessCallback*, ThunkFunc*> TAllocated;
    static TAllocated allocated;
    static ThunkFunc* firstFree;
    static int regCount;

    void insertMeAsFree()
    {
        next = firstFree;
        firstFree = this;
    }
};

ThunkFunc::TAllocated ThunkFunc::allocated;
ThunkFunc* ThunkFunc::firstFree = 0;
int ThunkFunc::regCount = 0;


template<int* seed>
class ThunkFuncImpl : ThunkFunc {
public:
    ThunkFuncImpl() 
    {
        assert( !*seed );
        *seed = true;
        regMe();
    }
private:
    virtual TParamlessCallback* getFuction( TCallback* f, TParam p )
    {
        assert( foo == 0 && f != 0 );
        foo = f;
        param = p;
        return theCallback;
    }
    virtual void freeFunction()
    {
        assert( foo != 0 );
        foo = 0;
    }
    virtual bool isFree() const
    {
        return foo != 0;
    }

    static TCallback* foo;
    static TParam param;
    static bool theCallback() { return foo( param ); }
};

template<int* seed>
ThunkFunc::TCallback* ThunkFuncImpl<seed>::foo = 0;

template<int* seed>
ThunkFunc::TParam ThunkFuncImpl<seed>::param;

#define IMPL_THUNK_FUNС_I2( UNIQUE_ID )                                            \
    namespace{                                                                    \
        int ThunkFuncSeed_##UNIQUE_ID = false;                                    \
        ThunkFuncImpl< & ThunkFuncSeed_##UNIQUE_ID > ThunkFuncImpl_##UNIQUE_ID;    \
    }    // namespace                                                            \


#define IMPL_THUNK_FUNС_I1( UNIQUE_ID ) IMPL_THUNK_FUNС_I2( UNIQUE_ID )

#define IMPL_THUNK_FUNС_I IMPL_THUNK_FUNС_I1( __LINE__ )

IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I
IMPL_THUNK_FUNС_I

// Если число масок ограничено, то можно попытаться сделать наподобие этого примера
// пример использования scandir взят из man scandir
// strcmp заменить на fnmatch
// test1.cpp
#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <stdlib.h>

struct Mask1
{
        static const char *name()
        {
                return "test1.cpp";
        }
};

struct Mask2
{
        static const char *name()
        {
                return "test2.cpp";
        }
};

template<class M>
struct FnMacher
{
        static int filter(const struct dirent *entry)
        {
                const char *name = entry->d_name;
                int r = strcmp(name, M::name());

                return (r == 0);
        }
};

int main()
{
        struct dirent **namelist;
        int n = scandir(".", &namelist, &FnMacher<Mask1>::filter, 0);

        if (n < 0)
           perror("scandir");
        else 
        {
           while (n--) 
           {
                   printf("Mask1: %s\n", namelist[n]->d_name);
                   free(namelist[n]);
           }

           free(namelist);
        }

        n = scandir(".", &namelist, &FnMacher<Mask2>::filter, 0);

        if (n < 0)
           perror("scandir");
        else 
        {
           while (n--) 
           {
                   printf("Mask2: %s\n", namelist[n]->d_name);
                   free(namelist[n]);
           }

           free(namelist);
        }

        return 0;
}