rsync.h

Go to the documentation of this file.

/*=                    -*- c-basic-offset: 4; indent-tabs-mode: nil; -*-
 *
 * librsync -- library for network deltas
 * $Id: rsync.h,v 1.1.1.1 2002/01/25 22:15:09 kergoth Exp $
 * 
 * Copyright (C) 2000, 2001 by Martin Pool <mbp@samba.org>
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

                              /*
                               | You should never wear your best
                               | trousers when you go out to fight for
                               | freedom and liberty.
                               |        -- Henrik Ibsen
                               */


#include <sys/types.h>

extern char const rs_librsync_version[];
extern char const rs_licence_string[];


#if SIZEOF_LONG_LONG
typedef signed long long    rs_long_t;
#else
typedef long rs_long_t;
#endif


typedef enum {
    RS_LOG_EMERG         = 0,   
    RS_LOG_ALERT         = 1,   
    RS_LOG_CRIT          = 2,   
    RS_LOG_ERR           = 3,   
    RS_LOG_WARNING       = 4,   
    RS_LOG_NOTICE        = 5,   
    RS_LOG_INFO          = 6,   
    RS_LOG_DEBUG         = 7    
} rs_loglevel;



typedef void    rs_trace_fn_t(int level, char const *msg);

void            rs_trace_set_level(rs_loglevel level);

void            rs_trace_to(rs_trace_fn_t *);

void            rs_trace_stderr(int level, char const *msg);

int             rs_supports_trace(void);



void     rs_hexify(char *to_buf, void const *from_buf, int from_len);

size_t rs_unbase64(char *s);


void rs_base64(unsigned char const *buf, int n, char *out);


typedef enum {
    RS_DONE =           0,      
    RS_BLOCKED =        1,      
    RS_RUNNING  =       2,      
    RS_TEST_SKIPPED =   77,     
    RS_IO_ERROR =       100,    
    RS_SYNTAX_ERROR =   101,    
    RS_MEM_ERROR =      102,    
    RS_INPUT_ENDED =    103,    
    RS_BAD_MAGIC =      104,    
    RS_UNIMPLEMENTED =  105,    
    RS_CORRUPT =        106,    
    RS_INTERNAL_ERROR = 107,    
    RS_PARAM_ERROR =    108     
} rs_result;



char const *rs_strerror(rs_result r);


typedef struct rs_stats {
    char const     *op;     
    int             lit_cmds;   
    rs_long_t       lit_bytes;  
    rs_long_t       lit_cmdbytes; 
    rs_long_t       copy_cmds, copy_bytes, copy_cmdbytes;
    rs_long_t       sig_cmds, sig_bytes;
    int             false_matches;

    rs_long_t       sig_blocks; 
    size_t          block_len;

    rs_long_t       in_bytes;   
    rs_long_t       out_bytes;  
} rs_stats_t;


typedef struct rs_mdfour {
    int                 A, B, C, D;
    int                 totalN;
    int                 tail_len;
    unsigned char       tail[64];
} rs_mdfour_t;

#define RS_MD4_LENGTH 16

typedef unsigned int rs_weak_sum_t;
typedef unsigned char rs_strong_sum_t[RS_MD4_LENGTH];

void            rs_mdfour(unsigned char *out, void const *in, size_t); 
void            rs_mdfour_begin(/* @out@ */ rs_mdfour_t * md);
void            rs_mdfour_update(rs_mdfour_t * md, void const *,
                                 size_t n);
void rs_mdfour_result(rs_mdfour_t * md, unsigned char *out);

char *rs_format_stats(rs_stats_t const *, char *, size_t);

int rs_log_stats(rs_stats_t const *stats);


typedef struct rs_signature rs_signature_t;

void rs_free_sumset(rs_signature_t *);
void rs_sumset_dump(rs_signature_t const *);


struct rs_buffers_s {
    char *next_in;              
    size_t avail_in;            
    int eof_in;                 
    char *next_out;             
    size_t avail_out;           
};

typedef struct rs_buffers_s rs_buffers_t;

#define RS_DEFAULT_STRONG_LEN 8

#define RS_DEFAULT_BLOCK_LEN 2048


typedef struct rs_job rs_job_t;

typedef enum rs_work_options {
    RS_END = 0x01               
} rs_work_options;


rs_result       rs_job_iter(rs_job_t *, rs_buffers_t *);

typedef rs_result rs_driven_cb(rs_job_t *job, rs_buffers_t *buf,
                               void *opaque);

rs_result rs_job_drive(rs_job_t *job, rs_buffers_t *buf,
                       rs_driven_cb in_cb, void *in_opaque,
                       rs_driven_cb out_cb, void *out_opaque);

rs_result       rs_job_free(rs_job_t *);

int             rs_accum_value(rs_job_t *, char *sum, size_t sum_len);

rs_job_t *rs_sig_begin(size_t new_block_len, size_t strong_sum_len);

rs_job_t *rs_delta_begin(rs_signature_t *);

rs_job_t *rs_loadsig_begin(rs_signature_t **);

typedef rs_result rs_copy_cb(void *opaque, off_t pos,
                             size_t *len, void **buf);



rs_job_t *rs_patch_begin(rs_copy_cb *, void *copy_arg);


rs_result rs_build_hash_table(rs_signature_t* sums);



#ifndef RSYNC_NO_STDIO_INTERFACE

extern int rs_inbuflen, rs_outbuflen;


void rs_mdfour_file(FILE *in_file, char *result);

rs_result rs_sig_file(FILE *old_file, FILE *sig_file,
                      size_t block_len, size_t strong_len, rs_stats_t *); 

rs_result rs_loadsig_file(FILE *, rs_signature_t **, rs_stats_t *);

rs_result rs_file_copy_cb(void *arg, off_t pos, size_t *len, void **buf);

rs_result rs_delta_file(rs_signature_t *, FILE *new_file, FILE *delta_file, rs_stats_t *);

rs_result rs_patch_file(FILE *basis_file, FILE *delta_file, FILE *new_file, rs_stats_t *);
#endif

---