C7

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

#include <unistd.h>
#include <crypt.h>
#include <time.h>

#include <pthread.h>
#include <semaphore.h>

#define PROC_NUM sysconf(_SC_NPROCESSORS_ONLN);                             //

typedef enum
{
    BM_ITER,
    BM_REC,
} brute_mode_t;

typedef enum                                                                //
{
    TM_SINGLE,
    TM_MULTI,
} thread_mode_t;

typedef struct config_t {
    brute_mode_t brute_mode;
    thread_mode_t thread_mode;                                              //
    int length;
    char * alphabet;
    char * hash;
} config_t;

typedef struct task_t {
    char password[8];
} task_t;

typedef struct queue_t {
    task_t queue[8];
    int head, tail;
    pthread_mutex_t head_mutex, tail_mutex;
    sem_t empty, full;
} queue_t;

typedef bool (*password_handler_t) (config_t * config, char * password);

void queue_init (queue_t * queue)
{
    queue->head = 0;
    queue->tail = 0;
    pthread_mutex_init (&queue->head_mutex, NULL);
    pthread_mutex_init (&queue->tail_mutex, NULL);
    sem_init (&queue->empty, 0, sizeof (queue->queue) / sizeof (queue->queue[0]));
    sem_init (&queue->full, 0, 0);
}

void queue_push (queue_t * queue, task_t * task)
{
    //7
    sem_wait (&queue->empty);
    pthread_mutex_lock (&queue->tail_mutex);
    queue->queue[queue->tail] = *task;
    if (++queue->tail == sizeof (queue->queue) / sizeof (queue->queue[0]))
        queue->tail = 0;
    pthread_mutex_unlock (&queue->tail_mutex);
    sem_post (&queue->full);

}

void queue_pop (queue_t * queue, task_t * task)
{
    //7
    sem_wait(&queue->full);
    pthread_mutex_lock (&queue->head_mutex);
    if (++queue->head == sizeof (queue->queue) / sizeof (queue->queue[0]))
        queue->head = 0;
    pthread_mutex_unlock (&queue->head_mutex);
    sem_post (&queue->empty);
}

bool rec(config_t* config, char* password, int pos, password_handler_t password_handler)
{
    int i;
    if (pos >= config->length)
    {
        if (password_handler (config, password))
        {
            return (true);
        }
    }
    else
    {
        for (i = 0; config->alphabet[i]; ++i)
        {
            password[pos] = config->alphabet[i];
            if (rec (config, password, pos + 1, password_handler))
                return (true);
        }
    }
    return (false);
}

void rec_wrapper(config_t* config, char* password, password_handler_t password_handler)
{
    rec (config, password, 0, password_handler);
}

void iter(config_t* config, char* password, password_handler_t password_handler)
{
    int alph_length_1 = strlen(config->alphabet) - 1;
    int idx[config->length];
    int i;

    for (i = 0; i < config->length; i++)
    {
        idx[i] = 0;
        password[i] = config->alphabet[0];
    }

    for (;;)
    {
         if (password_handler (config, password))
            break;
        for (i = config->length - 1; (i >= 0) && (idx[i] == alph_length_1); i--)
        {
            idx[i] = 0;
            password[i] = config->alphabet[0];
        }

        if (i < 0)
            break;

        password[i] = config->alphabet[++idx[i]];
    }
}

void parse_params(config_t* config, int argc, char* argv[])
{
    for (;;)
    {
        int opt = getopt(argc, argv, "a:l:h:irsm");                         //
        if (opt == -1)
            break;
        switch (opt)
        {
        case 's':
            config->thread_mode = TM_SINGLE;                                //
            break;

        case 'm':
            config->thread_mode = TM_MULTI;                                 //
            break;

        case 'i':
            config->brute_mode = BM_ITER;
            break;

        case 'r':
            config->brute_mode = BM_REC;
            break;

        case 'a':
            config->alphabet = optarg;
            break;

        case 'h':
            config->hash = optarg;
            break;

        case 'l':
            config->length = atoi(optarg);
            break;

        default:
            break;
        }
    }
}

bool print_password (config_t * config, char * password)
{
    printf ("%s\n", password);
    return (false);
}

bool check_password (config_t * config, char * password)
{
    char * hash = crypt (password, config->hash);
    int cmp = strcmp (hash, config->hash);
    return (0 == cmp);
}

int main(int argc, char* argv[])
{
    config_t config =
    {
        .thread_mode = TM_SINGLE,                                           //
        .brute_mode = BM_ITER,
        .alphabet = "01",
        .length = 6,
        .hash = strdup (crypt ("111101", "11")),
    };

    queue_t queue;
    queue_init (&queue);

    parse_params(&config, argc, argv);

    char password[config.length + 1];
    password[config.length] = 0;

    if (config.thread_mode == TM_MULTI)                                     //
    {
        pthread_t id[PROC_NUM];
        int i;
        for (i = 0; i < proc_num; i++)
            pthread_create (&id[i], NULL, /* fun */, NULL);
    }

    switch (config.brute_mode)
    {
        case BM_ITER:
            iter (&config, password, check_password);
            break;
        case BM_REC:
            rec_wrapper(&config, password, check_password);
            break;
    }
    printf ("%s\n", password);
    return (EXIT_SUCCESS);
}