自学教程：C++ svn_error_create函数代码示例

static svn_error_t *split_url_syntax(const char **msg,                 svn_boolean_t msg_only,                 svn_test_opts_t *opts,                 apr_pool_t *pool){  apr_status_t apr_err;  *msg = "svn_ra_local__split_URL: syntax validation";  if (msg_only)    return SVN_NO_ERROR;  /* TEST 1:  Make sure we can recognize bad URLs (this should not     require a filesystem) */  /* Use `blah' for scheme instead of `file' */  apr_err = try_split_url("blah:///bin/svn", pool);  if (apr_err != SVN_ERR_RA_ILLEGAL_URL)    return svn_error_create      (SVN_ERR_TEST_FAILED, NULL,       "svn_ra_local__split_URL failed to catch bad URL (scheme)");  /* Use only single slash after scheme */  apr_err = try_split_url("file:/path/to/repos", pool);  if (apr_err != SVN_ERR_RA_ILLEGAL_URL)    return svn_error_create      (SVN_ERR_TEST_FAILED, NULL,       "svn_ra_local__split_URL failed to catch bad URL (slashes)");  /* Use only a hostname, with no path */  apr_err = try_split_url("file://hostname", pool);  if (apr_err != SVN_ERR_RA_ILLEGAL_URL)    return svn_error_create      (SVN_ERR_TEST_FAILED, NULL,       "svn_ra_local__split_URL failed to catch bad URL (no path)");  return SVN_NO_ERROR;}

svn_error_t *svn_fs_fs__dag_set_entry(dag_node_t *node,                         const char *entry_name,                         const svn_fs_id_t *id,                         svn_node_kind_t kind,                         const char *txn_id,                         apr_pool_t *pool){    /* Check it's a directory. */    if (node->kind != svn_node_dir)        return svn_error_create               (SVN_ERR_FS_NOT_DIRECTORY, NULL,                _("Attempted to set entry in non-directory node"));    /* Check it's mutable. */    if (! svn_fs_fs__dag_check_mutable(node))        return svn_error_create               (SVN_ERR_FS_NOT_MUTABLE, NULL,                _("Attempted to set entry in immutable node"));    return set_entry(node, entry_name, id, kind, txn_id, pool);}

svn_error_t *svn_spillbuf__reader_getc(char *c,                          svn_spillbuf_reader_t *reader,                          apr_pool_t *scratch_pool){  apr_size_t amt;  SVN_ERR(svn_spillbuf__reader_read(&amt, reader, c, 1, scratch_pool));  if (amt == 0)    return svn_error_create(SVN_ERR_STREAM_UNEXPECTED_EOF, NULL, NULL);  return SVN_NO_ERROR;}

svn_error_t *svn_ra_neon__replay_range(svn_ra_session_t *session,                          svn_revnum_t start_revision,                          svn_revnum_t end_revision,                          svn_revnum_t low_water_mark,                          svn_boolean_t send_deltas,                          svn_ra_replay_revstart_callback_t revstart_func,                          svn_ra_replay_revfinish_callback_t revfinish_func,                          void *replay_baton,                          apr_pool_t *pool){  return svn_error_create(SVN_ERR_RA_NOT_IMPLEMENTED, NULL, NULL);}

static svn_error_t *reconcile_errors(svn_error_t *commit_err,                 svn_error_t *unlock_err,                 svn_error_t *bump_err,                 apr_pool_t *pool){  svn_error_t *err;  /* Early release (for good behavior). */  if (! (commit_err || unlock_err || bump_err))    return SVN_NO_ERROR;  /* If there was a commit error, start off our error chain with     that. */  if (commit_err)    {      commit_err = svn_error_quick_wrap        (commit_err, _("Commit failed (details follow):"));      err = commit_err;    }  /* Else, create a new "general" error that will lead off the errors     that follow. */  else    err = svn_error_create(SVN_ERR_BASE, NULL,                           _("Commit succeeded, but other errors follow:"));  /* If there was an unlock error... */  if (unlock_err)    {      /* Wrap the error with some headers. */      unlock_err = svn_error_quick_wrap        (unlock_err, _("Error unlocking locked dirs (details follow):"));      /* Append this error to the chain. */      svn_error_compose(err, unlock_err);    }  /* If there was a bumping error... */  if (bump_err)    {      /* Wrap the error with some headers. */      bump_err = svn_error_quick_wrap        (bump_err, _("Error bumping revisions post-commit (details follow):"));      /* Append this error to the chain. */      svn_error_compose(err, bump_err);    }  return err;}

