trunk/genisoimage/checksum.c

/*
 * checksum.c
 *
 * Copyright (c) 2008- Steve McIntyre <steve@einval.com>
 *
 * Implementation of a generic checksum interface, used in JTE.
 *
 * GNU GPL v2
 */

#include <mconfig.h>
#include "genisoimage.h"
#include <timedefs.h>
#include <fctldefs.h>
#include <regex.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "md5.h"
#include "sha1.h"
#include "sha256.h"
#include "sha512.h"
#include "checksum.h"

#ifdef THREADED_CHECKSUMS
#   include <pthread.h>
#endif

static void md5_init(void *context)
{
    mk_MD5Init(context);
}
static void md5_update(void *context, unsigned char const *buf, unsigned int len)
{
    mk_MD5Update(context, buf, len);
}
static void md5_final(unsigned char *digest, void *context)
{
    mk_MD5Final(digest, context);
}

static void sha1_init(void *context)
{
    sha1_init_ctx(context);
}
static void sha1_update(void *context, unsigned char const *buf, unsigned int len)
{
    sha1_process_bytes(buf, len, context);
}
static void sha1_final(unsigned char *digest, void *context)
{
    sha1_finish_ctx(context, digest);
}

static void sha256_init(void *context)
{
    sha256_init_ctx(context);
}
static void sha256_update(void *context, unsigned char const *buf, unsigned int len)
{
    sha256_process_bytes(buf, len, context);
}
static void sha256_final(unsigned char *digest, void *context)
{
    sha256_finish_ctx(context, digest);
}

static void sha512_init(void *context)
{
    sha512_init_ctx(context);
}
static void sha512_update(void *context, unsigned char const *buf, unsigned int len)
{
    sha512_process_bytes(buf, len, context);
}
static void sha512_final(unsigned char *digest, void *context)
{
    sha512_finish_ctx(context, digest);
}

struct checksum_details
{
    char          *name;
    char          *prog;
    int            digest_size;
    int            context_size;
    void          (*init)(void *context);
    void          (*update)(void *context, unsigned char const *buf, unsigned int len);
    void          (*final)(unsigned char *digest, void *context);
};

static const struct checksum_details algorithms[] = 
{
    {
        "MD5",
        "md5sum",
        16,
        sizeof(struct mk_MD5Context),
        md5_init,
        md5_update,
        md5_final
    },
    {
        "SHA1",
        "sha1sum",
        20,
        sizeof(struct sha1_ctx),
        sha1_init,
        sha1_update,
        sha1_final
    },
    {
        "SHA256",
        "sha256sum",
        32,
        sizeof(struct sha256_ctx),
        sha256_init,
        sha256_update,
        sha256_final
    },
    {
        "SHA512",
        "sha512sum",
        64,
        sizeof(struct sha512_ctx),
        sha512_init,
        sha512_update,
        sha512_final
    }
};

struct algo_context
{
    void                     *context;
    unsigned char            *digest;
    int                       enabled;
    int                       finalised;
    char                     *hexdump;
#ifdef THREADED_CHECKSUMS
    unsigned char const      *buf;
    unsigned int              len;
    int                       which;
    pthread_t                 thread;
    struct _checksum_context *parent;
    pthread_mutex_t           start_mutex;
    pthread_cond_t            start_cv;
#endif
};

struct _checksum_context
{
#ifdef THREADED_CHECKSUMS
    unsigned int           index;
    unsigned int           threads_running;
    unsigned int           threads_desired;
    pthread_mutex_t        done_mutex;
    pthread_cond_t         done_cv;
#endif
    char                  *owner;
    struct algo_context    algo[NUM_CHECKSUMS];
};

struct checksum_info *checksum_information(enum checksum_types which)
{
    return (struct checksum_info *)&algorithms[which];
}

/* Dump a buffer in hex */
static void hex_dump_to_buffer(char *output_buffer, unsigned char *buf, size_t buf_size)
{
    unsigned int i;
    char *p = output_buffer;

    memset(output_buffer, 0, 1 + (2*buf_size));
    for (i = 0; i < buf_size ; i++)
        p += sprintf(p, "%2.2x", buf[i]);
}

