static int modssl_register_alpn(conn_rec *c, ssl_alpn_propose_protos advertisefn, ssl_alpn_proto_negotiated negotiatedfn) { #if defined(HAVE_ALPN_NPN) || defined(HAVE_TLS_NPN) SSLConnRec *sslconn = myConnConfig(c); if (!sslconn) { return DECLINED; } if (!sslconn->alpn_proposefns) { sslconn->alpn_proposefns = apr_array_make(c->pool, 5, sizeof(ssl_alpn_propose_protos)); sslconn->alpn_negofns = apr_array_make(c->pool, 5, sizeof(ssl_alpn_proto_negotiated)); } if (advertisefn) APR_ARRAY_PUSH(sslconn->alpn_proposefns, ssl_alpn_propose_protos) = advertisefn; if (negotiatedfn) APR_ARRAY_PUSH(sslconn->alpn_negofns, ssl_alpn_proto_negotiated) = negotiatedfn; return OK; #else return DECLINED; #endif }
/* Call this after a sequence of reads has been ended by either close() * or lseek() for this HANDLE_INFO. This will update the read_map and * unique_clusters_read members of the underlying file_info_t structure. */ static void store_read_info(handle_info_t *handle_info) { if (handle_info->last_read_size) { apr_size_t i; apr_size_t first_cluster = (apr_size_t)(handle_info->last_read_start / cluster_size); apr_size_t last_cluster = (apr_size_t)(( handle_info->last_read_start + handle_info->last_read_size - 1) / cluster_size); /* auto-expand access map in case the file later shrunk or got deleted */ while (handle_info->file->read_map->nelts <= last_cluster) APR_ARRAY_PUSH(handle_info->file->read_map, word) = 0; /* accumulate the accesses per cluster. Saturate and count first * (i.e. disjoint) accesses clusters */ handle_info->file->clusters_read += last_cluster - first_cluster + 1; for (i = first_cluster; i <= last_cluster; ++i) { word *count = &APR_ARRAY_IDX(handle_info->file->read_map, i, word); if (*count == 0) handle_info->file->unique_clusters_read++; if (*count < 0xffff) ++*count; } } else if (handle_info->read_count == 0) { /* two consecutive seeks */ handle_info->file->unnecessary_seeks++; } }
static svn_error_t * set_revision_property(void *baton, const char *name, const svn_string_t *value) { struct revision_baton *rb = baton; struct parse_baton *pb = rb->pb; svn_boolean_t is_date = strcmp(name, SVN_PROP_REVISION_DATE) == 0; svn_prop_t *prop; /* If we're skipping this revision, we're done here. */ if (rb->skipped) return SVN_NO_ERROR; /* If we're ignoring dates, and this is one, we're done here. */ if (is_date && pb->ignore_dates) return SVN_NO_ERROR; /* Collect property changes to apply them in one FS call in close_revision. */ prop = &APR_ARRAY_PUSH(rb->revprops, svn_prop_t); prop->name = apr_pstrdup(rb->pool, name); prop->value = svn_string_dup(value, rb->pool); /* Remember any datestamp that passes through! (See comment in close_revision() below.) */ if (is_date) rb->datestamp = svn_string_dup(value, rb->pool); return SVN_NO_ERROR; }
apr_array_header_t *source_line_blocks(term_t info, apr_pool_t *pool) { apr_array_header_t *refs = apr_array_make(pool, 64, sizeof(source_ref_t)); term_t cons = info; while (is_cons(cons)) { term_box_t *cb = peel(cons); term_t t = cb->cons.head; //{F,L,S,E} if (is_tuple(t)) { term_box_t *tb = peel(t); if (tb->tuple.size == 4) { source_ref_t *ref = &APR_ARRAY_PUSH(refs, source_ref_t); ref->file_index = int_value(tb->tuple.elts[0]); ref->source_line = int_value(tb->tuple.elts[1]); ref->off_starts = int_value(tb->tuple.elts[2]); ref->off_ends = int_value(tb->tuple.elts[3]); } } cons = cb->cons.tail; } return refs; }
/* Initializes the revision cache */ static void pr_cache_init(path_repo_t *repo, int size) { int i; repo->cache = apr_array_make(repo->pool, size, sizeof(pr_cache_entry_t)); for (i = 0; i < size; i++) { APR_ARRAY_PUSH(repo->cache, pr_cache_entry_t).revision = -1; APR_ARRAY_IDX(repo->cache, i, pr_cache_entry_t).tree = cb_tree_make(); } repo->cache_index = 0; }
apr_status_t kahanaIOReadDir( apr_pool_t *p, kDir_t **newDirObj, const char *path, apr_int32_t wanted, ... ) { apr_dir_t *dir = NULL; kDir_t *dirObj = NULL; apr_pool_t *sp = NULL; apr_status_t rc; if( ( rc = apr_dir_open( &dir, dirObj->path, p ) ) ){ kahanaLogPut( NULL, NULL, "failed to apr_dir_open(): %s", STRERROR_APR( rc ) ); } else if( ( rc = kahanaMalloc( p, sizeof( kDir_t ), (void**)&dirObj, &sp ) ) ){ kahanaLogPut( NULL, NULL, "failed to kahanaMalloc(): %s", STRERROR_APR( rc ) ); } else { apr_filetype_e type; va_list types; dirObj->p = sp; dirObj->files = apr_array_make( sp, 0, sizeof( apr_finfo_t ) ); dirObj->path = (const char*)apr_pstrdup( sp, path ); *newDirObj = dirObj; do { apr_finfo_t finfo = { 0 }; if( ( rc = apr_dir_read( &finfo, wanted, dir ) ) ){ kahanaLogPut( NULL, NULL, "failed to apr_dir_read(): %s", STRERROR_APR( rc ) ); break; } else { va_start( types, wanted ); while( ( type = va_arg( types, apr_filetype_e ) ) ) { if( finfo.filetype == type ){ APR_ARRAY_PUSH( dirObj->files, apr_finfo_t ) = finfo; break; } } va_end( types ); } } while( rc == APR_SUCCESS ); rc = ( rc == APR_ENOENT ) ? APR_SUCCESS : rc; if( ( rc = apr_dir_close( dir ) ) ){ kahanaLogPut( NULL, NULL, "failed to apr_dir_close(): %s", STRERROR_APR( rc ) ); } } return rc; }
int term2bin(term_t t, atoms_t *atoms, apr_array_header_t *buf) { if (is_int(t)) { int i = int_value(t); if (i >= 0 && i < 256) { APR_ARRAY_PUSH(buf, apr_byte_t) = 97; APR_ARRAY_PUSH(buf, apr_byte_t) = (apr_byte_t)i; } else { APR_ARRAY_PUSH(buf, apr_byte_t) = 98; APR_ARRAY_PUSH(buf, apr_byte_t) = (apr_byte_t)((i >> 24)); APR_ARRAY_PUSH(buf, apr_byte_t) = (apr_byte_t)((i >> 16) & 255); APR_ARRAY_PUSH(buf, apr_byte_t) = (apr_byte_t)((i >> 8) & 255); APR_ARRAY_PUSH(buf, apr_byte_t) = (apr_byte_t)((i) & 255); } } else if (is_float(t))
svn_error_t * svn_repos_fs_change_txn_prop(svn_fs_txn_t *txn, const char *name, const svn_string_t *value, apr_pool_t *pool) { apr_array_header_t *props = apr_array_make(pool, 1, sizeof(svn_prop_t)); svn_prop_t prop; prop.name = name; prop.value = value; APR_ARRAY_PUSH(props, svn_prop_t) = prop; return svn_repos_fs_change_txn_props(txn, props, pool); }
term_t term_to_binary(term_t t, atoms_t *atoms, heap_t *hp) { apr_pool_t *tmp; apr_array_header_t *buf; int result; term_t bin = noval; apr_pool_create(&tmp, 0); buf = apr_array_make(tmp, 1024, 1); APR_ARRAY_PUSH(buf, apr_byte_t) = 131; result = term2bin(t, atoms, buf); if (result == 0) bin = heap_binary(hp, buf->nelts*8, (apr_byte_t *)buf->elts); apr_pool_destroy(tmp); return bin; }
svn_error_t * svn_cl__try(svn_error_t *err, apr_array_header_t *errors_seen, svn_boolean_t quiet, ...) { if (err) { apr_status_t apr_err; va_list ap; va_start(ap, quiet); while ((apr_err = va_arg(ap, apr_status_t)) != APR_SUCCESS) { if (errors_seen) { int i; svn_boolean_t add = TRUE; /* Don't report duplicate error codes. */ for (i = 0; i < errors_seen->nelts; i++) { if (APR_ARRAY_IDX(errors_seen, i, apr_status_t) == err->apr_err) { add = FALSE; break; } } if (add) APR_ARRAY_PUSH(errors_seen, apr_status_t) = err->apr_err; } if (err->apr_err == apr_err) { if (! quiet) svn_handle_warning2(stderr, err, "svn: "); svn_error_clear(err); return SVN_NO_ERROR; } } va_end(ap); } return svn_error_trace(err); }
apr_array_header_t * svn_prop_hash_to_array(const apr_hash_t *hash, apr_pool_t *pool) { apr_hash_index_t *hi; apr_array_header_t *array = apr_array_make(pool, apr_hash_count((apr_hash_t *)hash), sizeof(svn_prop_t)); for (hi = apr_hash_first(pool, (apr_hash_t *)hash); hi; hi = apr_hash_next(hi)) { const void *key; void *val; svn_prop_t prop; apr_hash_this(hi, &key, NULL, &val); prop.name = key; prop.value = val; APR_ARRAY_PUSH(array, svn_prop_t) = prop; } return array; }
/* Handle a open() call. Ensures that a file_info_t for the given NAME * exists. Auto-create and initialize a handle_info_t for it linked to * HANDLE. */ static void open_file(const char *name, int handle) { file_stats_t *file = apr_hash_get(files, name, APR_HASH_KEY_STRING); handle_info_t *handle_info = apr_hash_get(handles, &handle, sizeof(handle)); /* auto-create file info */ if (!file) { apr_pool_t *pool = apr_hash_pool_get(files); apr_pool_t *subpool = svn_pool_create(pool); apr_file_t *apr_file = NULL; apr_finfo_t finfo = { 0 }; int cluster_count = 0; /* determine file size (if file still exists) */ apr_file_open(&apr_file, name, APR_READ | APR_BUFFERED, APR_OS_DEFAULT, subpool); if (apr_file) apr_file_info_get(&finfo, APR_FINFO_SIZE, apr_file); svn_pool_destroy(subpool); file = apr_pcalloc(pool, sizeof(*file)); file->name = apr_pstrdup(pool, name); file->size = finfo.size; /* pre-allocate cluster map accordingly * (will be auto-expanded later if necessary) */ cluster_count = (int)(1 + (file->size - 1) / cluster_size); file->read_map = apr_array_make(pool, file->size ? cluster_count : 1, sizeof(word)); while (file->read_map->nelts < cluster_count) APR_ARRAY_PUSH(file->read_map, byte) = 0; /* determine first revision of rev / packed rev files */ if (strstr(name, "/db/revs/") != NULL && strstr(name, "manifest") == NULL) if (strstr(name, ".pack/pack") != NULL) file->rev_num = SVN_STR_TO_REV(strstr(name, "/db/revs/") + 9); else file->rev_num = SVN_STR_TO_REV(strrchr(name, '/') + 1); else file->rev_num = -1; /* filter out log/phys index files */ if (file->rev_num >= 0) { const char *suffix = name + strlen(name) - 4; if (strcmp(suffix, ".l2p") == 0 || strcmp(suffix, ".p2l") == 0) file->rev_num = -1; } apr_hash_set(files, file->name, APR_HASH_KEY_STRING, file); } file->open_count++; /* auto-create handle instance */ if (!handle_info) { apr_pool_t *pool = apr_hash_pool_get(handles); int *key = apr_palloc(pool, sizeof(*key)); *key = handle; handle_info = apr_pcalloc(pool, sizeof(*handle_info)); apr_hash_set(handles, key, sizeof(*key), handle_info); } /* link handle to file */ handle_info->file = file; handle_info->last_read_start = 0; handle_info->last_read_size = 0; }
/** Add cmid to cmid_arr */ MRCP_DECLARE(void) mrcp_cmid_add(apr_array_header_t *cmid_arr, apr_size_t cmid) { APR_ARRAY_PUSH(cmid_arr, apr_size_t) = cmid; }
/* This implements `svn_log_entry_receiver_t', printing the logs in XML. * * BATON is of type `struct log_receiver_baton'. * * Here is an example of the output; note that the "<log>" and * "</log>" tags are not emitted by this function: * * $ svn log --xml -r 1648:1649 * <log> * <logentry * revision="1648"> * <author>david</author> * <date>2002-04-06T16:34:51.428043Z</date> * <msg> * packages/rpm/subversion.spec : Now requires apache 2.0.36. * </msg> * </logentry> * <logentry * revision="1649"> * <author>cmpilato</author> * <date>2002-04-06T17:01:28.185136Z</date> * <msg>Fix error handling when the $EDITOR is needed but unavailable. Ah * ... now that's *much* nicer. * * * subversion/clients/cmdline/util.c * (svn_cl__edit_externally): Clean up the "no external editor" * error message. * (svn_cl__get_log_message): Wrap "no external editor" * errors with helpful hints about the -m and -F options. * * * subversion/libsvn_client/commit.c * (svn_client_commit): Actually capture and propogate "no external * editor" errors.</msg> * </logentry> * </log> * */ static svn_error_t * log_entry_receiver_xml(void *baton, svn_log_entry_t *log_entry, apr_pool_t *pool) { struct log_receiver_baton *lb = baton; /* Collate whole log message into sb before printing. */ svn_stringbuf_t *sb = svn_stringbuf_create("", pool); char *revstr; const char *author; const char *date; const char *message; if (lb->cancel_func) SVN_ERR(lb->cancel_func(lb->cancel_baton)); svn_compat_log_revprops_out(&author, &date, &message, log_entry->revprops); if (author) author = svn_xml_fuzzy_escape(author, pool); if (date) date = svn_xml_fuzzy_escape(date, pool); if (message) message = svn_xml_fuzzy_escape(message, pool); if (log_entry->revision == 0 && message == NULL) return SVN_NO_ERROR; if (! SVN_IS_VALID_REVNUM(log_entry->revision)) { svn_xml_make_close_tag(&sb, pool, "logentry"); SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout)); apr_array_pop(lb->merge_stack); return SVN_NO_ERROR; } revstr = apr_psprintf(pool, "%ld", log_entry->revision); /* <logentry revision="xxx"> */ svn_xml_make_open_tag(&sb, pool, svn_xml_normal, "logentry", "revision", revstr, NULL); /* <author>xxx</author> */ svn_cl__xml_tagged_cdata(&sb, pool, "author", author); /* Print the full, uncut, date. This is machine output. */ /* According to the docs for svn_log_entry_receiver_t, either NULL or the empty string represents no date. Avoid outputting an empty date element. */ if (date && date[0] == '\0') date = NULL; /* <date>xxx</date> */ svn_cl__xml_tagged_cdata(&sb, pool, "date", date); if (log_entry->changed_paths) { apr_hash_index_t *hi; char *path; /* <paths> */ svn_xml_make_open_tag(&sb, pool, svn_xml_normal, "paths", NULL); for (hi = apr_hash_first(pool, log_entry->changed_paths); hi != NULL; hi = apr_hash_next(hi)) { void *val; char action[2]; svn_log_changed_path_t *log_item; apr_hash_this(hi, (void *) &path, NULL, &val); log_item = val; action[0] = log_item->action; action[1] = '\0'; if (log_item->copyfrom_path && SVN_IS_VALID_REVNUM(log_item->copyfrom_rev)) { /* <path action="X" copyfrom-path="xxx" copyfrom-rev="xxx"> */ svn_stringbuf_t *escpath = svn_stringbuf_create("", pool); svn_xml_escape_attr_cstring(&escpath, log_item->copyfrom_path, pool); revstr = apr_psprintf(pool, "%ld", log_item->copyfrom_rev); svn_xml_make_open_tag(&sb, pool, svn_xml_protect_pcdata, "path", "action", action, "copyfrom-path", escpath->data, "copyfrom-rev", revstr, NULL); } else { /* <path action="X"> */ svn_xml_make_open_tag(&sb, pool, svn_xml_protect_pcdata, "path", "action", action, NULL); } /* xxx</path> */ svn_xml_escape_cdata_cstring(&sb, path, pool); svn_xml_make_close_tag(&sb, pool, "path"); } /* </paths> */ svn_xml_make_close_tag(&sb, pool, "paths"); } if (message != NULL) { /* <msg>xxx</msg> */ svn_cl__xml_tagged_cdata(&sb, pool, "msg", message); } svn_compat_log_revprops_clear(log_entry->revprops); if (log_entry->revprops && apr_hash_count(log_entry->revprops) > 0) { svn_xml_make_open_tag(&sb, pool, svn_xml_normal, "revprops", NULL); SVN_ERR(svn_cl__print_xml_prop_hash(&sb, log_entry->revprops, FALSE, /* name_only */ pool)); svn_xml_make_close_tag(&sb, pool, "revprops"); } if (log_entry->has_children) APR_ARRAY_PUSH(lb->merge_stack, svn_revnum_t) = log_entry->revision; else svn_xml_make_close_tag(&sb, pool, "logentry"); SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout)); return SVN_NO_ERROR; }
/* Implement `svn_log_entry_receiver_t', printing the logs in * a human-readable and machine-parseable format. * * BATON is of type `struct log_receiver_baton'. * * First, print a header line. Then if CHANGED_PATHS is non-null, * print all affected paths in a list headed "Changed paths:\n", * immediately following the header line. Then print a newline * followed by the message body, unless BATON->omit_log_message is true. * * Here are some examples of the output: * * $ svn log -r1847:1846 * ------------------------------------------------------------------------ * rev 1847: cmpilato | Wed 1 May 2002 15:44:26 | 7 lines * * Fix for Issue #694. * * * subversion/libsvn_repos/delta.c * (delta_files): Rework the logic in this function to only call * send_text_deltas if there are deltas to send, and within that case, * only use a real delta stream if the caller wants real text deltas. * * ------------------------------------------------------------------------ * rev 1846: whoever | Wed 1 May 2002 15:23:41 | 1 line * * imagine an example log message here * ------------------------------------------------------------------------ * * Or: * * $ svn log -r1847:1846 -v * ------------------------------------------------------------------------ * rev 1847: cmpilato | Wed 1 May 2002 15:44:26 | 7 lines * Changed paths: * M /trunk/subversion/libsvn_repos/delta.c * * Fix for Issue #694. * * * subversion/libsvn_repos/delta.c * (delta_files): Rework the logic in this function to only call * send_text_deltas if there are deltas to send, and within that case, * only use a real delta stream if the caller wants real text deltas. * * ------------------------------------------------------------------------ * rev 1846: whoever | Wed 1 May 2002 15:23:41 | 1 line * Changed paths: * M /trunk/notes/fs_dumprestore.txt * M /trunk/subversion/libsvn_repos/dump.c * * imagine an example log message here * ------------------------------------------------------------------------ * * Or: * * $ svn log -r1847:1846 -q * ------------------------------------------------------------------------ * rev 1847: cmpilato | Wed 1 May 2002 15:44:26 * ------------------------------------------------------------------------ * rev 1846: whoever | Wed 1 May 2002 15:23:41 * ------------------------------------------------------------------------ * * Or: * * $ svn log -r1847:1846 -qv * ------------------------------------------------------------------------ * rev 1847: cmpilato | Wed 1 May 2002 15:44:26 * Changed paths: * M /trunk/subversion/libsvn_repos/delta.c * ------------------------------------------------------------------------ * rev 1846: whoever | Wed 1 May 2002 15:23:41 * Changed paths: * M /trunk/notes/fs_dumprestore.txt * M /trunk/subversion/libsvn_repos/dump.c * ------------------------------------------------------------------------ * */ static svn_error_t * log_entry_receiver(void *baton, svn_log_entry_t *log_entry, apr_pool_t *pool) { struct log_receiver_baton *lb = baton; const char *author; const char *date; const char *message; /* Number of lines in the msg. */ int lines; if (lb->cancel_func) SVN_ERR(lb->cancel_func(lb->cancel_baton)); svn_compat_log_revprops_out(&author, &date, &message, log_entry->revprops); if (log_entry->revision == 0 && message == NULL) return SVN_NO_ERROR; if (! SVN_IS_VALID_REVNUM(log_entry->revision)) { apr_array_pop(lb->merge_stack); return SVN_NO_ERROR; } /* ### See http://subversion.tigris.org/issues/show_bug.cgi?id=807 for more on the fallback fuzzy conversions below. */ if (author == NULL) author = _("(no author)"); if (date && date[0]) /* Convert date to a format for humans. */ SVN_ERR(svn_cl__time_cstring_to_human_cstring(&date, date, pool)); else date = _("(no date)"); if (! lb->omit_log_message && message == NULL) message = ""; SVN_ERR(svn_cmdline_printf(pool, SEP_STRING "r%ld | %s | %s", log_entry->revision, author, date)); if (message != NULL) { lines = svn_cstring_count_newlines(message) + 1; SVN_ERR(svn_cmdline_printf(pool, (lines != 1) ? " | %d lines" : " | %d line", lines)); } SVN_ERR(svn_cmdline_printf(pool, "\n")); if (log_entry->changed_paths) { apr_array_header_t *sorted_paths; int i; /* Get an array of sorted hash keys. */ sorted_paths = svn_sort__hash(log_entry->changed_paths, svn_sort_compare_items_as_paths, pool); SVN_ERR(svn_cmdline_printf(pool, _("Changed paths:\n"))); for (i = 0; i < sorted_paths->nelts; i++) { svn_sort__item_t *item = &(APR_ARRAY_IDX(sorted_paths, i, svn_sort__item_t)); const char *path = item->key; svn_log_changed_path_t *log_item = apr_hash_get(log_entry->changed_paths, item->key, item->klen); const char *copy_data = ""; if (log_item->copyfrom_path && SVN_IS_VALID_REVNUM(log_item->copyfrom_rev)) { copy_data = apr_psprintf(pool, _(" (from %s:%ld)"), log_item->copyfrom_path, log_item->copyfrom_rev); } SVN_ERR(svn_cmdline_printf(pool, " %c %s%s\n", log_item->action, path, copy_data)); } } if (lb->merge_stack->nelts > 0) { int i; /* Print the result of merge line */ SVN_ERR(svn_cmdline_printf(pool, _("Merged via:"))); for (i = 0; i < lb->merge_stack->nelts; i++) { svn_revnum_t rev = APR_ARRAY_IDX(lb->merge_stack, i, svn_revnum_t); SVN_ERR(svn_cmdline_printf(pool, " r%ld%c", rev, i == lb->merge_stack->nelts - 1 ? '\n' : ',')); } } if (message != NULL) { /* A blank line always precedes the log message. */ SVN_ERR(svn_cmdline_printf(pool, "\n%s\n", message)); } SVN_ERR(svn_cmdline_fflush(stdout)); if (log_entry->has_children) APR_ARRAY_PUSH(lb->merge_stack, svn_revnum_t) = log_entry->revision; return SVN_NO_ERROR; }
dav_error * dav_svn__get_locations_report(const dav_resource *resource, const apr_xml_doc *doc, ap_filter_t *output) { svn_error_t *serr; dav_error *derr = NULL; apr_status_t apr_err; apr_bucket_brigade *bb; dav_svn__authz_read_baton arb; /* The parameters to do the operation on. */ const char *relative_path = NULL; const char *abs_path; svn_revnum_t peg_revision = SVN_INVALID_REVNUM; apr_array_header_t *location_revisions; /* XML Parsing Variables */ int ns; apr_xml_elem *child; apr_hash_t *fs_locations; location_revisions = apr_array_make(resource->pool, 0, sizeof(svn_revnum_t)); /* Sanity check. */ ns = dav_svn__find_ns(doc->namespaces, SVN_XML_NAMESPACE); if (ns == -1) { return dav_svn__new_error_tag(resource->pool, HTTP_BAD_REQUEST, 0, "The request does not contain the 'svn:' " "namespace, so it is not going to have " "certain required elements.", SVN_DAV_ERROR_NAMESPACE, SVN_DAV_ERROR_TAG); } /* Gather the parameters. */ for (child = doc->root->first_child; child != NULL; child = child->next) { /* If this element isn't one of ours, then skip it. */ if (child->ns != ns) continue; if (strcmp(child->name, "peg-revision") == 0) peg_revision = SVN_STR_TO_REV(dav_xml_get_cdata(child, resource->pool, 1)); else if (strcmp(child->name, "location-revision") == 0) { svn_revnum_t revision = SVN_STR_TO_REV(dav_xml_get_cdata(child, resource->pool, 1)); APR_ARRAY_PUSH(location_revisions, svn_revnum_t) = revision; } else if (strcmp(child->name, "path") == 0) { relative_path = dav_xml_get_cdata(child, resource->pool, 0); if ((derr = dav_svn__test_canonical(relative_path, resource->pool))) return derr; } } /* Now we should have the parameters ready - let's check if they are all present. */ if (! (relative_path && SVN_IS_VALID_REVNUM(peg_revision))) { return dav_svn__new_error_tag(resource->pool, HTTP_BAD_REQUEST, 0, "Not all parameters passed.", SVN_DAV_ERROR_NAMESPACE, SVN_DAV_ERROR_TAG); } /* Append the relative path to the base FS path to get an absolute repository path. */ abs_path = svn_path_join(resource->info->repos_path, relative_path, resource->pool); /* Build an authz read baton */ arb.r = resource->info->r; arb.repos = resource->info->repos; serr = svn_repos_trace_node_locations(resource->info->repos->fs, &fs_locations, abs_path, peg_revision, location_revisions, dav_svn__authz_read_func(&arb), &arb, resource->pool); if (serr) { return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR, serr->message, resource->pool); } bb = apr_brigade_create(resource->pool, output->c->bucket_alloc); apr_err = send_get_locations_report(output, bb, resource, fs_locations); if (apr_err) derr = dav_svn__convert_err(svn_error_create(apr_err, 0, NULL), HTTP_INTERNAL_SERVER_ERROR, "Error writing REPORT response.", resource->pool); /* Flush the contents of the brigade (returning an error only if we don't already have one). */ if (((apr_err = ap_fflush(output, bb))) && (! derr)) return dav_svn__convert_err(svn_error_create(apr_err, 0, NULL), HTTP_INTERNAL_SERVER_ERROR, "Error flushing brigade.", resource->pool); return derr; }
void svn_handle_error2(svn_error_t *err, FILE *stream, svn_boolean_t fatal, const char *prefix) { /* In a long error chain, there may be multiple errors with the same error code and no custom message. We only want to print the default message for that code once; printing it multiple times would add no useful information. The 'empties' array below remembers the codes of empty errors already seen in the chain. We could allocate it in err->pool, but there's no telling how long err will live or how many times it will get handled. So we use a subpool. */ apr_pool_t *subpool; apr_array_header_t *empties; svn_error_t *tmp_err; /* ### The rest of this file carefully avoids using svn_pool_*(), preferring apr_pool_*() instead. I can't remember why -- it may be an artifact of r843793, or it may be for some deeper reason -- but I'm playing it safe and using apr_pool_*() here too. */ apr_pool_create(&subpool, err->pool); empties = apr_array_make(subpool, 0, sizeof(apr_status_t)); tmp_err = err; while (tmp_err) { svn_boolean_t printed_already = FALSE; if (! tmp_err->message) { int i; for (i = 0; i < empties->nelts; i++) { if (tmp_err->apr_err == APR_ARRAY_IDX(empties, i, apr_status_t) ) { printed_already = TRUE; break; } } } if (! printed_already) { print_error(tmp_err, stream, prefix); if (! tmp_err->message) { APR_ARRAY_PUSH(empties, apr_status_t) = tmp_err->apr_err; } } tmp_err = tmp_err->child; } svn_pool_destroy(subpool); fflush(stream); if (fatal) { /* Avoid abort()s in maintainer mode. */ svn_error_clear(err); /* We exit(1) here instead of abort()ing so that atexit handlers get called. */ exit(EXIT_FAILURE); } }
static svn_error_t * close_revision(void *baton) { struct revision_baton *rb = baton; struct parse_baton *pb = rb->pb; const char *conflict_msg = NULL; svn_revnum_t committed_rev; svn_error_t *err; const char *txn_name = NULL; apr_hash_t *hooks_env; /* If we're skipping this revision we're done here. */ if (rb->skipped) return SVN_NO_ERROR; if (rb->rev == 0) { /* Special case: set revision 0 properties when loading into an 'empty' filesystem. */ svn_revnum_t youngest_rev; SVN_ERR(svn_fs_youngest_rev(&youngest_rev, pb->fs, rb->pool)); if (youngest_rev == 0) { apr_hash_t *orig_props; apr_hash_t *new_props; apr_array_header_t *diff; int i; SVN_ERR(svn_fs_revision_proplist(&orig_props, pb->fs, 0, rb->pool)); new_props = svn_prop_array_to_hash(rb->revprops, rb->pool); SVN_ERR(svn_prop_diffs(&diff, new_props, orig_props, rb->pool)); for (i = 0; i < diff->nelts; i++) { const svn_prop_t *prop = &APR_ARRAY_IDX(diff, i, svn_prop_t); SVN_ERR(change_rev_prop(pb->repos, 0, prop->name, prop->value, pb->validate_props, rb->pool)); } } return SVN_NO_ERROR; } /* If the dumpstream doesn't have an 'svn:date' property and we aren't ignoring the dates in the dumpstream altogether, remove any 'svn:date' revision property that was set by FS layer when the TXN was created. */ if (! (pb->ignore_dates || rb->datestamp)) { svn_prop_t *prop = &APR_ARRAY_PUSH(rb->revprops, svn_prop_t); prop->name = SVN_PROP_REVISION_DATE; prop->value = NULL; } /* Apply revision property changes. */ if (rb->pb->validate_props) SVN_ERR(svn_repos_fs_change_txn_props(rb->txn, rb->revprops, rb->pool)); else SVN_ERR(svn_fs_change_txn_props(rb->txn, rb->revprops, rb->pool)); /* Get the txn name and hooks environment if they will be needed. */ if (pb->use_pre_commit_hook || pb->use_post_commit_hook) { SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, pb->repos->hooks_env_path, rb->pool, rb->pool)); err = svn_fs_txn_name(&txn_name, rb->txn, rb->pool); if (err) { svn_error_clear(svn_fs_abort_txn(rb->txn, rb->pool)); return svn_error_trace(err); } } /* Run the pre-commit hook, if so commanded. */ if (pb->use_pre_commit_hook) { err = svn_repos__hooks_pre_commit(pb->repos, hooks_env, txn_name, rb->pool); if (err) { svn_error_clear(svn_fs_abort_txn(rb->txn, rb->pool)); return svn_error_trace(err); } } /* Commit. */ err = svn_fs_commit_txn(&conflict_msg, &committed_rev, rb->txn, rb->pool); if (SVN_IS_VALID_REVNUM(committed_rev)) { if (err) { /* ### Log any error, but better yet is to rev ### close_revision()'s API to allow both committed_rev and err ### to be returned, see #3768. */ svn_error_clear(err); } } else { svn_error_clear(svn_fs_abort_txn(rb->txn, rb->pool)); if (conflict_msg) return svn_error_quick_wrap(err, conflict_msg); else return svn_error_trace(err); } /* Run post-commit hook, if so commanded. */ if (pb->use_post_commit_hook) { if ((err = svn_repos__hooks_post_commit(pb->repos, hooks_env, committed_rev, txn_name, rb->pool))) return svn_error_create (SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED, err, _("Commit succeeded, but post-commit hook failed")); } /* After a successful commit, must record the dump-rev -> in-repos-rev mapping, so that copyfrom instructions in the dump file can look up the correct repository revision to copy from. */ set_revision_mapping(pb->rev_map, rb->rev, committed_rev); /* If the incoming dump stream has non-contiguous revisions (e.g. from using svndumpfilter --drop-empty-revs without --renumber-revs) then we must account for the missing gaps in PB->REV_MAP. Otherwise we might not be able to map all mergeinfo source revisions to the correct revisions in the target repos. */ if ((pb->last_rev_mapped != SVN_INVALID_REVNUM) && (rb->rev != pb->last_rev_mapped + 1)) { svn_revnum_t i; for (i = pb->last_rev_mapped + 1; i < rb->rev; i++) { set_revision_mapping(pb->rev_map, i, pb->last_rev_mapped); } } /* Update our "last revision mapped". */ pb->last_rev_mapped = rb->rev; /* Deltify the predecessors of paths changed in this revision. */ SVN_ERR(svn_fs_deltify_revision(pb->fs, committed_rev, rb->pool)); if (pb->notify_func) { /* ### TODO: Use proper scratch pool instead of pb->notify_pool */ svn_repos_notify_t *notify = svn_repos_notify_create( svn_repos_notify_load_txn_committed, pb->notify_pool); notify->new_revision = committed_rev; notify->old_revision = ((committed_rev == rb->rev) ? SVN_INVALID_REVNUM : rb->rev); pb->notify_func(pb->notify_baton, notify, pb->notify_pool); svn_pool_clear(pb->notify_pool); } return SVN_NO_ERROR; }