1 /* ====================================================================
2 * The Apache Software License, Version 1.1
4 * Copyright (c) 2000-2003 The Apache Software Foundation. All rights
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
19 * 3. The end-user documentation included with the redistribution,
20 * if any, must include the following acknowledgment:
21 * "This product includes software developed by the
22 * Apache Software Foundation (http://www.apache.org/)."
23 * Alternately, this acknowledgment may appear in the software itself,
24 * if and wherever such third-party acknowledgments normally appear.
26 * 4. The names "Apache" and "Apache Software Foundation" must
27 * not be used to endorse or promote products derived from this
28 * software without prior written permission. For written
29 * permission, please contact apache@apache.org.
31 * 5. Products derived from this software may not be called "Apache",
32 * nor may "Apache" appear in their name, without prior written
33 * permission of the Apache Software Foundation.
35 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
36 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
37 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
38 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
39 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
41 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
42 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
43 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
44 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
45 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47 * ====================================================================
49 * This software consists of voluntary contributions made by many
50 * individuals on behalf of the Apache Software Foundation. For more
51 * information on the Apache Software Foundation, please see
52 * <http://www.apache.org/>.
59 #include "apr_buckets.h"
73 * @brief Apache filter library
76 /** Returned by the bottom-most filter if no data was written.
77 * @see ap_pass_brigade(). */
78 #define AP_NOBODY_WROTE -1
79 /** Returned by the bottom-most filter if no data was read.
80 * @see ap_get_brigade(). */
81 #define AP_NOBODY_READ -2
82 /** Returned when?? @bug find out when! */
83 #define AP_FILTER_ERROR -3
86 * input filtering modes
89 /** The filter should return at most readbytes data. */
91 /** The filter should return at most one line of CRLF data.
92 * (If a potential line is too long or no CRLF is found, the
93 * filter may return partial data).
96 /** The filter should implicitly eat any CRLF pairs that it sees. */
98 /** The filter read should be treated as speculative and any returned
99 * data should be stored for later retrieval in another mode. */
101 /** The filter read should be exhaustive and read until it can not
103 * Use this mode with extreme caution.
106 /** The filter should initialize the connection if needed,
107 * NNTP or FTP over SSL for example.
113 * @defgroup filter FILTER CHAIN
115 * Filters operate using a "chaining" mechanism. The filters are chained
116 * together into a sequence. When output is generated, it is passed through
117 * each of the filters on this chain, until it reaches the end (or "bottom")
118 * and is placed onto the network.
120 * The top of the chain, the code generating the output, is typically called
121 * a "content generator." The content generator's output is fed into the
122 * filter chain using the standard Apache output mechanisms: ap_rputs(),
123 * ap_rprintf(), ap_rwrite(), etc.
125 * Each filter is defined by a callback. This callback takes the output from
126 * the previous filter (or the content generator if there is no previous
127 * filter), operates on it, and passes the result to the next filter in the
128 * chain. This pass-off is performed using the ap_fc_* functions, such as
129 * ap_fc_puts(), ap_fc_printf(), ap_fc_write(), etc.
131 * When content generation is complete, the system will pass an "end of
132 * stream" marker into the filter chain. The filters will use this to flush
133 * out any internal state and to detect incomplete syntax (for example, an
134 * unterminated SSI directive).
137 /* forward declare the filter type */
138 typedef struct ap_filter_t ap_filter_t;
141 * @name Filter callbacks
143 * This function type is used for filter callbacks. It will be passed a
144 * pointer to "this" filter, and a "bucket" containing the content to be
147 * In filter->ctx, the callback will find its context. This context is
148 * provided here, so that a filter may be installed multiple times, each
149 * receiving its own per-install context pointer.
151 * Callbacks are associated with a filter definition, which is specified
152 * by name. See ap_register_input_filter() and ap_register_output_filter()
153 * for setting the association between a name for a filter and its
154 * associated callback (and other information).
156 * If the initialization function argument passed to the registration
157 * functions is non-NULL, it will be called iff the filter is in the input
158 * or output filter chains and before any data is generated to allow the
159 * filter to prepare for processing.
161 * The *bucket structure (and all those referenced by ->next and ->prev)
162 * should be considered "const". The filter is allowed to modify the
163 * next/prev to insert/remove/replace elements in the bucket list, but
164 * the types and values of the individual buckets should not be altered.
166 * For the input and output filters, the return value of a filter should be
167 * an APR status value. For the init function, the return value should
168 * be an HTTP error code or OK if it was successful.
173 typedef apr_status_t (*ap_out_filter_func)(ap_filter_t *f,
174 apr_bucket_brigade *b);
175 typedef apr_status_t (*ap_in_filter_func)(ap_filter_t *f,
176 apr_bucket_brigade *b,
177 ap_input_mode_t mode,
178 apr_read_type_e block,
179 apr_off_t readbytes);
180 typedef int (*ap_init_filter_func)(ap_filter_t *f);
182 typedef union ap_filter_func {
183 ap_out_filter_func out_func;
184 ap_in_filter_func in_func;
190 * Filters have different types/classifications. These are used to group
191 * and sort the filters to properly sequence their operation.
193 * The types have a particular sort order, which allows us to insert them
194 * into the filter chain in a determistic order. Within a particular grouping,
195 * the ordering is equivalent to the order of calls to ap_add_*_filter().
198 /** These filters are used to alter the content that is passed through
199 * them. Examples are SSI or PHP. */
200 AP_FTYPE_RESOURCE = 10,
201 /** These filters are used to alter the content as a whole, but after all
202 * AP_FTYPE_RESOURCE filters are executed. These filters should not
203 * change the content-type. An example is deflate. */
204 AP_FTYPE_CONTENT_SET = 20,
205 /** These filters are used to handle the protocol between server and
206 * client. Examples are HTTP and POP. */
207 AP_FTYPE_PROTOCOL = 30,
208 /** These filters implement transport encodings (e.g., chunking). */
209 AP_FTYPE_TRANSCODE = 40,
210 /** These filters will alter the content, but in ways that are
211 * more strongly associated with the connection. Examples are
212 * splitting an HTTP connection into multiple requests and
213 * buffering HTTP responses across multiple requests.
215 * It is important to note that these types of filters are not
216 * allowed in a sub-request. A sub-request's output can certainly
217 * be filtered by ::AP_FTYPE_RESOURCE filters, but all of the "final
218 * processing" is determined by the main request. */
219 AP_FTYPE_CONNECTION = 50,
220 /** These filters don't alter the content. They are responsible for
221 * sending/receiving data to/from the client. */
222 AP_FTYPE_NETWORK = 60
226 * This is the request-time context structure for an installed filter (in
227 * the output filter chain). It provides the callback to use for filtering,
228 * the request this filter is associated with (which is important when
229 * an output chain also includes sub-request filters), the context for this
230 * installed filter, and the filter ordering/chaining fields.
232 * Filter callbacks are free to use ->ctx as they please, to store context
233 * during the filter process. Generally, this is superior over associating
234 * the state directly with the request. A callback should not change any of
238 typedef struct ap_filter_rec_t ap_filter_rec_t;
241 * This structure is used for recording information about the
242 * registered filters. It associates a name with the filter's callback
245 * At the moment, these are simply linked in a chain, so a ->next pointer
248 struct ap_filter_rec_t {
249 /** The registered name for this filter */
251 /** The function to call when this filter is invoked. */
252 ap_filter_func filter_func;
253 /** The function to call before the handlers are invoked. */
254 ap_init_filter_func filter_init_func;
255 /** The type of filter, either AP_FTYPE_CONTENT or AP_FTYPE_CONNECTION.
256 * An AP_FTYPE_CONTENT filter modifies the data based on information
257 * found in the content. An AP_FTYPE_CONNECTION filter modifies the
258 * data based on the type of connection.
260 ap_filter_type ftype;
262 /** The next filter_rec in the list */
263 struct ap_filter_rec_t *next;
267 * The representation of a filter chain. Each request has a list
268 * of these structures which are called in turn to filter the data. Sub
269 * requests get an exact copy of the main requests filter chain.
272 /** The internal representation of this filter. This includes
273 * the filter's name, type, and the actual function pointer.
275 ap_filter_rec_t *frec;
277 /** A place to store any data associated with the current filter */
280 /** The next filter in the chain */
283 /** The request_rec associated with the current filter. If a sub-request
284 * adds filters, then the sub-request is the request associated with the
289 /** The conn_rec associated with the current filter. This is analogous
290 * to the request_rec, except that it is used for input filtering.
296 * Get the current bucket brigade from the next filter on the filter
297 * stack. The filter returns an apr_status_t value. If the bottom-most
298 * filter doesn't read from the network, then ::AP_NOBODY_READ is returned.
299 * The bucket brigade will be empty when there is nothing left to get.
300 * @param filter The next filter in the chain
301 * @param bucket The current bucket brigade. The original brigade passed
302 * to ap_get_brigade() must be empty.
303 * @param mode The way in which the data should be read
304 * @param block How the operations should be performed
305 * ::APR_BLOCK_READ, ::APR_NONBLOCK_READ
306 * @param readbytes How many bytes to read from the next filter.
308 AP_DECLARE(apr_status_t) ap_get_brigade(ap_filter_t *filter,
309 apr_bucket_brigade *bucket,
310 ap_input_mode_t mode,
311 apr_read_type_e block,
312 apr_off_t readbytes);
315 * Pass the current bucket brigade down to the next filter on the filter
316 * stack. The filter returns an apr_status_t value. If the bottom-most
317 * filter doesn't write to the network, then ::AP_NOBODY_WROTE is returned.
318 * @param filter The next filter in the chain
319 * @param bucket The current bucket brigade
321 AP_DECLARE(apr_status_t) ap_pass_brigade(ap_filter_t *filter,
322 apr_bucket_brigade *bucket);
325 * This function is used to register an input filter with the system.
326 * After this registration is performed, then a filter may be added
327 * into the filter chain by using ap_add_input_filter() and simply
328 * specifying the name.
330 * @param name The name to attach to the filter function
331 * @param filter_func The filter function to name
332 * @param filter_init The function to call before the filter handlers
334 * @param ftype The type of filter function, either ::AP_FTYPE_CONTENT or
335 * ::AP_FTYPE_CONNECTION
336 * @see add_input_filter()
338 AP_DECLARE(ap_filter_rec_t *) ap_register_input_filter(const char *name,
339 ap_in_filter_func filter_func,
340 ap_init_filter_func filter_init,
341 ap_filter_type ftype);
343 * This function is used to register an output filter with the system.
344 * After this registration is performed, then a filter may be added
345 * into the filter chain by using ap_add_output_filter() and simply
346 * specifying the name.
348 * @param name The name to attach to the filter function
349 * @param filter_func The filter function to name
350 * @param filter_init The function to call before the filter handlers
352 * @param ftype The type of filter function, either ::AP_FTYPE_CONTENT or
353 * ::AP_FTYPE_CONNECTION
354 * @see ap_add_output_filter()
356 AP_DECLARE(ap_filter_rec_t *) ap_register_output_filter(const char *name,
357 ap_out_filter_func filter_func,
358 ap_init_filter_func filter_init,
359 ap_filter_type ftype);
362 * Adds a named filter into the filter chain on the specified request record.
363 * The filter will be installed with the specified context pointer.
365 * Filters added in this way will always be placed at the end of the filters
366 * that have the same type (thus, the filters have the same order as the
367 * calls to ap_add_filter). If the current filter chain contains filters
368 * from another request, then this filter will be added before those other
371 * To re-iterate that last comment. This function is building a FIFO
372 * list of filters. Take note of that when adding your filter to the chain.
374 * @param name The name of the filter to add
375 * @param ctx Context data to provide to the filter
376 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
377 * @param c The connection to add the fillter for
379 AP_DECLARE(ap_filter_t *) ap_add_input_filter(const char *name, void *ctx,
380 request_rec *r, conn_rec *c);
383 * Variant of ap_add_input_filter() that accepts a registered filter handle
384 * (as returned by ap_register_input_filter()) rather than a filter name
386 * @param f The filter handle to add
387 * @param ctx Context data to provide to the filter
388 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
389 * @param c The connection to add the fillter for
391 AP_DECLARE(ap_filter_t *) ap_add_input_filter_handle(ap_filter_rec_t *f,
397 * Returns the filter handle for use with ap_add_input_filter_handle.
399 * @param name The filter name to look up
401 AP_DECLARE(ap_filter_rec_t *) ap_get_input_filter_handle(const char *name);
404 * Add a filter to the current request. Filters are added in a FIFO manner.
405 * The first filter added will be the first filter called.
406 * @param name The name of the filter to add
407 * @param ctx Context data to set in the filter
408 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
409 * @param c The connection to add this filter for
411 AP_DECLARE(ap_filter_t *) ap_add_output_filter(const char *name, void *ctx,
412 request_rec *r, conn_rec *c);
415 * Variant of ap_add_output_filter() that accepts a registered filter handle
416 * (as returned by ap_register_output_filter()) rather than a filter name
418 * @param f The filter handle to add
419 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
420 * @param c The connection to add the fillter for
422 AP_DECLARE(ap_filter_t *) ap_add_output_filter_handle(ap_filter_rec_t *f,
428 * Returns the filter handle for use with ap_add_output_filter_handle.
430 * @param name The filter name to look up
432 AP_DECLARE(ap_filter_rec_t *) ap_get_output_filter_handle(const char *name);
435 * Remove an input filter from either the request or connection stack
436 * it is associated with.
437 * @param f The filter to remove
440 AP_DECLARE(void) ap_remove_input_filter(ap_filter_t *f);
443 * Remove an output filter from either the request or connection stack
444 * it is associated with.
445 * @param f The filter to remove
448 AP_DECLARE(void) ap_remove_output_filter(ap_filter_t *f);
450 /* The next two filters are for abstraction purposes only. They could be
451 * done away with, but that would require that we break modules if we ever
452 * want to change our filter registration method. The basic idea, is that
453 * all filters have a place to store data, the ctx pointer. These functions
454 * fill out that pointer with a bucket brigade, and retrieve that data on
455 * the next call. The nice thing about these functions, is that they
456 * automatically concatenate the bucket brigades together for you. This means
457 * that if you have already stored a brigade in the filters ctx pointer, then
458 * when you add more it will be tacked onto the end of that brigade. When
459 * you retrieve data, if you pass in a bucket brigade to the get function,
460 * it will append the current brigade onto the one that you are retrieving.
464 * prepare a bucket brigade to be setaside. If a different brigade was
465 * set-aside earlier, then the two brigades are concatenated together.
466 * @param f The current filter
467 * @param save_to The brigade that was previously set-aside. Regardless, the
468 * new bucket brigade is returned in this location.
469 * @param b The bucket brigade to save aside. This brigade is always empty
471 * @param p Ensure that all data in the brigade lives as long as this pool
473 AP_DECLARE(apr_status_t) ap_save_brigade(ap_filter_t *f,
474 apr_bucket_brigade **save_to,
475 apr_bucket_brigade **b, apr_pool_t *p);
478 * Flush function for apr_brigade_* calls. This calls ap_pass_brigade
479 * to flush the brigade if the brigade buffer overflows.
480 * @param bb The brigade to flush
481 * @param ctx The filter to pass the brigade to
482 * @note this function has nothing to do with FLUSH buckets. It is simply
483 * a way to flush content out of a brigade and down a filter stack.
485 AP_DECLARE_NONSTD(apr_status_t) ap_filter_flush(apr_bucket_brigade *bb,
489 * Flush the current brigade down the filter stack.
490 * @param f The current filter
491 * @param bb The brigade to flush
493 AP_DECLARE(apr_status_t) ap_fflush(ap_filter_t *f, apr_bucket_brigade *bb);
496 * Write a buffer for the current filter, buffering if possible.
497 * @param f the filter doing the writing
498 * @param bb The brigade to buffer into
499 * @param data The data to write
500 * @param nbyte The number of bytes in the data
502 #define ap_fwrite(f, bb, data, nbyte) \
503 apr_brigade_write(bb, ap_filter_flush, f, data, nbyte)
506 * Write a buffer for the current filter, buffering if possible.
507 * @param f the filter doing the writing
508 * @param bb The brigade to buffer into
509 * @param str The string to write
511 #define ap_fputs(f, bb, str) \
512 apr_brigade_puts(bb, ap_filter_flush, f, str)
515 * Write a character for the current filter, buffering if possible.
516 * @param f the filter doing the writing
517 * @param bb The brigade to buffer into
518 * @param c The character to write
520 #define ap_fputc(f, bb, c) \
521 apr_brigade_putc(bb, ap_filter_flush, f, c)
524 * Write an unspecified number of strings to the current filter
525 * @param f the filter doing the writing
526 * @param bb The brigade to buffer into
527 * @param ... The strings to write
529 AP_DECLARE_NONSTD(apr_status_t) ap_fputstrs(ap_filter_t *f,
530 apr_bucket_brigade *bb,
534 * Output data to the filter in printf format
535 * @param f the filter doing the writing
536 * @param bb The brigade to buffer into
537 * @param fmt The format string
538 * @param ... The argumets to use to fill out the format string
540 AP_DECLARE_NONSTD(apr_status_t) ap_fprintf(ap_filter_t *f,
541 apr_bucket_brigade *bb,
544 __attribute__((format(printf,3,4)));
550 #endif /* !AP_FILTER_H */