1 /* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include "apr_buckets.h"
35 * @brief Apache filter library
38 /** Returned by the bottom-most filter if no data was written.
39 * @see ap_pass_brigade(). */
40 #define AP_NOBODY_WROTE -1
41 /** Returned by the bottom-most filter if no data was read.
42 * @see ap_get_brigade(). */
43 #define AP_NOBODY_READ -2
44 /** Returned when?? @bug find out when! */
45 #define AP_FILTER_ERROR -3
48 * input filtering modes
51 /** The filter should return at most readbytes data. */
53 /** The filter should return at most one line of CRLF data.
54 * (If a potential line is too long or no CRLF is found, the
55 * filter may return partial data).
58 /** The filter should implicitly eat any CRLF pairs that it sees. */
60 /** The filter read should be treated as speculative and any returned
61 * data should be stored for later retrieval in another mode. */
63 /** The filter read should be exhaustive and read until it can not
65 * Use this mode with extreme caution.
68 /** The filter should initialize the connection if needed,
69 * NNTP or FTP over SSL for example.
75 * @defgroup filter FILTER CHAIN
77 * Filters operate using a "chaining" mechanism. The filters are chained
78 * together into a sequence. When output is generated, it is passed through
79 * each of the filters on this chain, until it reaches the end (or "bottom")
80 * and is placed onto the network.
82 * The top of the chain, the code generating the output, is typically called
83 * a "content generator." The content generator's output is fed into the
84 * filter chain using the standard Apache output mechanisms: ap_rputs(),
85 * ap_rprintf(), ap_rwrite(), etc.
87 * Each filter is defined by a callback. This callback takes the output from
88 * the previous filter (or the content generator if there is no previous
89 * filter), operates on it, and passes the result to the next filter in the
90 * chain. This pass-off is performed using the ap_fc_* functions, such as
91 * ap_fc_puts(), ap_fc_printf(), ap_fc_write(), etc.
93 * When content generation is complete, the system will pass an "end of
94 * stream" marker into the filter chain. The filters will use this to flush
95 * out any internal state and to detect incomplete syntax (for example, an
96 * unterminated SSI directive).
99 /* forward declare the filter type */
100 typedef struct ap_filter_t ap_filter_t;
103 * @name Filter callbacks
105 * This function type is used for filter callbacks. It will be passed a
106 * pointer to "this" filter, and a "bucket" containing the content to be
109 * In filter->ctx, the callback will find its context. This context is
110 * provided here, so that a filter may be installed multiple times, each
111 * receiving its own per-install context pointer.
113 * Callbacks are associated with a filter definition, which is specified
114 * by name. See ap_register_input_filter() and ap_register_output_filter()
115 * for setting the association between a name for a filter and its
116 * associated callback (and other information).
118 * If the initialization function argument passed to the registration
119 * functions is non-NULL, it will be called iff the filter is in the input
120 * or output filter chains and before any data is generated to allow the
121 * filter to prepare for processing.
123 * The *bucket structure (and all those referenced by ->next and ->prev)
124 * should be considered "const". The filter is allowed to modify the
125 * next/prev to insert/remove/replace elements in the bucket list, but
126 * the types and values of the individual buckets should not be altered.
128 * For the input and output filters, the return value of a filter should be
129 * an APR status value. For the init function, the return value should
130 * be an HTTP error code or OK if it was successful.
135 typedef apr_status_t (*ap_out_filter_func)(ap_filter_t *f,
136 apr_bucket_brigade *b);
137 typedef apr_status_t (*ap_in_filter_func)(ap_filter_t *f,
138 apr_bucket_brigade *b,
139 ap_input_mode_t mode,
140 apr_read_type_e block,
141 apr_off_t readbytes);
142 typedef int (*ap_init_filter_func)(ap_filter_t *f);
144 typedef union ap_filter_func {
145 ap_out_filter_func out_func;
146 ap_in_filter_func in_func;
152 * Filters have different types/classifications. These are used to group
153 * and sort the filters to properly sequence their operation.
155 * The types have a particular sort order, which allows us to insert them
156 * into the filter chain in a determistic order. Within a particular grouping,
157 * the ordering is equivalent to the order of calls to ap_add_*_filter().
160 /** These filters are used to alter the content that is passed through
161 * them. Examples are SSI or PHP. */
162 AP_FTYPE_RESOURCE = 10,
163 /** These filters are used to alter the content as a whole, but after all
164 * AP_FTYPE_RESOURCE filters are executed. These filters should not
165 * change the content-type. An example is deflate. */
166 AP_FTYPE_CONTENT_SET = 20,
167 /** These filters are used to handle the protocol between server and
168 * client. Examples are HTTP and POP. */
169 AP_FTYPE_PROTOCOL = 30,
170 /** These filters implement transport encodings (e.g., chunking). */
171 AP_FTYPE_TRANSCODE = 40,
172 /** These filters will alter the content, but in ways that are
173 * more strongly associated with the connection. Examples are
174 * splitting an HTTP connection into multiple requests and
175 * buffering HTTP responses across multiple requests.
177 * It is important to note that these types of filters are not
178 * allowed in a sub-request. A sub-request's output can certainly
179 * be filtered by ::AP_FTYPE_RESOURCE filters, but all of the "final
180 * processing" is determined by the main request. */
181 AP_FTYPE_CONNECTION = 50,
182 /** These filters don't alter the content. They are responsible for
183 * sending/receiving data to/from the client. */
184 AP_FTYPE_NETWORK = 60
188 * This is the request-time context structure for an installed filter (in
189 * the output filter chain). It provides the callback to use for filtering,
190 * the request this filter is associated with (which is important when
191 * an output chain also includes sub-request filters), the context for this
192 * installed filter, and the filter ordering/chaining fields.
194 * Filter callbacks are free to use ->ctx as they please, to store context
195 * during the filter process. Generally, this is superior over associating
196 * the state directly with the request. A callback should not change any of
200 typedef struct ap_filter_rec_t ap_filter_rec_t;
201 typedef struct ap_filter_provider_t ap_filter_provider_t;
204 * This structure is used for recording information about the
205 * registered filters. It associates a name with the filter's callback
208 * At the moment, these are simply linked in a chain, so a ->next pointer
211 * It is used for any filter that can be inserted in the filter chain.
212 * This may be either a httpd-2.0 filter or a mod_filter harness.
213 * In the latter case it contains dispatch, provider and protocol information.
214 * In the former case, the new fields (from dispatch) are ignored.
216 struct ap_filter_rec_t {
217 /** The registered name for this filter */
220 /** The function to call when this filter is invoked. */
221 ap_filter_func filter_func;
223 /** The function to call before the handlers are invoked. Notice
224 * that this function is called only for filters participating in
225 * the http protocol. Filters for other protocols are to be
226 * initialized by the protocols themselves.
228 ap_init_filter_func filter_init_func;
230 /** The type of filter, either AP_FTYPE_CONTENT or AP_FTYPE_CONNECTION.
231 * An AP_FTYPE_CONTENT filter modifies the data based on information
232 * found in the content. An AP_FTYPE_CONNECTION filter modifies the
233 * data based on the type of connection.
235 ap_filter_type ftype;
237 /** The next filter_rec in the list */
238 struct ap_filter_rec_t *next;
240 /** Providers for this filter */
241 ap_filter_provider_t *providers;
243 /** Trace level for this filter */
246 /** Protocol flags for this filter */
247 unsigned int proto_flags;
251 * The representation of a filter chain. Each request has a list
252 * of these structures which are called in turn to filter the data. Sub
253 * requests get an exact copy of the main requests filter chain.
256 /** The internal representation of this filter. This includes
257 * the filter's name, type, and the actual function pointer.
259 ap_filter_rec_t *frec;
261 /** A place to store any data associated with the current filter */
264 /** The next filter in the chain */
267 /** The request_rec associated with the current filter. If a sub-request
268 * adds filters, then the sub-request is the request associated with the
273 /** The conn_rec associated with the current filter. This is analogous
274 * to the request_rec, except that it is used for input filtering.
280 * Get the current bucket brigade from the next filter on the filter
281 * stack. The filter returns an apr_status_t value. If the bottom-most
282 * filter doesn't read from the network, then ::AP_NOBODY_READ is returned.
283 * The bucket brigade will be empty when there is nothing left to get.
284 * @param filter The next filter in the chain
285 * @param bucket The current bucket brigade. The original brigade passed
286 * to ap_get_brigade() must be empty.
287 * @param mode The way in which the data should be read
288 * @param block How the operations should be performed
289 * ::APR_BLOCK_READ, ::APR_NONBLOCK_READ
290 * @param readbytes How many bytes to read from the next filter.
292 AP_DECLARE(apr_status_t) ap_get_brigade(ap_filter_t *filter,
293 apr_bucket_brigade *bucket,
294 ap_input_mode_t mode,
295 apr_read_type_e block,
296 apr_off_t readbytes);
299 * Pass the current bucket brigade down to the next filter on the filter
300 * stack. The filter returns an apr_status_t value. If the bottom-most
301 * filter doesn't write to the network, then ::AP_NOBODY_WROTE is returned.
302 * The caller relinquishes ownership of the brigade.
303 * @param filter The next filter in the chain
304 * @param bucket The current bucket brigade
306 AP_DECLARE(apr_status_t) ap_pass_brigade(ap_filter_t *filter,
307 apr_bucket_brigade *bucket);
310 * This function is used to register an input filter with the system.
311 * After this registration is performed, then a filter may be added
312 * into the filter chain by using ap_add_input_filter() and simply
313 * specifying the name.
315 * @param name The name to attach to the filter function
316 * @param filter_func The filter function to name
317 * @param filter_init The function to call before the filter handlers
319 * @param ftype The type of filter function, either ::AP_FTYPE_CONTENT or
320 * ::AP_FTYPE_CONNECTION
321 * @see add_input_filter()
323 AP_DECLARE(ap_filter_rec_t *) ap_register_input_filter(const char *name,
324 ap_in_filter_func filter_func,
325 ap_init_filter_func filter_init,
326 ap_filter_type ftype);
329 * This function is used to register an output filter with the system.
330 * After this registration is performed, then a filter may be added
331 * into the filter chain by using ap_add_output_filter() and simply
332 * specifying the name. It may also be used as a provider under mod_filter.
333 * This is (equivalent to) ap_register_output_filter_protocol with
334 * proto_flags=0, and is retained for back-compatibility with 2.0 modules.
336 * @param name The name to attach to the filter function
337 * @param filter_func The filter function to name
338 * @param filter_init The function to call before the filter handlers
340 * @param ftype The type of filter function, either ::AP_FTYPE_CONTENT or
341 * ::AP_FTYPE_CONNECTION
342 * @see ap_add_output_filter()
344 AP_DECLARE(ap_filter_rec_t *) ap_register_output_filter(const char *name,
345 ap_out_filter_func filter_func,
346 ap_init_filter_func filter_init,
347 ap_filter_type ftype);
349 /* For httpd-2.2 I suggest replacing the above with
350 #define ap_register_output_filter(name,ffunc,init,ftype) \
351 ap_register_output_filter_protocol(name,ffunc,init,ftype,0)
355 * This function is used to register an output filter with the system.
356 * After this registration is performed, then a filter may be added
357 * into the filter chain by using ap_add_output_filter() and simply
358 * specifying the name. It may also be used as a provider under mod_filter.
360 * @param name The name to attach to the filter function
361 * @param filter_func The filter function to name
362 * @param filter_init The function to call before the filter handlers
364 * @param ftype The type of filter function, either ::AP_FTYPE_CONTENT or
365 * ::AP_FTYPE_CONNECTION
366 * @param proto_flags Protocol flags: logical OR of AP_FILTER_PROTO_* bits
367 * @see ap_add_output_filter()
369 AP_DECLARE(ap_filter_rec_t *) ap_register_output_filter_protocol(
371 ap_out_filter_func filter_func,
372 ap_init_filter_func filter_init,
373 ap_filter_type ftype,
374 unsigned int proto_flags);
377 * Adds a named filter into the filter chain on the specified request record.
378 * The filter will be installed with the specified context pointer.
380 * Filters added in this way will always be placed at the end of the filters
381 * that have the same type (thus, the filters have the same order as the
382 * calls to ap_add_filter). If the current filter chain contains filters
383 * from another request, then this filter will be added before those other
386 * To re-iterate that last comment. This function is building a FIFO
387 * list of filters. Take note of that when adding your filter to the chain.
389 * @param name The name of the filter to add
390 * @param ctx Context data to provide to the filter
391 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
392 * @param c The connection to add the fillter for
394 AP_DECLARE(ap_filter_t *) ap_add_input_filter(const char *name, void *ctx,
395 request_rec *r, conn_rec *c);
398 * Variant of ap_add_input_filter() that accepts a registered filter handle
399 * (as returned by ap_register_input_filter()) rather than a filter name
401 * @param f The filter handle to add
402 * @param ctx Context data to provide to the filter
403 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
404 * @param c The connection to add the fillter for
406 AP_DECLARE(ap_filter_t *) ap_add_input_filter_handle(ap_filter_rec_t *f,
412 * Returns the filter handle for use with ap_add_input_filter_handle.
414 * @param name The filter name to look up
416 AP_DECLARE(ap_filter_rec_t *) ap_get_input_filter_handle(const char *name);
419 * Add a filter to the current request. Filters are added in a FIFO manner.
420 * The first filter added will be the first filter called.
421 * @param name The name of the filter to add
422 * @param ctx Context data to set in the filter
423 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
424 * @param c The connection to add this filter for
426 AP_DECLARE(ap_filter_t *) ap_add_output_filter(const char *name, void *ctx,
427 request_rec *r, conn_rec *c);
430 * Variant of ap_add_output_filter() that accepts a registered filter handle
431 * (as returned by ap_register_output_filter()) rather than a filter name
433 * @param f The filter handle to add
434 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
435 * @param c The connection to add the fillter for
437 AP_DECLARE(ap_filter_t *) ap_add_output_filter_handle(ap_filter_rec_t *f,
443 * Returns the filter handle for use with ap_add_output_filter_handle.
445 * @param name The filter name to look up
447 AP_DECLARE(ap_filter_rec_t *) ap_get_output_filter_handle(const char *name);
450 * Remove an input filter from either the request or connection stack
451 * it is associated with.
452 * @param f The filter to remove
455 AP_DECLARE(void) ap_remove_input_filter(ap_filter_t *f);
458 * Remove an output filter from either the request or connection stack
459 * it is associated with.
460 * @param f The filter to remove
463 AP_DECLARE(void) ap_remove_output_filter(ap_filter_t *f);
465 /* The next two filters are for abstraction purposes only. They could be
466 * done away with, but that would require that we break modules if we ever
467 * want to change our filter registration method. The basic idea, is that
468 * all filters have a place to store data, the ctx pointer. These functions
469 * fill out that pointer with a bucket brigade, and retrieve that data on
470 * the next call. The nice thing about these functions, is that they
471 * automatically concatenate the bucket brigades together for you. This means
472 * that if you have already stored a brigade in the filters ctx pointer, then
473 * when you add more it will be tacked onto the end of that brigade. When
474 * you retrieve data, if you pass in a bucket brigade to the get function,
475 * it will append the current brigade onto the one that you are retrieving.
479 * prepare a bucket brigade to be setaside. If a different brigade was
480 * set-aside earlier, then the two brigades are concatenated together.
481 * @param f The current filter
482 * @param save_to The brigade that was previously set-aside. Regardless, the
483 * new bucket brigade is returned in this location.
484 * @param b The bucket brigade to save aside. This brigade is always empty
486 * @param p Ensure that all data in the brigade lives as long as this pool
488 AP_DECLARE(apr_status_t) ap_save_brigade(ap_filter_t *f,
489 apr_bucket_brigade **save_to,
490 apr_bucket_brigade **b, apr_pool_t *p);
493 * Flush function for apr_brigade_* calls. This calls ap_pass_brigade
494 * to flush the brigade if the brigade buffer overflows.
495 * @param bb The brigade to flush
496 * @param ctx The filter to pass the brigade to
497 * @note this function has nothing to do with FLUSH buckets. It is simply
498 * a way to flush content out of a brigade and down a filter stack.
500 AP_DECLARE_NONSTD(apr_status_t) ap_filter_flush(apr_bucket_brigade *bb,
504 * Flush the current brigade down the filter stack.
505 * @param f The filter we are passing to
506 * @param bb The brigade to flush
508 AP_DECLARE(apr_status_t) ap_fflush(ap_filter_t *f, apr_bucket_brigade *bb);
511 * Write a buffer for the current filter, buffering if possible.
512 * @param f the filter we are writing to
513 * @param bb The brigade to buffer into
514 * @param data The data to write
515 * @param nbyte The number of bytes in the data
517 #define ap_fwrite(f, bb, data, nbyte) \
518 apr_brigade_write(bb, ap_filter_flush, f, data, nbyte)
521 * Write a buffer for the current filter, buffering if possible.
522 * @param f the filter we are writing to
523 * @param bb The brigade to buffer into
524 * @param str The string to write
526 #define ap_fputs(f, bb, str) \
527 apr_brigade_puts(bb, ap_filter_flush, f, str)
530 * Write a character for the current filter, buffering if possible.
531 * @param f the filter we are writing to
532 * @param bb The brigade to buffer into
533 * @param c The character to write
535 #define ap_fputc(f, bb, c) \
536 apr_brigade_putc(bb, ap_filter_flush, f, c)
539 * Write an unspecified number of strings to the current filter
540 * @param f the filter we are writing to
541 * @param bb The brigade to buffer into
542 * @param ... The strings to write
544 AP_DECLARE_NONSTD(apr_status_t) ap_fputstrs(ap_filter_t *f,
545 apr_bucket_brigade *bb,
549 * Output data to the filter in printf format
550 * @param f the filter we are writing to
551 * @param bb The brigade to buffer into
552 * @param fmt The format string
553 * @param ... The argumets to use to fill out the format string
555 AP_DECLARE_NONSTD(apr_status_t) ap_fprintf(ap_filter_t *f,
556 apr_bucket_brigade *bb,
559 __attribute__((format(printf,3,4)));
562 * set protocol requirements for an output content filter
563 * (only works with AP_FTYPE_RESOURCE and AP_FTYPE_CONTENT_SET)
564 * @param f the filter in question
565 * @param proto_flags Logical OR of AP_FILTER_PROTO_* bits
567 AP_DECLARE(void) ap_filter_protocol(ap_filter_t* f, unsigned int proto_flags);
569 /** Filter changes contents (so invalidating checksums/etc) */
570 #define AP_FILTER_PROTO_CHANGE 0x1
572 /** Filter changes length of contents (so invalidating content-length/etc) */
573 #define AP_FILTER_PROTO_CHANGE_LENGTH 0x2
575 /** Filter requires complete input and can't work on byteranges */
576 #define AP_FILTER_PROTO_NO_BYTERANGE 0x4
578 /** Filter should not run in a proxy */
579 #define AP_FILTER_PROTO_NO_PROXY 0x8
581 /** Filter makes output non-cacheable */
582 #define AP_FILTER_PROTO_NO_CACHE 0x10
584 /** Filter is incompatible with "Cache-Control: no-transform" */
585 #define AP_FILTER_PROTO_TRANSFORM 0x20
591 #endif /* !AP_FILTER_H */