?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync usage with man page.
[netbsd-mini2440.git] / external / bsd / openldap / dist / libraries / librewrite / context.c
blobb12bf26900bab0a1f1df8e7e817b060af65b3f41
1 /* $OpenLDAP: pkg/ldap/libraries/librewrite/context.c,v 1.15.2.3 2008/02/11 23:26:42 kurt Exp $ */
2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
3 *
4 * Copyright 2000-2008 The OpenLDAP Foundation.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted only as authorized by the OpenLDAP
9 * Public License.
10 *
11 * A copy of this license is available in the file LICENSE in the
12 * top-level directory of the distribution or, alternatively, at
13 * <http://www.OpenLDAP.org/license.html>.
14 */
15 /* ACKNOWLEDGEMENT:
16 * This work was initially developed by Pierangelo Masarati for
17 * inclusion in OpenLDAP Software.
18 */
19
20 #include <portable.h>
21
22 #include "rewrite-int.h"
23
24 /*
25 * Compares two struct rewrite_context based on the name;
26 * used by avl stuff
27 */
28 static int
29 rewrite_context_cmp(
30 const void *c1,
31 const void *c2
32 )
33 {
34 const struct rewrite_context *lc1, *lc2;
35
36 lc1 = (const struct rewrite_context *)c1;
37 lc2 = (const struct rewrite_context *)c2;
38
39 assert( c1 != NULL );
40 assert( c2 != NULL );
41 assert( lc1->lc_name != NULL );
42 assert( lc2->lc_name != NULL );
43
44 return strcasecmp( lc1->lc_name, lc2->lc_name );
45 }
46
47 /*
48 * Returns -1 in case a duplicate struct rewrite_context
49 * has been inserted; used by avl stuff
50 */
51 static int
52 rewrite_context_dup(
53 void *c1,
54 void *c2
55 )
56 {
57 struct rewrite_context *lc1, *lc2;
58
59 lc1 = (struct rewrite_context *)c1;
60 lc2 = (struct rewrite_context *)c2;
61
62 assert( c1 != NULL );
63 assert( c2 != NULL );
64 assert( lc1->lc_name != NULL );
65 assert( lc2->lc_name != NULL );
66
67 return( strcasecmp( lc1->lc_name, lc2->lc_name) == 0 ? -1 : 0 );
68 }
69
70 /*
71 * Finds the context named rewriteContext in the context tree
72 */
73 struct rewrite_context *
74 rewrite_context_find(
75 struct rewrite_info *info,
76 const char *rewriteContext
77 )
78 {
79 struct rewrite_context *context, c;
80
81 assert( info != NULL );
82 assert( rewriteContext != NULL );
83
84 /*
85 * Fetches the required rewrite context
86 */
87 c.lc_name = (char *)rewriteContext;
88 context = (struct rewrite_context *)avl_find( info->li_context,
89 (caddr_t)&c, rewrite_context_cmp );
90 if ( context == NULL ) {
91 return NULL;
92 }
93
94 /*
95 * De-aliases the context if required
96 */
97 if ( context->lc_alias ) {
98 return context->lc_alias;
99 }
100
101 return context;
102 }
103
104 /*
105 * Creates a new context called rewriteContext and stores in into the tree
106 */
107 struct rewrite_context *
108 rewrite_context_create(
109 struct rewrite_info *info,
110 const char *rewriteContext
111 )
112 {
113 struct rewrite_context *context;
114 int rc;
115
116 assert( info != NULL );
117 assert( rewriteContext != NULL );
118
119 context = calloc( sizeof( struct rewrite_context ), 1 );
120 if ( context == NULL ) {
121 return NULL;
122 }
123
124 /*
125 * Context name
126 */
127 context->lc_name = strdup( rewriteContext );
128 if ( context->lc_name == NULL ) {
129 free( context );
130 return NULL;
131 }
132
133 /*
134 * The first, empty rule
135 */
136 context->lc_rule = calloc( sizeof( struct rewrite_rule ), 1 );
137 if ( context->lc_rule == NULL ) {
138 free( context->lc_name );
139 free( context );
140 return NULL;
141 }
142 memset( context->lc_rule, 0, sizeof( struct rewrite_rule ) );
143
144 /*
145 * Add context to tree
146 */
147 rc = avl_insert( &info->li_context, (caddr_t)context,
148 rewrite_context_cmp, rewrite_context_dup );
149 if ( rc == -1 ) {
150 free( context->lc_rule );
151 free( context->lc_name );
152 free( context );
153 return NULL;
154 }
155
156 return context;
157 }
158
159 /*
160 * Finds the next rule according to a goto action statement,
161 * or null in case of error.
162 * Helper for rewrite_context_apply.
163 */
164 static struct rewrite_rule *
165 rewrite_action_goto(
166 struct rewrite_action *action,
167 struct rewrite_rule *rule
168 )
169 {
170 int n;
171
172 assert( action != NULL );
173 assert( action->la_args != NULL );
174 assert( rule != NULL );
175
176 n = ((int *)action->la_args)[ 0 ];
177
178 if ( n > 0 ) {
179 for ( ; n > 1 && rule != NULL ; n-- ) {
180 rule = rule->lr_next;
181 }
182 } else if ( n <= 0 ) {
183 for ( ; n < 1 && rule != NULL ; n++ ) {
184 rule = rule->lr_prev;
185 }
186 }
187
188 return rule;
189 }
190
191 /*
192 * Rewrites string according to context; may return:
193 * OK: fine; if *result != NULL rule matched and rewrite succeeded.
194 * STOP: fine, rule matched; stop processing following rules
195 * UNWILL: rule matched; force 'unwilling to perform'
196 */
197 int
198 rewrite_context_apply(
199 struct rewrite_info *info,
200 struct rewrite_op *op,
201 struct rewrite_context *context,
202 const char *string,
203 char **result
204 )
205 {
206 struct rewrite_rule *rule;
207 char *s, *res = NULL;
208 int return_code = REWRITE_REGEXEC_OK;
209
210 assert( info != NULL );
211 assert( op != NULL );
212 assert( context != NULL );
213 assert( context->lc_rule != NULL );
214 assert( string != NULL );
215 assert( result != NULL );
216
217 op->lo_depth++;
218 assert( op->lo_depth > 0 );
219
220 Debug( LDAP_DEBUG_TRACE, "==> rewrite_context_apply"
221 " [depth=%d] string='%s'\n",
222 op->lo_depth, string, 0 );
223
224 s = (char *)string;
225
226 for ( rule = context->lc_rule->lr_next;
227 rule != NULL && op->lo_num_passes < info->li_max_passes;
228 rule = rule->lr_next, op->lo_num_passes++ ) {
229 int rc;
230
231 /*
232 * Apply a single rule
233 */
234 rc = rewrite_rule_apply( info, op, rule, s, &res );
235
236 /*
237 * A rule may return:
238 * OK with result != NULL if matched
239 * ERR if anything was wrong
240 * UNWILLING if the server should drop the request
241 * the latter case in honored immediately;
242 * the other two may require some special actions to take
243 * place.
244 */
245 switch ( rc ) {
246
247 case REWRITE_REGEXEC_ERR:
248 Debug( LDAP_DEBUG_ANY, "==> rewrite_context_apply"
249 " error ...\n", 0, 0, 0);
250
251 /*
252 * Checks for special actions to be taken
253 * in case of error ...
254 */
255 if ( rule->lr_action != NULL ) {
256 struct rewrite_action *action;
257 int do_continue = 0;
258
259 for ( action = rule->lr_action;
260 action != NULL;
261 action = action->la_next ) {
262 switch ( action->la_type ) {
263
264 /*
265 * This action takes precedence
266 * over the others in case of failure
267 */
268 case REWRITE_ACTION_IGNORE_ERR:
269 Debug( LDAP_DEBUG_ANY,
270 "==> rewrite_context_apply"
271 " ignoring error ...\n", 0, 0, 0 );
272 do_continue = 1;
273 break;
274
275 /*
276 * Goto is honored only if it comes
277 * after ignore error
278 */
279 case REWRITE_ACTION_GOTO:
280 if ( do_continue ) {
281 rule = rewrite_action_goto( action, rule );
282 if ( rule == NULL ) {
283 return_code = REWRITE_REGEXEC_ERR;
284 goto rc_end_of_context;
285 }
286 }
287 break;
288
289 /*
290 * Other actions are ignored
291 */
292 default:
293 break;
294 }
295 }
296
297 if ( do_continue ) {
298 if ( rule->lr_next == NULL ) {
299 res = s;
300 }
301 goto rc_continue;
302 }
303 }
304
305 /*
306 * Default behavior is to bail out ...
307 */
308 return_code = REWRITE_REGEXEC_ERR;
309 goto rc_end_of_context;
310
311 /*
312 * OK means there were no errors or special return codes;
313 * if res is defined, it means the rule matched and we
314 * got a sucessful rewriting
315 */
316 case REWRITE_REGEXEC_OK:
317
318 /*
319 * It matched! Check for actions ...
320 */
321 if ( res != NULL ) {
322 struct rewrite_action *action;
323
324 if ( s != string && s != res ) {
325 free( s );
326 }
327 s = res;
328
329 for ( action = rule->lr_action;
330 action != NULL;
331 action = action->la_next ) {
332
333 switch ( action->la_type ) {
334
335 /*
336 * This ends the rewrite context
337 * successfully
338 */
339 case REWRITE_ACTION_STOP:
340 goto rc_end_of_context;
341
342 /*
343 * This instructs the server to return
344 * an `unwilling to perform' error
345 * message
346 */
347 case REWRITE_ACTION_UNWILLING:
348 return_code = REWRITE_REGEXEC_UNWILLING;
349 goto rc_end_of_context;
350
351 /*
352 * This causes the processing to
353 * jump n rules back and forth
354 */
355 case REWRITE_ACTION_GOTO:
356 rule = rewrite_action_goto( action, rule );
357 if ( rule == NULL ) {
358 return_code = REWRITE_REGEXEC_ERR;
359 goto rc_end_of_context;
360 }
361 break;
362
363 /*
364 * This ends the rewrite context
365 * and returns a user-defined
366 * error code
367 */
368 case REWRITE_ACTION_USER:
369 return_code = ((int *)action->la_args)[ 0 ];
370 goto rc_end_of_context;
371
372 default:
373 /* ... */
374 break;
375 }
376 }
377
378 /*
379 * If result was OK and string didn't match,
380 * in case of last rule we need to set the
381 * result back to the string
382 */
383 } else if ( rule->lr_next == NULL ) {
384 res = s;
385 }
386
387 break;
388
389 /*
390 * A STOP has propagated ...
391 */
392 case REWRITE_REGEXEC_STOP:
393 goto rc_end_of_context;
394
395 /*
396 * This will instruct the server to return
397 * an `unwilling to perform' error message
398 */
399 case REWRITE_REGEXEC_UNWILLING:
400 return_code = REWRITE_REGEXEC_UNWILLING;
401 goto rc_end_of_context;
402
403 /*
404 * A user-defined error code has propagated ...
405 */
406 default:
407 assert( rc >= REWRITE_REGEXEC_USER );
408 goto rc_end_of_context;
409
410 }
411
412 rc_continue:; /* sent here by actions that require to continue */
413
414 }
415
416 rc_end_of_context:;
417 *result = res;
418
419 Debug( LDAP_DEBUG_TRACE, "==> rewrite_context_apply"
420 " [depth=%d] res={%d,'%s'}\n",
421 op->lo_depth, return_code, ( res ? res : "NULL" ) );
422
423 assert( op->lo_depth > 0 );
424 op->lo_depth--;
425
426 return return_code;
427 }
428
429 void
430 rewrite_context_free(
431 void *tmp
432 )
433 {
434 struct rewrite_context *context = (struct rewrite_context *)tmp;
435
436 assert( tmp != NULL );
437
438 rewrite_context_destroy( &context );
439 }
440
441 int
442 rewrite_context_destroy(
443 struct rewrite_context **pcontext
444 )
445 {
446 struct rewrite_context *context;
447 struct rewrite_rule *r;
448
449 assert( pcontext != NULL );
450 assert( *pcontext != NULL );
451
452 context = *pcontext;
453
454 assert( context->lc_rule != NULL );
455
456 for ( r = context->lc_rule->lr_next; r; ) {
457 struct rewrite_rule *cr = r;
458
459 r = r->lr_next;
460 rewrite_rule_destroy( &cr );
461 }
462
463 free( context->lc_rule );
464 context->lc_rule = NULL;
465
466 assert( context->lc_name != NULL );
467 free( context->lc_name );
468 context->lc_name = NULL;
469
470 free( context );
471 *pcontext = NULL;
472
473 return 0;
474 }
NetBSD on the FriendlyARM MINI2440