svn_error_t *svn_cl__make_log_msg_baton(void **baton,                           svn_cl__opt_state_t *opt_state,                           const char *base_dir /* UTF-8! */,                           apr_hash_t *config,                           apr_pool_t *pool){  struct log_msg_baton *lmb = apr_palloc(pool, sizeof(*lmb));  if (opt_state->filedata)    {      if (strlen(opt_state->filedata->data) < opt_state->filedata->len)        {          /* The data contains a zero byte, and therefore can't be             represented as a C string.  Punt now; it's probably not             a deliberate encoding, and even if it is, we still             can't handle it. */          return svn_error_create(SVN_ERR_CL_BAD_LOG_MESSAGE, NULL,                                  _("Log message contains a zero byte"));        }      lmb->message = opt_state->filedata->data;    }  else    {      lmb->message = opt_state->message;    }  lmb->editor_cmd = opt_state->editor_cmd;  if (opt_state->encoding)    {      lmb->message_encoding = opt_state->encoding;    }  else if (config)    {      svn_config_t *cfg = apr_hash_get(config, SVN_CONFIG_CATEGORY_CONFIG,                                       APR_HASH_KEY_STRING);      svn_config_get(cfg, &(lmb->message_encoding),                     SVN_CONFIG_SECTION_MISCELLANY,                     SVN_CONFIG_OPTION_LOG_ENCODING,                     NULL);    }  lmb->base_dir = base_dir ? base_dir : "";  lmb->tmpfile_left = NULL;  lmb->config = config;  lmb->keep_locks = opt_state->no_unlock;  lmb->non_interactive = opt_state->non_interactive;  lmb->pool = pool;  *baton = lmb;  return SVN_NO_ERROR;}

/* * ASN.1 DER decoding routines */static svn_error_t *asn1_get_len(const unsigned char **p, const unsigned char *end,             ptrdiff_t *len){  if ((end - *p) < 1)    return svn_error_create(SVN_ERR_ASN1_OUT_OF_DATA, NULL, NULL);  if ((**p & 0x80) == 0)    *len = *(*p)++;  else    switch (**p & 0x7F)      {      case 1:        if ((end - *p) < 2)          return svn_error_create(SVN_ERR_ASN1_OUT_OF_DATA, NULL, NULL);        *len = (*p)[1];        (*p) += 2;        break;      case 2:        if ((end - *p) < 3)          return svn_error_create(SVN_ERR_ASN1_OUT_OF_DATA, NULL, NULL);        *len = ((*p)[1] << 8) | (*p)[2];        (*p) += 3;        break;      default:        return svn_error_create(SVN_ERR_ASN1_INVALID_LENGTH, NULL, NULL);        break;      }  if (*len > (end - *p))    return svn_error_create(SVN_ERR_ASN1_OUT_OF_DATA, NULL, NULL);  return SVN_NO_ERROR;}