#ifdef THREADED_CHECKSUMS
static void *checksum_thread(void *arg)
{
    struct algo_context *a = arg;
    struct _checksum_context *c = a->parent;
    int num_blocks_summed = 0;

    while (1)
    {
        /* wait to be given some work to do */
        pthread_mutex_lock(&a->start_mutex);
        while (a->buf == NULL)
        {
            pthread_cond_wait(&a->start_cv, &a->start_mutex);
        }
        pthread_mutex_unlock(&a->start_mutex);

        /* if we're given a zero-length buffer, then that means we're
         * done */
        if (a->len == 0)
            break;

        /* actually do the checksum on the supplied buffer */
        algorithms[a->which].update(a->context, a->buf, a->len);
        num_blocks_summed++;
        a->buf = NULL;

        /* and tell the main thread that we're done with that
         * buffer */
        pthread_mutex_lock(&c->done_mutex);
        c->threads_running--;
        if (c->threads_running == 0)
            pthread_cond_signal(&c->done_cv);
        pthread_mutex_unlock(&c->done_mutex);
    }

    pthread_exit(0);
}
#endif

checksum_context_t *checksum_init_context(int checksums, const char *owner)
{
    int i = 0;
    int ret = 0;
    struct _checksum_context *context = calloc(1, sizeof(struct _checksum_context));

    if (!context)
        return NULL;

    context->owner = strdup(owner);
    if (!context->owner)
    {
        free(context);
        return NULL;
    }   

#ifdef THREADED_CHECKSUMS
    pthread_mutex_init(&context->done_mutex, NULL);
    pthread_cond_init(&context->done_cv, NULL);
    context->index = 0;
    context->threads_running = 0;
    context->threads_desired = 0;

    for (i = 0; i < NUM_CHECKSUMS; i++)
        if ( (1 << i) & checksums)
            context->threads_desired++;    
#endif

    for (i = 0; i < NUM_CHECKSUMS; i++)
    {
        struct algo_context *a = &context->algo[i];
        if ( (1 << i) & checksums)
        {
            a->context = malloc(algorithms[i].context_size);
            if (!a->context)
            {
                checksum_free_context(context);
                return NULL;
            }
            a->digest = malloc(algorithms[i].digest_size);
            if (!a->digest)
            {
                checksum_free_context(context);
                return NULL;
            }
            a->hexdump = malloc(1 + (2*algorithms[i].digest_size));
            if (!a->hexdump)
            {
                checksum_free_context(context);
                return NULL;
            }
            algorithms[i].init(a->context);
            a->enabled = 1;
            a->finalised = 0;
#ifdef THREADED_CHECKSUMS
            a->which = i;
            a->parent = context;
            a->buf = NULL;
            a->len = 0;
            pthread_mutex_init(&a->start_mutex, NULL);
            pthread_cond_init(&a->start_cv, NULL);
            ret = pthread_create(&a->thread, NULL, checksum_thread, a);
            if (ret != 0)
            {
                fprintf(stderr, "failed to create new thread: %d\n", ret);
                checksum_free_context(context);
                return NULL;
            }
#endif
        }
        else
            a->enabled = 0;
    }
    
    return context;
}

void checksum_free_context(checksum_context_t *context)
{
    int i = 0;
    struct _checksum_context *c = context;

    for (i = 0; i < NUM_CHECKSUMS; i++)
    {
        struct algo_context *a = &c->algo[i];

#ifdef THREADED_CHECKSUMS
        if (a->thread)
        {
            void *ret;
            pthread_cancel(a->thread);
            pthread_join(a->thread, &ret);
            a->thread = 0;
        }
#endif
        free(a->context);
        free(a->digest);
        free(a->hexdump);
    }
    free(c->owner);
    free(c);
}

#ifdef THREADED_CHECKSUMS
void checksum_update(checksum_context_t *context,
                     unsigned char const *buf, unsigned int len)
{
    int i = 0;
    struct _checksum_context *c = context;
    static int index = 0;

    index++;

    c->threads_running = c->threads_desired;    
    for (i = 0; i < NUM_CHECKSUMS; i++)
    {
        if (c->algo[i].enabled)
        {
            struct algo_context *a = &c->algo[i];
            pthread_mutex_lock(&a->start_mutex);
            a->len = len;
            a->buf = buf;
            pthread_cond_signal(&a->start_cv);
            pthread_mutex_unlock(&a->start_mutex);
        }
    }

    /* Should now all be running, wait on them all to return */
    pthread_mutex_lock(&c->done_mutex);
    while (c->threads_running > 0)
    {
        pthread_cond_wait(&c->done_cv, &c->done_mutex);
    }
    pthread_mutex_unlock(&c->done_mutex);
}

