Return to patch.c CVS log

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

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

1.2     ! 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: patch.c,v 1.1.1.1.2.2 2011/05/09 14:35:56 misho Exp $
        !             7: *
        !             8: **************************************************************************
        !             9: The ELWIX and AITNET software is distributed under the following
        !            10: terms:
        !            11: 
        !            12: All of the documentation and software included in the ELWIX and AITNET
        !            13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
        !            14: 
        !            15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
        !            16:        by Michael Pounov <misho@elwix.org>.  All rights reserved.
        !            17: 
        !            18: Redistribution and use in source and binary forms, with or without
        !            19: modification, are permitted provided that the following conditions
        !            20: are met:
        !            21: 1. Redistributions of source code must retain the above copyright
        !            22:    notice, this list of conditions and the following disclaimer.
        !            23: 2. Redistributions in binary form must reproduce the above copyright
        !            24:    notice, this list of conditions and the following disclaimer in the
        !            25:    documentation and/or other materials provided with the distribution.
        !            26: 3. All advertising materials mentioning features or use of this software
        !            27:    must display the following acknowledgement:
        !            28: This product includes software developed by Michael Pounov <misho@elwix.org>
        !            29: ELWIX - Embedded LightWeight unIX and its contributors.
        !            30: 4. Neither the name of AITNET nor the names of its contributors
        !            31:    may be used to endorse or promote products derived from this software
        !            32:    without specific prior written permission.
        !            33: 
        !            34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
        !            35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            37: ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            44: SUCH DAMAGE.
        !            45: */
1.1       misho      46: #include "global.h"
                     47: #include "patch.h"
                     48: 
                     49: 
                     50: int sync_buildPatch(void * __restrict buf, u_int buflen, struct tagPiece ** __restrict arr)
                     51: {
                     52:        void *pos;
                     53:        sync_chunk_t *prefix, *suffix;
                     54:        struct tagPiece *a = *arr;
                     55:        register int i;
                     56:        u_int len = buflen;
                     57: 
                     58:        if (!buf || !arr)
                     59:                return -1;
                     60: 
                     61:        a = malloc(sizeof(struct tagPiece));
                     62:        if (!a) {
                     63:                SETERR;
                     64:                return -1;
                     65:        } else
                     66:                memset(a, 0, sizeof(struct tagPiece));
                     67: 
                     68:        for (pos = buf, i = 0; len && pos < buf + buflen; i++) {
                     69:                a = realloc(a, sizeof(struct tagPiece) * (i + 2));
                     70:                if (!a) {
                     71:                        SETERR;
                     72:                        return -1;
                     73:                } else {
                     74:                        memset(&a[i + 1], 0, sizeof(struct tagPiece));
                     75:                        // printf("%d.prefix_pos=%p len=%d\n", i, pos, len);
                     76: 
                     77:                        // prefix chunk
                     78:                        prefix = pos;
                     79:                        if (prefix->sc_magic != DLTSYNC_MAGIC) {
                     80:                                if (a) {
                     81:                                        free(a);
                     82:                                        a = NULL;
                     83:                                }
                     84:                                return -1;
                     85:                        } else {
                     86:                                a[i].pfx = prefix;
                     87:                                pos += sizeof(sync_chunk_t);
                     88:                                len -= sizeof(sync_chunk_t);
                     89:                        }
                     90:                        // printf("%d.prefix=%p pos=%p len=%d\n", i, a[i].pfx, pos, len);
                     91: 
                     92:                        // data
                     93:                        if (!len) {
                     94:                                if (a) {
                     95:                                        free(a);
                     96:                                        a = NULL;
                     97:                                }
                     98:                                return -1;
                     99:                        } else {
                    100:                                a[i].buf = pos;
                    101:                                pos += prefix->sc_len;
                    102:                                len -= prefix->sc_len;
                    103:                        }
                    104:                        // printf("%d.data=%p pos=%p len=%d\n", i, a[i].buf, pos, len);
                    105: 
                    106:                        // if find sync chunk
                    107:                        if (len) {
                    108:                                suffix = pos;
                    109:                                if (SIGSYNC_MAGIC == suffix->sc_magic) {
                    110:                                        a[i].sfx = suffix;
                    111:                                        pos += sizeof(sync_chunk_t);
                    112:                                        len -= sizeof(sync_chunk_t);
                    113:                                }
                    114:                                // printf("%d.data=%p pos=%p len=%d\n", i, a[i].sfx, pos, len);
                    115:                        }
                    116:                }
                    117:        }
                    118: 
                    119:        *arr = a;
                    120:        return i;
                    121: }