Initial revision

1 files changed, 317 insertions, 0 deletions

diff --git a/rsync/patch.c b/rsync/patch.c
new file mode 100644
index 0000000..d2daa85
--- a/dev/null
+++ b/rsync/patch.c
@@ -0,0 +1,317 @@
+/*= -*- c-basic-offset: 4; indent-tabs-mode: nil; -*-
+ *
+ * librsync -- the library for network deltas
+ * $Id$
+ * 
+ * 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.
+ */
+
+
+                              /*
+                               | This is Tranquility Base.
+                               */
+
+
+#include <config_rsync.h>
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "rsync.h"
+#include "util.h"
+#include "trace.h"
+#include "protocol.h"
+#include "netint.h"
+#include "command.h"
+#include "sumset.h"
+#include "prototab.h"
+#include "stream.h"
+#include "job.h"
+
+
+
+static rs_result rs_patch_s_cmdbyte(rs_job_t *);
+static rs_result rs_patch_s_params(rs_job_t *);
+static rs_result rs_patch_s_run(rs_job_t *);
+static rs_result rs_patch_s_literal(rs_job_t *);
+static rs_result rs_patch_s_copy(rs_job_t *);
+static rs_result rs_patch_s_copying(rs_job_t *);
+
+
+/**
+ * State of trying to read the first byte of a command.  Once we've
+ * taken that in, we can know how much data to read to get the
+ * arguments.
+ */
+static rs_result rs_patch_s_cmdbyte(rs_job_t *job)
+{
+    rs_result result;
+        
+    if ((result = rs_suck_byte(job, &job->op)) != RS_DONE)
+        return result;
+
+    job->cmd = &rs_prototab[job->op];
+        
+    rs_trace("got command byte 0x%02x (%s), len_1=%.0f", job->op,
+             rs_op_kind_name(job->cmd->kind),
+             (double) job->cmd->len_1);
+
+    if (job->cmd->len_1)
+        job->statefn = rs_patch_s_params;
+    else {
+        job->param1 = job->cmd->immediate;
+        job->statefn = rs_patch_s_run;
+    }
+
+    return RS_RUNNING;
+}
+
+
+/**
+ * Called after reading a command byte to pull in its parameters and
+ * then setup to execute the command.
+ */
+static rs_result rs_patch_s_params(rs_job_t *job)
+{
+    rs_result result;
+    int len = job->cmd->len_1 + job->cmd->len_2;
+    void *p;
+
+    assert(len);
+
+    result = rs_scoop_readahead(job, len, &p);
+    if (result != RS_DONE)
+        return result;
+
+    /* we now must have LEN bytes buffered */
+    result = rs_suck_netint(job, &job->param1, job->cmd->len_1);
+    /* shouldn't fail, since we already checked */
+    assert(result == RS_DONE);
+
+    if (job->cmd->len_2) {
+        result = rs_suck_netint(job, &job->param2, job->cmd->len_2);
+        assert(result == RS_DONE);
+    }
+
+    job->statefn = rs_patch_s_run;
+
+    return RS_RUNNING;
+}
+
+
+
+/**
+ * Called when we've read in the whole command and we need to execute it.
+ */
+static rs_result rs_patch_s_run(rs_job_t *job)
+{
+    rs_trace("running command 0x%x, kind %d", job->op, job->cmd->kind);
+
+    switch (job->cmd->kind) {
+    case RS_KIND_LITERAL:
+        job->statefn = rs_patch_s_literal;
+        return RS_RUNNING;
+        
+    case RS_KIND_END:
+        return RS_DONE;
+        /* so we exit here; trying to continue causes an error */
+
+    case RS_KIND_COPY:
+        job->statefn = rs_patch_s_copy;
+        return RS_RUNNING;
+
+    default:
+        rs_error("bogus command 0x%02x", job->op);
+        return RS_CORRUPT;
+    }
+}
+
+
+/**
+ * Called when trying to copy through literal data.
+ */
+static rs_result rs_patch_s_literal(rs_job_t *job)
+{
+    rs_long_t   len = job->param1;
+    
+    rs_trace("LITERAL(len=%.0f)", (double) len);
+
+    job->stats.lit_cmds++;
+    job->stats.lit_bytes    += len;
+    job->stats.lit_cmdbytes += 1 + job->cmd->len_1;
+
+    rs_tube_copy(job, len);
+
+    job->statefn = rs_patch_s_cmdbyte;
+    return RS_RUNNING;
+}
+
+
+
+static rs_result rs_patch_s_copy(rs_job_t *job)
+{
+    rs_long_t  where, len;
+    rs_stats_t      *stats;
+
+    where = job->param1;
+    len = job->param2;
+        
+    rs_trace("COPY(where=%.0f, len=%.0f)", (double) where, (double) len);
+
+    if (len < 0) {
+        rs_log(RS_LOG_ERR, "invalid length=%.0f on COPY command", (double) len);
+        return RS_CORRUPT;
+    }
+
+    if (where < 0) {
+        rs_log(RS_LOG_ERR, "invalid where=%.0f on COPY command", (double) where);
+        return RS_CORRUPT;
+    }
+
+    job->basis_pos = where;
+    job->basis_len = len;
+
+    stats = &job->stats;
+
+    stats->copy_cmds++;
+    stats->copy_bytes += len;
+    stats->copy_cmdbytes += 1 + job->cmd->len_1 + job->cmd->len_2;
+
+    job->statefn = rs_patch_s_copying;
+    return RS_RUNNING;
+}
+
+
+/**
+ * Called when we're executing a COPY command and waiting for all the
+ * data to be retrieved from the callback.
+ */
+static rs_result rs_patch_s_copying(rs_job_t *job)
+{
+    rs_result       result;
+    size_t          len;
+    void            *buf, *ptr;
+    rs_buffers_t    *buffs = job->stream;
+
+    len = job->basis_len;
+    
+    /* copy only as much as will fit in the output buffer, so that we
+     * don't have to block or store the input. */
+    if (len > buffs->avail_out)
+        len = buffs->avail_out;
+
+    if (!len)
+        return RS_BLOCKED;
+
+    rs_trace("copy %.0f bytes from basis at offset %.0f",
+             (double) len, (double) job->basis_pos);
+
+    ptr = buf = rs_alloc(len, "basis buffer");
+    
+    result = (job->copy_cb)(job->copy_arg, job->basis_pos, &len, &ptr);
+    if (result != RS_DONE)
+        return result;
+    else
+        rs_trace("copy callback returned %s", rs_strerror(result));
+    
+    rs_trace("got %.0f bytes back from basis callback", (double) len);
+
+    memcpy(buffs->next_out, ptr, len);
+
+    buffs->next_out += len;
+    buffs->avail_out -= len;
+
+    job->basis_pos += len;
+    job->basis_len -= len;
+
+    free(buf);
+
+    if (!job->basis_len) {
+        /* Done! */
+        job->statefn = rs_patch_s_cmdbyte;
+    } 
+
+    return RS_RUNNING;
+}
+
+
+/**
+ * Called while we're trying to read the header of the patch.
+ */
+static rs_result rs_patch_s_header(rs_job_t *job)
+{
+    int       v;
+    rs_result result;
+
+        
+    if ((result = rs_suck_n4(job, &v)) != RS_DONE)
+        return result;
+
+    if (v != RS_DELTA_MAGIC) {
+        rs_log(RS_LOG_ERR,
+               "got magic number %#x rather than expected value %#x",
+               v, RS_DELTA_MAGIC);
+        return RS_BAD_MAGIC;
+    } else
+        rs_trace("got patch magic %#x", v);
+
+
+    job->statefn = rs_patch_s_cmdbyte;
+
+    return RS_RUNNING;
+}
+
+
+
+/**
+ * \brief Apply a \ref gloss_delta to a \ref gloss_basis to recreate
+ * the new file.
+ *
+ * This gives you back a ::rs_job_t object, which can be cranked by
+ * calling rs_job_iter() and updating the stream pointers.  When
+ * finished, call rs_job_finish() to dispose of it.
+ *
+ * \param stream Contains pointers to input and output buffers, to be
+ * adjusted by caller on each iteration.
+ *
+ * \param copy_cb Callback used to retrieve content from the basis
+ * file.
+ *
+ * \param copy_arg Opaque environment pointer passed through to the
+ * callback.
+ *
+ * \todo As output is produced, accumulate the MD4 checksum of the
+ * output.  Then if we find a CHECKSUM command we can check it's
+ * contents against the output.
+ *
+ * \todo Implement COPY commands.
+ *
+ * \sa rs_patch_file()
+ */
+rs_job_t *
+rs_patch_begin(rs_copy_cb *copy_cb, void *copy_arg)
+{
+    rs_job_t *job = rs_job_new("patch", rs_patch_s_header);
+        
+    job->copy_cb = copy_cb;
+    job->copy_arg = copy_arg;
+
+    rs_mdfour_begin(&job->output_md4);
+
+    return job;
+}