#else // THREADED_CHECKSUMS

void checksum_update(checksum_context_t *context,
                     unsigned char const *buf, unsigned int len)
{
    int i = 0;
    struct _checksum_context *c = context;
    
    for (i = 0; i < NUM_CHECKSUMS; i++)
    {
        if (c->algo[i].enabled)
        {
            struct algo_context *a = &c->algo[i];
            algorithms[i].update(a->context, buf, len);
        }
    }
}

#endif // THREADED_CHECKSUMS

void checksum_final(checksum_context_t *context)
{
    int i = 0;
    struct _checksum_context *c = context;
    
#ifdef THREADED_CHECKSUMS
    void *thread_ret;
    /* Clean up the threads */
    c->threads_running = c->threads_desired;    

    for (i = 0; i < NUM_CHECKSUMS; i++)
    {
        if (c->algo[i].enabled)
        {
            void *ret = 0;
            struct algo_context *a = &c->algo[i];

            pthread_mutex_lock(&a->start_mutex);
            a->len = 0;
            a->buf = (unsigned char *)-1;
            pthread_cond_signal(&a->start_cv);
            pthread_mutex_unlock(&a->start_mutex);
            pthread_join(a->thread, &ret);
            a->thread = 0;
        }
    }
#endif

    for (i = 0; i < NUM_CHECKSUMS; i++)
    {
        struct algo_context *a = &c->algo[i];
        if (a->enabled)
        {
            algorithms[i].final(a->digest, a->context);
            hex_dump_to_buffer(a->hexdump, a->digest, algorithms[i].digest_size);
            a->finalised = 1;
        }
    }
}

void checksum_copy(checksum_context_t *context,
                   enum checksum_types which,
                   unsigned char *digest)
{
    struct _checksum_context *c = context;

    if (c->algo[which].enabled)
    {
        if (c->algo[which].finalised)
            memcpy(digest, c->algo[which].digest, algorithms[which].digest_size);
        else
            memset(digest, 0, algorithms[which].digest_size);
    }
    else
        fprintf(stderr, "Asked for %s checksum, not enabled!\n",
                algorithms[which].name);
}

const char *checksum_hex(checksum_context_t *context,
                         enum checksum_types which)
{
    struct _checksum_context *c = context;

    if (c->algo[which].enabled && c->algo[which].finalised)
        return c->algo[which].hexdump;

    /* else */
    return NULL;
}


/* Parse the command line options for which checksums to use */
int parse_checksum_algo(char *arg, int *algo)
{
    int error = 0;
    int i = 0;
    char *start_ptr = arg;
    int len = 0;

    *algo = 0;

    if (!strcasecmp(arg, "all"))
    {
        *algo = 0xFF;
        return 0;
    }
    
    while (*start_ptr != 0)
    {
        int match = 0;
        len = 0;

        while (start_ptr[len] != ',' && start_ptr[len] != 0)
            len++;
        
        if (len)
        {
            for (i = 0; i < NUM_CHECKSUMS; i++)
            {
                if (len == strlen(algorithms[i].name) &&
                    !strncasecmp(start_ptr, algorithms[i].name, len))
                {
                    match = 1;
                    *algo |= (1 << i);
                }
            }
        
            if (!match)
            {
                fprintf(stderr, "invalid algorithm name found in %s\n", arg);
                return EINVAL;
            }
        }
        
        if (start_ptr[len] == 0)
            break;
            
        start_ptr += len + 1;
    }
    
    if (! (*algo & CHECK_MD5_USED))
    {
        fprintf(stderr, "invalid choices: algorithms *must* include MD5\n");
        return EINVAL;
    }
    
    return 0;
}