/* For HTTPv1 servers, do a PROPFIND dance on the VCC to fetch the youngest   revnum. If BASECOLL_URL is non-NULL, then the corresponding baseline   collection URL is also returned.   Do the work over CONN.   *BASECOLL_URL (if requested) will be allocated in RESULT_POOL. All   temporary allocations will be made in SCRATCH_POOL.  */static svn_error_t *v1_get_youngest_revnum(svn_revnum_t *youngest,                       const char **basecoll_url,                       svn_ra_serf__session_t *session,                       const char *vcc_url,                       apr_pool_t *result_pool,                       apr_pool_t *scratch_pool){  const char *baseline_url;  const char *bc_url;  /* Fetching DAV:checked-in from the VCC (with no Label: to specify a     revision) will return the latest Baseline resource's URL.  */  SVN_ERR(svn_ra_serf__fetch_dav_prop(&baseline_url, session, vcc_url,                                      SVN_INVALID_REVNUM,                                      "checked-in",                                      scratch_pool, scratch_pool));  if (!baseline_url)    {      return svn_error_create(SVN_ERR_RA_DAV_OPTIONS_REQ_FAILED, NULL,                              _("The OPTIONS response did not include "                                "the requested checked-in value"));    }  baseline_url = svn_urlpath__canonicalize(baseline_url, scratch_pool);  /* From the Baseline resource, we can fetch the DAV:baseline-collection     and DAV:version-name properties. The latter is the revision number,     which is formally the name used in Label: headers.  */  /* First check baseline information cache. */  SVN_ERR(svn_ra_serf__blncache_get_baseline_info(&bc_url,                                                  youngest,                                                  session->blncache,                                                  baseline_url,                                                  scratch_pool));  if (!bc_url)    {      SVN_ERR(retrieve_baseline_info(youngest, &bc_url, session,                                     baseline_url, SVN_INVALID_REVNUM,                                     scratch_pool, scratch_pool));      SVN_ERR(svn_ra_serf__blncache_set(session->blncache,                                        baseline_url, *youngest,                                        bc_url, scratch_pool));    }  if (basecoll_url != NULL)    *basecoll_url = apr_pstrdup(result_pool, bc_url);  return SVN_NO_ERROR;}

/* Parse the conflict info fields from SKEL into *VERSION_INFO. */static svn_error_t *read_node_version_info(const svn_wc_conflict_version_t **version_info,                       const svn_skel_t *skel,                       apr_pool_t *result_pool,                       apr_pool_t *scratch_pool){  int n;  const char *repos_root;  const char *repos_relpath;  svn_revnum_t peg_rev;  svn_node_kind_t kind;  if (!is_valid_version_info_skel(skel))    return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,                            _("Invalid version info in tree conflict "                              "description"));  repos_root = apr_pstrmemdup(scratch_pool,                              skel->children->next->data,                              skel->children->next->len);  if (*repos_root == '/0')    {      *version_info = NULL;      return SVN_NO_ERROR;    }  /* Apply the Subversion 1.7+ url canonicalization rules to a pre 1.7 url */  repos_root = svn_uri_canonicalize(repos_root, result_pool);  peg_rev = SVN_STR_TO_REV(apr_pstrmemdup(scratch_pool,                                          skel->children->next->next->data,                                          skel->children->next->next->len));  repos_relpath = apr_pstrmemdup(result_pool,                                 skel->children->next->next->next->data,                                 skel->children->next->next->next->len);  SVN_ERR(read_enum_field(&n, node_kind_map,                          skel->children->next->next->next->next));  kind = (svn_node_kind_t)n;  *version_info = svn_wc_conflict_version_create2(repos_root,                                                  NULL,                                                  repos_relpath,                                                  peg_rev,                                                  kind,                                                  result_pool);  return SVN_NO_ERROR;}

svn_error_t *svn_repos_fs_unlock(svn_repos_t *repos,                    const char *path,                    const char *token,                    svn_boolean_t break_lock,                    apr_pool_t *pool){    svn_error_t *err;    svn_fs_access_t *access_ctx = NULL;    const char *username = NULL;    apr_array_header_t *paths;    apr_hash_t *hooks_env;    /* Parse the hooks-env file (if any). */    SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, repos->hooks_env_path,                                       pool, pool));    /* Setup an array of paths in anticipation of the ra layers handling       multiple locks in one request (1.3 most likely).  This is only       used by svn_repos__hooks_post_lock. */    paths = apr_array_make(pool, 1, sizeof(const char *));    APR_ARRAY_PUSH(paths, const char *) = path;    SVN_ERR(svn_fs_get_access(&access_ctx, repos->fs));    if (access_ctx)        SVN_ERR(svn_fs_access_get_username(&username, access_ctx));    if (! break_lock && ! username)        return svn_error_createf               (SVN_ERR_FS_NO_USER, NULL,                _("Cannot unlock path '%s', no authenticated username available"),                path);    /* Run pre-unlock hook.  This could throw error, preventing       svn_fs_unlock() from happening. */    SVN_ERR(svn_repos__hooks_pre_unlock(repos, hooks_env, path, username, token,                                        break_lock, pool));    /* Unlock. */    SVN_ERR(svn_fs_unlock(repos->fs, path, token, break_lock, pool));    /* Run post-unlock hook. */    if ((err = svn_repos__hooks_post_unlock(repos, hooks_env, paths,                                            username, pool)))        return svn_error_create               (SVN_ERR_REPOS_POST_UNLOCK_HOOK_FAILED, err,                _("Unlock succeeded, but post-unlock hook failed"));    return SVN_NO_ERROR;}

  /**   * a quick way to create error messages   */  static void  fail(apr_pool_t *pool, apr_status_t status, const char *fmt, ...)  {    va_list ap;    char *msg;    svn_error_t * error;    va_start(ap, fmt);    msg = apr_pvsprintf(pool, fmt, ap);    va_end(ap);    error = svn_error_create(status, nullptr, msg);    throw ClientException(error);  }

