subversion/libsvn_repos/authz.c

236  * in the next segment level. We keep it separate to save a bit of memory
241   /* If not NULL, this represents the "*" follow-segment. */
244   /* If not NULL, this represents the "**" follow-segment. */
248    * prefix part of "prefix*" patterns.  Sorted by segment prefix. */
253    * segment suffix. */
261   /* This node itself is a "**" segment and must therefore itself be added
267  * prefix tree, with a single, whole segment stored at each node.  The whole
272   /* The segment as specified in the path rule.  During the lookup tree walk,
273    * this will compared to the respective segment of the path to check. */
274   svn_string_t segment;
280   /* Map of sub-segment(const char *) to respective node (node_t) for all
285   /* If not NULL, this contains the pattern-based segment sub-nodes. */
293 create_node(authz_rule_segment_t *segment,
297   if (segment)
298     result->segment = segment->pattern;
301       result->segment.data = "";
302       result->segment.len = 0;
311             authz_rule_segment_t *segment,
315     *node = create_node(segment, result_pool);
320 /* compare_func comparing segment names. It takes a sorted_pattern_t* as
328   const authz_rule_segment_t *segment = void_rhs;
330   return strcmp(element->node->segment.data, segment->pattern.data);
333 /* compare_func comparing segment names. It takes a sorted_pattern_t* as
341   const char *segment = void_rhs;
343   return strcmp(element->node->segment.data, segment);
348  * sorted by their segment strings.
352                      authz_rule_segment_t *segment,
367   entry_ptr = svn_sort__array_lookup(*array, segment, &idx,
374   entry.node = create_node(segment, result_pool);
393 /* Combine an ACL rule segment with the corresponding node in our filtered
397   authz_rule_segment_t *segment;
435             authz_rule_segment_t *segment,
458   if (segment->kind != authz_rule_literal)
461   switch (segment->kind)
463       /* A full wildcard segment? */
466                              segment, result_pool);
472                              segment, result_pool);
476       /* A single wildcard at the end of the segment? */
479                                       segment, result_pool);
485                                       segment, result_pool);
491                                       segment, result_pool);
496       SVN_ERR_ASSERT_NO_RETURN(segment->kind == authz_rule_literal);
505           sub_node = svn_hash_gets(node->sub_nodes, segment->pattern.data);
508       /* Auto-insert a sub-node for the current segment. */
511           sub_node = create_node(segment, result_pool);
513                        sub_node->segment.data,
514                        sub_node->segment.len,
521   node_segment->segment = segment;
524   /* Continue at the sub-node with the next segment. */
525   insert_path(ctx, sub_node, path_access, segment_count - 1, segment + 1,
569           || step->segment->kind != acl->rule.path[i].kind
570           || step->segment->pattern.data != acl->rule.path[i].pattern.data)
626               apr_hash_set(*hash, node->segment.data, node->segment.len,
810       if (prev->node->segment.data[0] != pattern->node->segment.data[0])
816         if (   prev->node->segment.len < pattern->node->segment.len
817             && !memcmp(prev->node->segment.data,
818                        pattern->node->segment.data,
819                        prev->node->segment.len))
1006    * segment (used to build up the next contents of CURRENT). */
1077   /* Var-segment rules match empty segments as well */
1096  * for the next path segment.
1117       /* NODE is now enlisted as a (potential) match for the next segment. */
1120       /* Variable length sub-segment sequences apply to the same node as
1139                       const svn_stringbuf_t *segment)
1142   if (   node->segment.len <= segment->len
1143       && !memcmp(node->segment.data, segment->data, node->segment.len))
1151                    const svn_stringbuf_t *segment,
1156   int i = svn_sort__bsearch_lower_bound(prefixes, segment->data,
1164                           segment);
1176           add_if_prefix_matches(state, pattern, segment);
1186                     const svn_stringbuf_t *segment,
1193       if (0 == apr_fnmatch(node->segment.data, segment->data, 0))
1198 /* Extract the next segment from PATH and copy it into SEGMENT, whose current
1200  * segment separators will be interpreted as an empty segment ("").  Non-
1203  * Return the start of the next segment within PATH, skipping the '/'
1210 next_segment(svn_stringbuf_t *segment,
1220         /* End of segment. */
1221         segment->data[len] = 0;
1222         segment->len = len;
1230          * treat trailing '/' as indicating an empty trailing segment.
1236         /* Copy segment contents directly into the result buffer.
1238         segment->data[len] = c;
1241   /* No separator found, so all of PATH has been the last segment. */
1242   segment->data[len] = 0;
1243   segment->len = len;
1245   /* Tell the caller that this has been the last segment. */
1288       svn_stringbuf_t *segment = state->scratch_pad;
1298       /* Extract the next segment. */
1299       path = next_segment(segment, path);
1301       /* Initial state for this segment. */
1319           svn_stringbuf_appendbytes(state->parent_path, segment->data,
1320                                     segment->len);
1328             add_next_node(state, apr_hash_get(node->sub_nodes, segment->data,
1329                                               segment->len));
1343                 add_prefix_matches(state, segment,
1347                 add_complex_matches(state, segment,
1355                   svn_authz__reverse_string(segment->data, segment->len);
1356                   add_prefix_matches(state, segment,