#ifdef CHECKSUM_SELF_TEST
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    char buf[1024];
    int fd = -1;
    char *filename;
    int err = 0;
    static checksum_context_t *test_context = NULL;
    int i = 0;

    if (argc != 2)
    {
        fprintf(stderr, "Need a filename to act on!\n");
        return 1;
    }

    filename = argv[1];
    fd = open(filename, O_RDONLY);
    if (fd < 0)
    {
        fprintf(stderr, "Unable to open file %s, errno %d\n", filename, errno);
        return 1;
    }

    test_context = checksum_init_context(CHECK_ALL_USED, "test");
    if (!test_context)
    {
        fprintf(stderr, "Unable to initialise checksum context\n");
        return 1;
    }

    while(1)
    {
        err = read(fd, buf, sizeof(buf));
        if (err < 0)
        {
            fprintf(stderr, "Failed to read from file, errno %d\n", errno);
            return 1;
        }

        if (err == 0)
            break; // EOF

        /* else */
        checksum_update(test_context, buf, err);
    }
    close(fd);
    checksum_final(test_context);

    for (i = 0; i < NUM_CHECKSUMS; i++)
    {
        struct checksum_info *info;
        unsigned char r[64];
        int j = 0;

        info = checksum_information(i);
        memset(r, 0, sizeof(r));

        checksum_copy(test_context, i, r);

        printf("OUR %s:\n", info->name);
        for (j = 0; j < info->digest_size; j++)
            printf("%2.2x", r[j]);
        printf("  %s\n", filename);
        printf("system checksum program (%s):\n", info->prog);
        sprintf(buf, "%s %s", info->prog, filename);
        system(buf);
        printf("\n");
    }
    return 0;
}
#endif /* CHECKSUM_SELF_TEST */