static svn_error_t *start_gls(svn_ra_serf__xml_parser_t *parser,          void *userData,          svn_ra_serf__dav_props_t name,          const char **attrs){  gls_context_t *gls_ctx = userData;  if ((! gls_ctx->inside_report)      && strcmp(name.name, "get-location-segments-report") == 0)    {      gls_ctx->inside_report = TRUE;    }  else if (gls_ctx->inside_report           && strcmp(name.name, "location-segment") == 0)    {      const char *rev_str;      svn_revnum_t range_start = SVN_INVALID_REVNUM;      svn_revnum_t range_end = SVN_INVALID_REVNUM;      const char *path = NULL;      path = svn_xml_get_attr_value("path", attrs);      rev_str = svn_xml_get_attr_value("range-start", attrs);      if (rev_str)        range_start = SVN_STR_TO_REV(rev_str);      rev_str = svn_xml_get_attr_value("range-end", attrs);      if (rev_str)        range_end = SVN_STR_TO_REV(rev_str);      if (SVN_IS_VALID_REVNUM(range_start) && SVN_IS_VALID_REVNUM(range_end))        {          svn_location_segment_t *segment = apr_pcalloc(gls_ctx->subpool,                                                        sizeof(*segment));          segment->path = path;          segment->range_start = range_start;          segment->range_end = range_end;          SVN_ERR(gls_ctx->receiver(segment,                                    gls_ctx->receiver_baton,                                    gls_ctx->subpool));          svn_pool_clear(gls_ctx->subpool);        }      else        {          return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,                                  _("Expected valid revision range"));        }    }  return SVN_NO_ERROR;}

/* This implements svn_editor_cb_add_absent_t */static svn_error_t *add_absent_cb(void *baton,              const char *relpath,              svn_node_kind_t kind,              svn_revnum_t replaces_rev,              apr_pool_t *scratch_pool){    /* This is a programming error. Code should not attempt to create these       kinds of nodes within the FS.  */    /* ### use a custom error code  */    return svn_error_create(               SVN_ERR_UNSUPPORTED_FEATURE, NULL,               _("The filesystem does not support 'absent' nodes"));}

/* Display a prompt and read a one-line response into the provided buffer,   removing a trailing newline if present. */static svn_error_t *prompt_and_read_line(const char *prompt,                     char *buffer,                     size_t max){  int len;  printf("%s: ", prompt);  if (fgets(buffer, max, stdin) == NULL)    return svn_error_create(0, NULL, "error reading stdin");  len = strlen(buffer);  if (len > 0 && buffer[len-1] == '/n')    buffer[len-1] = 0;  return SVN_NO_ERROR;}

