Return to patch.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitsync / src

Annotation of libaitsync/src/patch.c, revision 1.1.1.1.2.1

1.1.1.1.2.1! misho       1: /*************************************************************************
        !             2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
        !             3: *  by Michael Pounov <misho@openbsd-bg.org>
        !             4: *
        !             5: * $Author: misho $
        !             6: * $Id: aitsync.c,v 1.1.1.1 2010/03/24 16:00:15 misho Exp $
        !             7: *
        !             8: *************************************************************************/
1.1       misho       9: #include "global.h"
                     10: #include "patch.h"
                     11: 
                     12: 
                     13: int sync_buildPatch(void * __restrict buf, u_int buflen, struct tagPiece ** __restrict arr)
                     14: {
                     15:        void *pos;
                     16:        sync_chunk_t *prefix, *suffix;
                     17:        struct tagPiece *a = *arr;
                     18:        register int i;
                     19:        u_int len = buflen;
                     20: 
                     21:        if (!buf || !arr)
                     22:                return -1;
                     23: 
                     24:        a = malloc(sizeof(struct tagPiece));
                     25:        if (!a) {
                     26:                SETERR;
                     27:                return -1;
                     28:        } else
                     29:                memset(a, 0, sizeof(struct tagPiece));
                     30: 
                     31:        for (pos = buf, i = 0; len && pos < buf + buflen; i++) {
                     32:                a = realloc(a, sizeof(struct tagPiece) * (i + 2));
                     33:                if (!a) {
                     34:                        SETERR;
                     35:                        return -1;
                     36:                } else {
                     37:                        memset(&a[i + 1], 0, sizeof(struct tagPiece));
                     38:                        // printf("%d.prefix_pos=%p len=%d\n", i, pos, len);
                     39: 
                     40:                        // prefix chunk
                     41:                        prefix = pos;
                     42:                        if (prefix->sc_magic != DLTSYNC_MAGIC) {
                     43:                                if (a) {
                     44:                                        free(a);
                     45:                                        a = NULL;
                     46:                                }
                     47:                                return -1;
                     48:                        } else {
                     49:                                a[i].pfx = prefix;
                     50:                                pos += sizeof(sync_chunk_t);
                     51:                                len -= sizeof(sync_chunk_t);
                     52:                        }
                     53:                        // printf("%d.prefix=%p pos=%p len=%d\n", i, a[i].pfx, pos, len);
                     54: 
                     55:                        // data
                     56:                        if (!len) {
                     57:                                if (a) {
                     58:                                        free(a);
                     59:                                        a = NULL;
                     60:                                }
                     61:                                return -1;
                     62:                        } else {
                     63:                                a[i].buf = pos;
                     64:                                pos += prefix->sc_len;
                     65:                                len -= prefix->sc_len;
                     66:                        }
                     67:                        // printf("%d.data=%p pos=%p len=%d\n", i, a[i].buf, pos, len);
                     68: 
                     69:                        // if find sync chunk
                     70:                        if (len) {
                     71:                                suffix = pos;
                     72:                                if (SIGSYNC_MAGIC == suffix->sc_magic) {
                     73:                                        a[i].sfx = suffix;
                     74:                                        pos += sizeof(sync_chunk_t);
                     75:                                        len -= sizeof(sync_chunk_t);
                     76:                                }
                     77:                                // printf("%d.data=%p pos=%p len=%d\n", i, a[i].sfx, pos, len);
                     78:                        }
                     79:                }
                     80:        }
                     81: 
                     82:        *arr = a;
                     83:        return i;
                     84: }