replay.c

subversion-1.4.3-1.tar.gz 配置svn的源码

            else
              rev = SVN_INVALID_REVNUM;

            rb->err = rb->editor->add_file(path, parent->baton, cpath, rev,
                                           parent->file_pool, &rb->file_baton);
          }
        else
          {
            const char *crev = svn_xml_get_attr_value("rev", atts);

            if (crev)
              rev = SVN_STR_TO_REV(crev);
            else
              rev = SVN_INVALID_REVNUM;

            rb->err = rb->editor->open_file(path, parent->baton, rev,
                                            parent->file_pool,
                                            &rb->file_baton);
          }
      }
      break;

    case ELEM_apply_textdelta:
      if (! rb->file_baton)
        rb->err = svn_error_create
                    (SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
                     _("Got apply-textdelta element without preceding "
                       "add-file or open-file"));
      else
        {
          const char *checksum = svn_xml_get_attr_value("checksum", atts);

          rb->err = rb->editor->apply_textdelta(rb->file_baton,
                                                checksum,
                                                TOP_DIR(rb).file_pool,
                                                &rb->whandler,
                                                &rb->whandler_baton);
          if (! rb->err)
            {
              rb->svndiff_decoder = svn_txdelta_parse_svndiff
                                      (rb->whandler, rb->whandler_baton,
                                       TRUE, TOP_DIR(rb).file_pool);
              rb->base64_decoder = svn_base64_decode(rb->svndiff_decoder,
                                                     TOP_DIR(rb).file_pool);
            }
        }
      break;

    case ELEM_close_file:
      if (! rb->file_baton)
        rb->err = svn_error_create
                    (SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
                     _("Got close-file element without preceding "
                       "add-file or open-file"));
      else
        {
          const char *checksum = svn_xml_get_attr_value("checksum", atts);

          rb->err = rb->editor->close_file(rb->file_baton,
                                           checksum,
                                           TOP_DIR(rb).file_pool);
          rb->file_baton = NULL;
        }
      break;

    case ELEM_close_directory:
      if (rb->dirs->nelts == 0)
        rb->err = svn_error_create
                    (SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
                     _("Got close-directory element without ever opening "
                       "a directory"));
      else
        {
          dir_item_t *di = &TOP_DIR(rb);

          rb->err = rb->editor->close_directory(di->baton, di->pool);

          svn_pool_destroy(di->pool);

          apr_array_pop(rb->dirs);
        }
      break;

    case ELEM_change_file_prop:
    case ELEM_change_dir_prop:
      {
        const char *name = svn_xml_get_attr_value("name", atts);

        if (! name)
          rb->err = svn_error_createf
                      (SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
                       _("Missing name attr in %s element"),
                       elm->id == ELEM_change_file_prop ? "change-file-prop"
                                                        : "change-dir-prop");
        else
          {
            svn_pool_clear(rb->prop_pool);

            if (svn_xml_get_attr_value("del", atts))
              rb->prop_accum = NULL;
            else
              rb->prop_accum = svn_stringbuf_create("", rb->prop_pool);

            rb->prop_name = apr_pstrdup(rb->prop_pool, name);
          }
      }
      break;
    }

  if (rb->err)
    return NE_XML_ABORT;

  return elm->id;
}

static int
end_element(void *baton, int state, const char *nspace, const char *elt_name)
{
  replay_baton_t *rb = baton;

  const svn_ra_dav__xml_elm_t *elm
    = svn_ra_dav__lookup_xml_elem(editor_report_elements, nspace, elt_name);

  if (! elm)
    return NE_XML_DECLINE;

  switch (elm->id)
    {
    case ELEM_editor_report:
      if (rb->dirs->nelts)
        svn_pool_destroy(APR_ARRAY_IDX(rb->dirs, 0, dir_item_t).pool);

      rb->err = SVN_NO_ERROR;
      break;

    case ELEM_apply_textdelta:
      rb->err = svn_stream_close(rb->base64_decoder);

      rb->whandler = NULL;
      rb->whandler_baton = NULL;
      rb->svndiff_decoder = NULL;
      rb->base64_decoder = NULL;
      break;

    case ELEM_change_file_prop:
    case ELEM_change_dir_prop:
      {
        const svn_string_t *decoded_value;
        svn_string_t prop;

        if (rb->prop_accum)
          {
            prop.data = rb->prop_accum->data;
            prop.len = rb->prop_accum->len;

            decoded_value = svn_base64_decode_string(&prop, rb->prop_pool);
          }
        else
          decoded_value = NULL; /* It's a delete */

        if (elm->id == ELEM_change_dir_prop)
          rb->err = rb->editor->change_dir_prop(TOP_DIR(rb).baton,
                                                rb->prop_name,
                                                decoded_value,
                                                TOP_DIR(rb).pool);
        else
          rb->err = rb->editor->change_file_prop(rb->file_baton,
                                                 rb->prop_name,
                                                 decoded_value,
                                                 TOP_DIR(rb).file_pool);
      }
      break;

    default:
      break;
    }

  if (rb->err)
    return NE_XML_ABORT;

  return SVN_RA_DAV__XML_VALID;
}

static int
cdata_handler(void *baton, int state, const char *cdata, size_t len)
{
  replay_baton_t *rb = baton;
  apr_size_t nlen = len;

  switch (state)
    {
    case ELEM_apply_textdelta:
      rb->err = svn_stream_write(rb->base64_decoder, cdata, &nlen);
      if (! rb->err && nlen != len)
        rb->err = svn_error_createf
                    (SVN_ERR_STREAM_UNEXPECTED_EOF, NULL,
                     _("Error writing stream: unexpected EOF"));
      break;

    case ELEM_change_dir_prop:
    case ELEM_change_file_prop:
      if (! rb->prop_accum)
        rb->err = svn_error_createf(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
                                    _("Got cdata content for a prop delete"));
      else
        svn_stringbuf_appendbytes(rb->prop_accum, cdata, len);
      break;
    }

  if (rb->err)
    return NE_XML_ABORT;

  return 0; /* no error */
}

svn_error_t *
svn_ra_dav__replay(svn_ra_session_t *session,
                   svn_revnum_t revision,
                   svn_revnum_t low_water_mark,
                   svn_boolean_t send_deltas,
                   const svn_delta_editor_t *editor,
                   void *edit_baton,
                   apr_pool_t *pool)
{
  svn_ra_dav__session_t *ras = session->priv;
  replay_baton_t rb;

  const char *body
    = apr_psprintf(pool,
                   "<S:replay-report xmlns:S=\"svn:\">\n"
                   "  <S:revision>%ld</S:revision>\n"
                   "  <S:low-water-mark>%ld</S:low-water-mark>\n"
                   "  <S:send-deltas>%d</S:send-deltas>\n"
                   "</S:replay-report>",
                   revision, low_water_mark, send_deltas);

  memset(&rb, 0, sizeof(rb));

  rb.editor = editor;
  rb.edit_baton = edit_baton;
  rb.err = SVN_NO_ERROR;
  rb.pool = pool;
  rb.dirs = apr_array_make(pool, 5, sizeof(dir_item_t));
  rb.prop_pool = svn_pool_create(pool);
  rb.prop_accum = svn_stringbuf_create("", rb.prop_pool);

  SVN_ERR(svn_ra_dav__parsed_request(ras->sess, "REPORT", ras->url->data, body,
                                     NULL, NULL,
                                     start_element,
                                     cdata_handler,
                                     end_element,
                                     &rb,
                                     NULL, /* extra headers */
                                     NULL, /* status code */
                                     FALSE, /* spool response */
                                     pool));

  return rb.err;
}