/* Loads the properties of a node to a temporary file */static svn_error_t *delta_load_properties(de_node_baton_t *node){	char *filename;	apr_file_t *file = NULL;	apr_status_t status;	apr_pool_t *pool = svn_pool_create(node->pool);	filename = rhash_get(prop_hash, node->path, APR_HASH_KEY_STRING);	if (filename == NULL) {		/* No properties is ok, too */		svn_pool_destroy(pool);		return SVN_NO_ERROR;	}	status = apr_file_open(&file, filename, APR_READ, 0600, pool);	if (status) {		apr_pool_t *epool = svn_pool_create(NULL);		char *errbuf = apr_palloc(epool, ERRBUFFER_SIZE);		svn_pool_destroy(pool);		return svn_error_create(status, NULL, apr_strerror(status, errbuf, ERRBUFFER_SIZE));	}	if (property_hash_load(node->properties, file, node->pool)) {		apr_file_close(file);		DEBUG_MSG("ERROR reading from %s/n", filename);		return svn_error_create(1, NULL, "Error reading properties file");	}	apr_file_close(file);	/* Delete the old file if it exists */	apr_file_remove(filename, pool);	rhash_set(prop_hash, node->path, APR_HASH_KEY_STRING, NULL, 0);	svn_pool_destroy(pool);	return SVN_NO_ERROR;}

static svn_error_t *change_txn_prop(svn_fs_txn_t *txn,                const char *propname,                const svn_string_t *value,                apr_pool_t *scratch_pool){  if (strcmp(propname, SVN_PROP_REVISION_AUTHOR) == 0)    return svn_error_create(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,                            "Attempted to modify 'svn:author' property "                            "on a transaction");  SVN_ERR(svn_repos_fs_change_txn_prop(txn, propname, value, scratch_pool));  return SVN_NO_ERROR;}

svn_error_t *svn_fs_x__dag_dir_entries(apr_hash_t **entries,                           dag_node_t *node,                           apr_pool_t *pool){  node_revision_t *noderev;  SVN_ERR(get_node_revision(&noderev, node));  if (noderev->kind != svn_node_dir)    return svn_error_create(SVN_ERR_FS_NOT_DIRECTORY, NULL,                            _("Can't get entries of non-directory"));  return svn_fs_x__rep_contents_dir(entries, node->fs, noderev, pool);}

/* Don't call this function directly!  Use svn_atomic__init_once(). */static svn_error_t *init_sqlite(void *baton, apr_pool_t *pool){  if (sqlite3_libversion_number() < SQLITE_VERSION_NUMBER)    {      return svn_error_createf(                    SVN_ERR_SQLITE_ERROR, NULL,                    _("SQLite compiled for %s, but running with %s"),                    SQLITE_VERSION, sqlite3_libversion());    }#if APR_HAS_THREADS  /* SQLite 3.5 allows verification of its thread-safety at runtime.     Older versions are simply expected to have been configured with     --enable-threadsafe, which compiles with -DSQLITE_THREADSAFE=1     (or -DTHREADSAFE, for older versions). */  if (! sqlite3_threadsafe())    return svn_error_create(SVN_ERR_SQLITE_ERROR, NULL,                            _("SQLite is required to be compiled and run in "                              "thread-safe mode"));  /* If SQLite has been already initialized, sqlite3_config() returns     SQLITE_MISUSE. */  {    int err = sqlite3_config(SQLITE_CONFIG_MULTITHREAD);    if (err != SQLITE_OK && err != SQLITE_MISUSE)      return svn_error_create(SQLITE_ERROR_CODE(err), NULL,                              _("Could not configure SQLite"));  }  SQLITE_ERR_MSG(sqlite3_initialize(), _("Could not initialize SQLite"));#endif /* APR_HAS_THRADS */  return SVN_NO_ERROR;}

static svn_error_t *rollback_transaction(svn_sqlite__db_t *db,                     svn_error_t *error_to_wrap){  svn_sqlite__stmt_t *stmt;  svn_error_t *err;  err = get_internal_statement(&stmt, db, STMT_INTERNAL_ROLLBACK_TRANSACTION);  if (!err)    {      err = svn_error_trace(svn_sqlite__step_done(stmt));      if (err && err->apr_err == SVN_ERR_SQLITE_BUSY)        {          /* ### Houston, we have a problem!             We are trying to rollback but we can't because some             statements are still busy. This leaves the database             unusable for future transactions as the current transaction             is still open.             As we are returning the actual error as the most relevant             error in the chain, our caller might assume that it can             retry/compensate on this error (e.g. SVN_WC_LOCKED), while             in fact the SQLite database is unusable until the statements             started within this transaction are reset and the transaction             aborted.             We try to compensate by resetting all prepared but unreset             statements; but we leave the busy error in the chain anyway to             help diagnosing the original error and help in finding where             a reset statement is missing. */          err = svn_error_trace(reset_all_statements(db, err));          err = svn_error_compose_create(                      svn_error_trace(svn_sqlite__step_done(stmt)),                      err);        }    }  if (err)    {      /* Rollback failed, use a specific error code. */      err = svn_error_create(SVN_SQLITE__ERR_ROLLBACK_FAILED, err,                             _("SQLite transaction rollback failed"));    }  return svn_error_compose_create(error_to_wrap, err);}

/* This implements the `svn_opt_subcommand_t' interface. */svn_error_t *svn_cl__cat(apr_getopt_t *os,            void *baton,            apr_pool_t *pool){  svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;  svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;  apr_array_header_t *targets;  int i;  svn_stream_t *out;  apr_pool_t *subpool = svn_pool_create(pool);  SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,                                                      opt_state->targets,                                                      ctx, pool));  /* Cat cannot operate on an implicit '.' so a filename is required */  if (! targets->nelts)    return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL);  SVN_ERR(svn_stream_for_stdout(&out, pool));  for (i = 0; i < targets->nelts; i++)    {      const char *target = APR_ARRAY_IDX(targets, i, const char *);      const char *truepath;      svn_opt_revision_t peg_revision;      svn_pool_clear(subpool);      SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));      /* Get peg revisions. */      SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target,                                 subpool));      SVN_ERR(svn_cl__try(svn_client_cat2(out, truepath, &peg_revision,                                          &(opt_state->start_revision),                                          ctx, subpool),                           NULL, opt_state->quiet,                           SVN_ERR_UNVERSIONED_RESOURCE,                           SVN_ERR_ENTRY_NOT_FOUND,                           SVN_ERR_CLIENT_IS_DIRECTORY,                           SVN_NO_ERROR));    }  svn_pool_destroy(subpool);  return SVN_NO_ERROR;}