1	/*
2	* checksum.c
3	*
4	* Copyright (c) 2008- Steve McIntyre <steve@einval.com>
5	*
6	* Implementation of a generic checksum interface, used in JTE.
7	*
8	* GNU GPL v2
9	*/
10
11	#include <mconfig.h>
12	#include "genisoimage.h"
13	#include <timedefs.h>
14	#include <fctldefs.h>
15	#include <regex.h>
16	#include <stdlib.h>
17	#include <string.h>
18	#include <errno.h>
19	#include "md5.h"
20	#include "sha1.h"
21	#include "sha256.h"
22	#include "sha512.h"
23	#include "checksum.h"
24
25	#ifdef THREADED_CHECKSUMS
26	# include <pthread.h>
27	#endif
28
29	static void md5_init(void *context)
30	{
31	mk_MD5Init(context);
32	}
33	static void md5_update(void context, unsigned char const buf, unsigned int len)
34	{
35	mk_MD5Update(context, buf, len);
36	}
37	static void md5_final(unsigned char digest, void context)
38	{
39	mk_MD5Final(digest, context);
40	}
41
42	static void sha1_init(void *context)
43	{
44	sha1_init_ctx(context);
45	}
46	static void sha1_update(void context, unsigned char const buf, unsigned int len)
47	{
48	sha1_process_bytes(buf, len, context);
49	}
50	static void sha1_final(unsigned char digest, void context)
51	{
52	sha1_finish_ctx(context, digest);
53	}
54
55	static void sha256_init(void *context)
56	{
57	sha256_init_ctx(context);
58	}
59	static void sha256_update(void context, unsigned char const buf, unsigned int len)
60	{
61	sha256_process_bytes(buf, len, context);
62	}
63	static void sha256_final(unsigned char digest, void context)
64	{
65	sha256_finish_ctx(context, digest);
66	}
67
68	static void sha512_init(void *context)
69	{
70	sha512_init_ctx(context);
71	}
72	static void sha512_update(void context, unsigned char const buf, unsigned int len)
73	{
74	sha512_process_bytes(buf, len, context);
75	}
76	static void sha512_final(unsigned char digest, void context)
77	{
78	sha512_finish_ctx(context, digest);
79	}
80
81	struct checksum_details
82	{
83	char *name;
84	char *prog;
85	int digest_size;
86	int context_size;
87	void (init)(void context);
88	void (update)(void context, unsigned char const *buf, unsigned int len);
89	void (final)(unsigned char digest, void *context);
90	};
91
92	static const struct checksum_details algorithms[] =
93	{
94	{
95	"MD5",
96	"md5sum",
97	16,
98	sizeof(struct mk_MD5Context),
99	md5_init,
100	md5_update,
101	md5_final
102	},
103	{
104	"SHA1",
105	"sha1sum",
106	20,
107	sizeof(struct sha1_ctx),
108	sha1_init,
109	sha1_update,
110	sha1_final
111	},
112	{
113	"SHA256",
114	"sha256sum",
115	32,
116	sizeof(struct sha256_ctx),
117	sha256_init,
118	sha256_update,
119	sha256_final
120	},
121	{
122	"SHA512",
123	"sha512sum",
124	64,
125	sizeof(struct sha512_ctx),
126	sha512_init,
127	sha512_update,
128	sha512_final
129	}
130	};
131
132	struct algo_context
133	{
134	void *context;
135	unsigned char *digest;
136	int enabled;
137	int finalised;
138	char *hexdump;
139	#ifdef THREADED_CHECKSUMS
140	unsigned char const *buf;
141	unsigned int len;
142	int which;
143	pthread_t thread;
144	struct _checksum_context *parent;
145	pthread_mutex_t start_mutex;
146	pthread_cond_t start_cv;
147	#endif
148	};
149
150	struct _checksum_context
151	{
152	#ifdef THREADED_CHECKSUMS
153	unsigned int index;
154	unsigned int threads_running;
155	unsigned int threads_desired;
156	pthread_mutex_t done_mutex;
157	pthread_cond_t done_cv;
158	#endif
159	char *owner;
160	struct algo_context algo[NUM_CHECKSUMS];
161	};
162
163	struct checksum_info *checksum_information(enum checksum_types which)
164	{
165	return (struct checksum_info *)&algorithms[which];
166	}
167
168	/* Dump a buffer in hex */
169	static void hex_dump_to_buffer(char output_buffer, unsigned char buf, size_t buf_size)
170	{
171	unsigned int i;
172	char *p = output_buffer;
173
174	memset(output_buffer, 0, 1 + (2*buf_size));
175	for (i = 0; i < buf_size ; i++)
176	p += sprintf(p, "%2.2x", buf[i]);
177	}
178
179	#ifdef THREADED_CHECKSUMS
180	static void checksum_thread(void arg)
181	{
182	struct algo_context *a = arg;
183	struct _checksum_context *c = a->parent;
184	int num_blocks_summed = 0;
185
186	while (1)
187	{
188	/* wait to be given some work to do */
189	pthread_mutex_lock(&a->start_mutex);
190	while (a->buf == NULL)
191	{
192	pthread_cond_wait(&a->start_cv, &a->start_mutex);
193	}
194	pthread_mutex_unlock(&a->start_mutex);
195
196	/* if we're given a zero-length buffer, then that means we're
197	* done */
198	if (a->len == 0)
199	break;
200
201	/* actually do the checksum on the supplied buffer */
202	algorithms[a->which].update(a->context, a->buf, a->len);
203	num_blocks_summed++;
204	a->buf = NULL;
205
206	/* and tell the main thread that we're done with that
207	* buffer */
208	pthread_mutex_lock(&c->done_mutex);
209	c->threads_running--;
210	if (c->threads_running == 0)
211	pthread_cond_signal(&c->done_cv);
212	pthread_mutex_unlock(&c->done_mutex);
213	}
214
215	pthread_exit(0);
216	}
217	#endif
218
219	checksum_context_t checksum_init_context(int checksums, const char owner)
220	{
221	int i = 0;
222	int ret = 0;
223	struct _checksum_context *context = calloc(1, sizeof(struct _checksum_context));
224
225	if (!context)
226	return NULL;
227
228	context->owner = strdup(owner);
229	if (!context->owner)
230	{
231	free(context);
232	return NULL;
233	}
234
235	#ifdef THREADED_CHECKSUMS
236	pthread_mutex_init(&context->done_mutex, NULL);
237	pthread_cond_init(&context->done_cv, NULL);
238	context->index = 0;
239	context->threads_running = 0;
240	context->threads_desired = 0;
241
242	for (i = 0; i < NUM_CHECKSUMS; i++)
243	if ( (1 << i) & checksums)
244	context->threads_desired++;
245	#endif
246
247	for (i = 0; i < NUM_CHECKSUMS; i++)
248	{
249	struct algo_context *a = &context->algo[i];
250	if ( (1 << i) & checksums)
251	{
252	a->context = malloc(algorithms[i].context_size);
253	if (!a->context)
254	{
255	checksum_free_context(context);
256	return NULL;
257	}
258	a->digest = malloc(algorithms[i].digest_size);
259	if (!a->digest)
260	{
261	checksum_free_context(context);
262	return NULL;
263	}
264	a->hexdump = malloc(1 + (2*algorithms[i].digest_size));
265	if (!a->hexdump)
266	{
267	checksum_free_context(context);
268	return NULL;
269	}
270	algorithms[i].init(a->context);
271	a->enabled = 1;
272	a->finalised = 0;
273	#ifdef THREADED_CHECKSUMS
274	a->which = i;
275	a->parent = context;
276	a->buf = NULL;
277	a->len = 0;
278	pthread_mutex_init(&a->start_mutex, NULL);
279	pthread_cond_init(&a->start_cv, NULL);
280	ret = pthread_create(&a->thread, NULL, checksum_thread, a);
281	if (ret != 0)
282	{
283	fprintf(stderr, "failed to create new thread: %d\n", ret);
284	checksum_free_context(context);
285	return NULL;
286	}
287	#endif
288	}
289	else
290	a->enabled = 0;
291	}
292
293	return context;
294	}
295
296	void checksum_free_context(checksum_context_t *context)
297	{
298	int i = 0;
299	struct _checksum_context *c = context;
300
301	for (i = 0; i < NUM_CHECKSUMS; i++)
302	{
303	struct algo_context *a = &c->algo[i];
304
305	#ifdef THREADED_CHECKSUMS
306	if (a->thread)
307	{
308	void *ret;
309	pthread_cancel(a->thread);
310	pthread_join(a->thread, &ret);
311	a->thread = 0;
312	}
313	#endif
314	free(a->context);
315	free(a->digest);
316	free(a->hexdump);
317	}
318	free(c->owner);
319	free(c);
320	}
321
322	#ifdef THREADED_CHECKSUMS
323	void checksum_update(checksum_context_t *context,
324	unsigned char const *buf, unsigned int len)
325	{
326	int i = 0;
327	struct _checksum_context *c = context;
328	static int index = 0;
329
330	index++;
331
332	c->threads_running = c->threads_desired;
333	for (i = 0; i < NUM_CHECKSUMS; i++)
334	{
335	if (c->algo[i].enabled)
336	{
337	struct algo_context *a = &c->algo[i];
338	pthread_mutex_lock(&a->start_mutex);
339	a->len = len;
340	a->buf = buf;
341	pthread_cond_signal(&a->start_cv);
342	pthread_mutex_unlock(&a->start_mutex);
343	}
344	}
345
346	/* Should now all be running, wait on them all to return */
347	pthread_mutex_lock(&c->done_mutex);
348	while (c->threads_running > 0)
349	{
350	pthread_cond_wait(&c->done_cv, &c->done_mutex);
351	}
352	pthread_mutex_unlock(&c->done_mutex);
353	}
354
355	#else // THREADED_CHECKSUMS
356
357	void checksum_update(checksum_context_t *context,
358	unsigned char const *buf, unsigned int len)
359	{
360	int i = 0;
361	struct _checksum_context *c = context;
362
363	for (i = 0; i < NUM_CHECKSUMS; i++)
364	{
365	if (c->algo[i].enabled)
366	{
367	struct algo_context *a = &c->algo[i];
368	algorithms[i].update(a->context, buf, len);
369	}
370	}
371	}
372
373	#endif // THREADED_CHECKSUMS
374
375	void checksum_final(checksum_context_t *context)
376	{
377	int i = 0;
378	struct _checksum_context *c = context;
379
380	#ifdef THREADED_CHECKSUMS
381	void *thread_ret;
382	/* Clean up the threads */
383	c->threads_running = c->threads_desired;
384
385	for (i = 0; i < NUM_CHECKSUMS; i++)
386	{
387	if (c->algo[i].enabled)
388	{
389	void *ret = 0;
390	struct algo_context *a = &c->algo[i];
391
392	pthread_mutex_lock(&a->start_mutex);
393	a->len = 0;
394	a->buf = (unsigned char *)-1;
395	pthread_cond_signal(&a->start_cv);
396	pthread_mutex_unlock(&a->start_mutex);
397	pthread_join(a->thread, &ret);
398	a->thread = 0;
399	}
400	}
401	#endif
402
403	for (i = 0; i < NUM_CHECKSUMS; i++)
404	{
405	struct algo_context *a = &c->algo[i];
406	if (a->enabled)
407	{
408	algorithms[i].final(a->digest, a->context);
409	hex_dump_to_buffer(a->hexdump, a->digest, algorithms[i].digest_size);
410	a->finalised = 1;
411	}
412	}
413	}
414
415	void checksum_copy(checksum_context_t *context,
416	enum checksum_types which,
417	unsigned char *digest)
418	{
419	struct _checksum_context *c = context;
420
421	if (c->algo[which].enabled)
422	{
423	if (c->algo[which].finalised)
424	memcpy(digest, c->algo[which].digest, algorithms[which].digest_size);
425	else
426	memset(digest, 0, algorithms[which].digest_size);
427	}
428	else
429	fprintf(stderr, "Asked for %s checksum, not enabled!\n",
430	algorithms[which].name);
431	}
432
433	const char checksum_hex(checksum_context_t context,
434	enum checksum_types which)
435	{
436	struct _checksum_context *c = context;
437
438	if (c->algo[which].enabled && c->algo[which].finalised)
439	return c->algo[which].hexdump;
440
441	/* else */
442	return NULL;
443	}
444
445
446	/* Parse the command line options for which checksums to use */
447	int parse_checksum_algo(char arg, int algo)
448	{
449	int error = 0;
450	int i = 0;
451	char *start_ptr = arg;
452	int len = 0;
453
454	*algo = 0;
455
456	if (!strcasecmp(arg, "all"))
457	{
458	*algo = 0xFF;
459	return 0;
460	}
461
462	while (*start_ptr != 0)
463	{
464	int match = 0;
465	len = 0;
466
467	while (start_ptr[len] != ',' && start_ptr[len] != 0)
468	len++;
469
470	if (len)
471	{
472	for (i = 0; i < NUM_CHECKSUMS; i++)
473	{
474	if (len == strlen(algorithms[i].name) &&
475	!strncasecmp(start_ptr, algorithms[i].name, len))
476	{
477	match = 1;
478	*algo \|= (1 << i);
479	}
480	}
481
482	if (!match)
483	{
484	fprintf(stderr, "invalid algorithm name found in %s\n", arg);
485	return EINVAL;
486	}
487	}
488
489	if (start_ptr[len] == 0)
490	break;
491
492	start_ptr += len + 1;
493	}
494
495	if (! (*algo & CHECK_MD5_USED))
496	{
497	fprintf(stderr, "invalid choices: algorithms must include MD5\n");
498	return EINVAL;
499	}
500
501	return 0;
502	}
503
504	#ifdef CHECKSUM_SELF_TEST
505	#include <sys/types.h>
506	#include <sys/stat.h>
507	#include <fcntl.h>
508	#include <unistd.h>
509	#include <errno.h>
510	#include <stdlib.h>
511
512	int main(int argc, char **argv)
513	{
514	char buf[1024];
515	int fd = -1;
516	char *filename;
517	int err = 0;
518	static checksum_context_t *test_context = NULL;
519	int i = 0;
520
521	if (argc != 2)
522	{
523	fprintf(stderr, "Need a filename to act on!\n");
524	return 1;
525	}
526
527	filename = argv[1];
528	fd = open(filename, O_RDONLY);
529	if (fd < 0)
530	{
531	fprintf(stderr, "Unable to open file %s, errno %d\n", filename, errno);
532	return 1;
533	}
534
535	test_context = checksum_init_context(CHECK_ALL_USED, "test");
536	if (!test_context)
537	{
538	fprintf(stderr, "Unable to initialise checksum context\n");
539	return 1;
540	}
541
542	while(1)
543	{
544	err = read(fd, buf, sizeof(buf));
545	if (err < 0)
546	{
547	fprintf(stderr, "Failed to read from file, errno %d\n", errno);
548	return 1;
549	}
550
551	if (err == 0)
552	break; // EOF
553
554	/* else */
555	checksum_update(test_context, buf, err);
556	}
557	close(fd);
558	checksum_final(test_context);
559
560	for (i = 0; i < NUM_CHECKSUMS; i++)
561	{
562	struct checksum_info *info;
563	unsigned char r[64];
564	int j = 0;
565
566	info = checksum_information(i);
567	memset(r, 0, sizeof(r));
568
569	checksum_copy(test_context, i, r);
570
571	printf("OUR %s:\n", info->name);
572	for (j = 0; j < info->digest_size; j++)
573	printf("%2.2x", r[j]);
574	printf(" %s\n", filename);
575	printf("system checksum program (%s):\n", info->prog);
576	sprintf(buf, "%s %s", info->prog, filename);
577	system(buf);
578	printf("\n");
579	}
580	return 0;
581	}
582	#endif /* CHECKSUM_SELF_TEST */
583