/* Parse the enumeration value in VALUE into a plain * 'int', using MAP to convert from strings to enumeration values. * In MAP, a null .str field marks the end of the map. */static svn_error_t *read_enum_field(int *result,                const svn_token_map_t *map,                const svn_skel_t *skel){  int value = svn_token__from_mem(map, skel->data, skel->len);  if (value == SVN_TOKEN_UNKNOWN)    return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,                            _("Unknown enumeration value in tree conflict "                              "description"));  *result = value;  return SVN_NO_ERROR;}

svn_error_t *svn_sqlite__exec(svn_sqlite__db_t *db, const char *sql){  char *err_msg;  int sqlite_err = sqlite3_exec(db->db3, sql, NULL, NULL, &err_msg);  if (sqlite_err != SQLITE_OK)    {      svn_error_t *err = svn_error_create(SQLITE_ERROR_CODE(sqlite_err), NULL,                                          err_msg);      sqlite3_free(err_msg);      return err;    }  return SVN_NO_ERROR;}

svn_error_t *svn_wc__db_verify_no_work(svn_sqlite__db_t *sdb){  svn_sqlite__stmt_t *stmt;  svn_boolean_t have_row;  SVN_ERR(svn_sqlite__get_statement(&stmt, sdb, STMT_LOOK_FOR_WORK));  SVN_ERR(svn_sqlite__step(&have_row, stmt));  SVN_ERR(svn_sqlite__reset(stmt));  if (have_row)    return svn_error_create(SVN_ERR_WC_CLEANUP_REQUIRED, NULL,                            NULL /* nothing to add.  */);  return SVN_NO_ERROR;}

static svn_error_t *stream_write(svn_stream_t *out,             const char *data,             apr_size_t len){  apr_size_t write_len = len;  /* We're gonna bail on an incomplete write here only because we know     that this stream is really stdout, which should never be blocking     on us. */  SVN_ERR(svn_stream_write(out, data, &write_len));  if (write_len != len)    return svn_error_create(SVN_ERR_STREAM_UNEXPECTED_EOF, NULL,                            _("Error writing to stream"));  return SVN_NO_ERROR;}

/* Implements svn_cache__deserialize_func_t */static svn_error_t *deserialize_id(void **out,               const char *data,               apr_size_t data_len,               apr_pool_t *pool){  svn_fs_id_t *id = svn_fs_fs__id_parse(data, data_len, pool);  if (id == NULL)    {      return svn_error_create(SVN_ERR_FS_NOT_ID, NULL,                              _("Bad ID in cache"));    }  *out = id;  return SVN_NO_ERROR;}

static svn_error_t *write_rep(const char **msg,          svn_boolean_t msg_only,          svn_test_opts_t *opts,          apr_pool_t *pool){  struct rep_args new_args;  struct rep_args args;  const char *new_rep = "((fulltext 0 ) a83t2Z0q)";  const char *rep = "((fulltext 0 ) kfogel31337)";  svn_fs_t *fs;  *msg = "write a new rep, then overwrite it";  if (msg_only)    return SVN_NO_ERROR;  /* Create a new fs and repos */  SVN_ERR(svn_test__create_fs          (&fs, "test-repo-write-rep",           "bdb", pool));  /* Set up transaction baton */  new_args.fs = fs;  new_args.skel = svn_fs_base__parse_skel(new_rep, strlen(new_rep), pool);  new_args.key = NULL;  /* Write new rep to reps table. */  SVN_ERR(svn_fs_base__retry_txn(new_args.fs,                                 txn_body_write_new_rep, &new_args, pool));  /* Make sure we got a valid key. */  if (new_args.key == NULL)    return svn_error_create(SVN_ERR_FS_GENERAL, NULL,                            "error writing new representation");  /* Set up transaction baton for re-writing reps. */  args.fs = new_args.fs;  args.skel = svn_fs_base__parse_skel(rep, strlen(rep), pool);  args.key = new_args.key;  /* Overwrite first rep in reps table. */  SVN_ERR(svn_fs_base__retry_txn(new_args.fs,                                 txn_body_write_rep, &args, pool));  return SVN_NO_ERROR;}

/* This implements `svn_opt_subcommand_t'. */static svn_error_t *subcommand_index (apr_getopt_t *os, void *baton, apr_pool_t *pool){  struct svnindex_opt_state *opt_state = baton;  svn_repos_t *repos;  svn_fs_t *fs;  svn_stream_t *stderr_stream = NULL;  struct recode_write_baton stderr_stream_rwb = { 0 };  svn_revnum_t lower = SVN_INVALID_REVNUM, upper = SVN_INVALID_REVNUM;  svn_revnum_t youngest;  SVN_ERR (open_repos (&repos, opt_state->repository_path, pool));  fs = svn_repos_fs (repos);  SVN_ERR (svn_fs_youngest_rev (&youngest, fs, pool));  /* Find the revision numbers at which to start and end. */  SVN_ERR (get_revnum (&lower, &opt_state->start_revision,                       youngest, repos, pool));  SVN_ERR (get_revnum (&upper, &opt_state->end_revision,                       youngest, repos, pool));  if (lower > upper)    return svn_error_create      (SVN_ERR_CL_ARG_PARSING_ERROR, NULL,       _("First revision cannot be higher than second"));  /* Progress feedback goes to stderr, unless they asked to suppress     it. */  if (! opt_state->quiet)    {      stderr_stream = svn_stream_create (&stderr_stream_rwb, pool);      stderr_stream_rwb.pool = pool;      stderr_stream_rwb.out = stderr;      svn_stream_set_write (stderr_stream, recode_write);    }  SVN_ERR (svnindex__index (repos,                            stderr_stream,                            lower, upper,                            opt_state->verbose,                            opt_state->db,                            check_cancel,                            NULL,                            pool));  return SVN_NO_ERROR;}

static svn_error_t *initialize(void *baton, apr_pool_t *pool){  int result;  SVN_ERR(svn_ra_svn__sasl_common_init(pool));  /* The second parameter tells SASL to look for a configuration file     named subversion.conf. */  result = sasl_server_init(callbacks, SVN_RA_SVN_SASL_NAME);  if (result != SASL_OK)    {      svn_error_t *err = svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,                                          sasl_errstring(result, NULL, NULL));      return svn_error_quick_wrap(err,                                  _("Could not initialize the SASL library"));    }  return SVN_NO_ERROR;}