1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements. See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License. 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.
19 * @brief Apache filter library
26 #include "apr_buckets.h"
39 * @brief input filtering modes
42 /** The filter should return at most readbytes data. */
44 /** The filter should return at most one line of CRLF data.
45 * (If a potential line is too long or no CRLF is found, the
46 * filter may return partial data).
49 /** The filter should implicitly eat any CRLF pairs that it sees. */
51 /** The filter read should be treated as speculative and any returned
52 * data should be stored for later retrieval in another mode. */
54 /** The filter read should be exhaustive and read until it can not
56 * Use this mode with extreme caution.
59 /** The filter should initialize the connection if needed,
60 * NNTP or FTP over SSL for example.
66 * @defgroup APACHE_CORE_FILTER Filter Chain
67 * @ingroup APACHE_CORE
69 * Filters operate using a "chaining" mechanism. The filters are chained
70 * together into a sequence. When output is generated, it is passed through
71 * each of the filters on this chain, until it reaches the end (or "bottom")
72 * and is placed onto the network.
74 * The top of the chain, the code generating the output, is typically called
75 * a "content generator." The content generator's output is fed into the
76 * filter chain using the standard Apache output mechanisms: ap_rputs(),
77 * ap_rprintf(), ap_rwrite(), etc.
79 * Each filter is defined by a callback. This callback takes the output from
80 * the previous filter (or the content generator if there is no previous
81 * filter), operates on it, and passes the result to the next filter in the
82 * chain. This pass-off is performed using the ap_fc_* functions, such as
83 * ap_fc_puts(), ap_fc_printf(), ap_fc_write(), etc.
85 * When content generation is complete, the system will pass an "end of
86 * stream" marker into the filter chain. The filters will use this to flush
87 * out any internal state and to detect incomplete syntax (for example, an
88 * unterminated SSI directive).
93 /* forward declare the filter type */
94 typedef struct ap_filter_t ap_filter_t;
97 * @name Filter callbacks
99 * This function type is used for filter callbacks. It will be passed a
100 * pointer to "this" filter, and a "bucket brigade" containing the content
103 * In filter->ctx, the callback will find its context. This context is
104 * provided here, so that a filter may be installed multiple times, each
105 * receiving its own per-install context pointer.
107 * Callbacks are associated with a filter definition, which is specified
108 * by name. See ap_register_input_filter() and ap_register_output_filter()
109 * for setting the association between a name for a filter and its
110 * associated callback (and other information).
112 * If the initialization function argument passed to the registration
113 * functions is non-NULL, it will be called iff the filter is in the input
114 * or output filter chains and before any data is generated to allow the
115 * filter to prepare for processing.
117 * The bucket brigade always belongs to the caller, but the filter
118 * is free to use the buckets within it as it sees fit. Normally,
119 * the brigade will be returned empty. Buckets *may not* be retained
120 * between successive calls to the filter unless they have been
121 * "set aside" with a call apr_bucket_setaside. Typically this will
122 * be done with ap_save_brigade(). Buckets removed from the brigade
123 * become the responsibility of the filter, which must arrange for
124 * them to be deleted, either by doing so directly or by inserting
125 * them in a brigade which will subsequently be destroyed.
127 * For the input and output filters, the return value of a filter should be
128 * an APR status value. For the init function, the return value should
129 * be an HTTP error code or OK if it was successful.
134 typedef apr_status_t (*ap_out_filter_func)(ap_filter_t *f,
135 apr_bucket_brigade *b);
136 typedef apr_status_t (*ap_in_filter_func)(ap_filter_t *f,
137 apr_bucket_brigade *b,
138 ap_input_mode_t mode,
139 apr_read_type_e block,
140 apr_off_t readbytes);
141 typedef int (*ap_init_filter_func)(ap_filter_t *f);
143 typedef union ap_filter_func {
144 ap_out_filter_func out_func;
145 ap_in_filter_func in_func;
151 * Filters have different types/classifications. These are used to group
152 * and sort the filters to properly sequence their operation.
154 * The types have a particular sort order, which allows us to insert them
155 * into the filter chain in a determistic order. Within a particular grouping,
156 * the ordering is equivalent to the order of calls to ap_add_*_filter().
159 /** These filters are used to alter the content that is passed through
160 * them. Examples are SSI or PHP. */
161 AP_FTYPE_RESOURCE = 10,
162 /** These filters are used to alter the content as a whole, but after all
163 * AP_FTYPE_RESOURCE filters are executed. These filters should not
164 * change the content-type. An example is deflate. */
165 AP_FTYPE_CONTENT_SET = 20,
166 /** These filters are used to handle the protocol between server and
167 * client. Examples are HTTP and POP. */
168 AP_FTYPE_PROTOCOL = 30,
169 /** These filters implement transport encodings (e.g., chunking). */
170 AP_FTYPE_TRANSCODE = 40,
171 /** These filters will alter the content, but in ways that are
172 * more strongly associated with the connection. Examples are
173 * splitting an HTTP connection into multiple requests and
174 * buffering HTTP responses across multiple requests.
176 * It is important to note that these types of filters are not
177 * allowed in a sub-request. A sub-request's output can certainly
178 * be filtered by ::AP_FTYPE_RESOURCE filters, but all of the "final
179 * processing" is determined by the main request. */
180 AP_FTYPE_CONNECTION = 50,
181 /** These filters don't alter the content. They are responsible for
182 * sending/receiving data to/from the client. */
183 AP_FTYPE_NETWORK = 60
187 * These flags indicate whether the given filter is an input filter or an
193 /** Output filters */
194 AP_FILTER_OUTPUT = 2,
195 } ap_filter_direction_e;
198 * This is the request-time context structure for an installed filter (in
199 * the output filter chain). It provides the callback to use for filtering,
200 * the request this filter is associated with (which is important when
201 * an output chain also includes sub-request filters), the context for this
202 * installed filter, and the filter ordering/chaining fields.
204 * Filter callbacks are free to use ->ctx as they please, to store context
205 * during the filter process. Generally, this is superior over associating
206 * the state directly with the request. A callback should not change any of
210 typedef struct ap_filter_rec_t ap_filter_rec_t;
211 typedef struct ap_filter_provider_t ap_filter_provider_t;
214 * @brief This structure is used for recording information about the
215 * registered filters. It associates a name with the filter's callback
218 * At the moment, these are simply linked in a chain, so a ->next pointer
221 * It is used for any filter that can be inserted in the filter chain.
222 * This may be either a httpd-2.0 filter or a mod_filter harness.
223 * In the latter case it contains dispatch, provider and protocol information.
224 * In the former case, the new fields (from dispatch) are ignored.
226 struct ap_filter_rec_t {
227 /** The registered name for this filter */
230 /** The function to call when this filter is invoked. */
231 ap_filter_func filter_func;
233 /** The function to call directly before the handlers are invoked
234 * for a request. The init function is called once directly
235 * before running the handlers for a request or subrequest. The
236 * init function is never called for a connection filter (with
237 * ftype >= AP_FTYPE_CONNECTION). Any use of this function for
238 * filters for protocols other than HTTP is specified by the
239 * module supported that protocol.
241 ap_init_filter_func filter_init_func;
243 /** The next filter_rec in the list */
244 struct ap_filter_rec_t *next;
246 /** Providers for this filter */
247 ap_filter_provider_t *providers;
249 /** The type of filter, either AP_FTYPE_CONTENT or AP_FTYPE_CONNECTION.
250 * An AP_FTYPE_CONTENT filter modifies the data based on information
251 * found in the content. An AP_FTYPE_CONNECTION filter modifies the
252 * data based on the type of connection.
254 ap_filter_type ftype;
256 /** Trace level for this filter */
259 /** Protocol flags for this filter */
260 unsigned int proto_flags;
262 /** Whether the filter is an input or output filter */
263 ap_filter_direction_e direction;
267 * @brief The representation of a filter chain.
269 * Each request has a list
270 * of these structures which are called in turn to filter the data. Sub
271 * requests get an exact copy of the main requests filter chain.
274 /** The internal representation of this filter. This includes
275 * the filter's name, type, and the actual function pointer.
277 ap_filter_rec_t *frec;
279 /** A place to store any data associated with the current filter */
282 /** The next filter in the chain */
285 /** The request_rec associated with the current filter. If a sub-request
286 * adds filters, then the sub-request is the request associated with the
291 /** The conn_rec associated with the current filter. This is analogous
292 * to the request_rec, except that it is used for connection filters.
296 /** Buffered data associated with the current filter. */
297 apr_bucket_brigade *bb;
299 /** Dedicated pool to use for deferred writes. */
300 apr_pool_t *deferred_pool;
302 /** Entry in ring of pending filters (with setaside buckets). */
303 APR_RING_ENTRY(ap_filter_t) pending;
307 * @brief The representation of a filters' ring.
309 typedef APR_RING_HEAD(ap_filter_ring, ap_filter_t) ap_filter_ring_t;
312 * Get the current bucket brigade from the next filter on the filter
313 * stack. The filter returns an apr_status_t value. If the bottom-most
314 * filter doesn't read from the network, then ::AP_NOBODY_READ is returned.
315 * The bucket brigade will be empty when there is nothing left to get.
316 * @param filter The next filter in the chain
317 * @param bucket The current bucket brigade. The original brigade passed
318 * to ap_get_brigade() must be empty.
319 * @param mode The way in which the data should be read
320 * @param block How the operations should be performed
321 * ::APR_BLOCK_READ, ::APR_NONBLOCK_READ
322 * @param readbytes How many bytes to read from the next filter.
324 AP_DECLARE(apr_status_t) ap_get_brigade(ap_filter_t *filter,
325 apr_bucket_brigade *bucket,
326 ap_input_mode_t mode,
327 apr_read_type_e block,
328 apr_off_t readbytes);
331 * Pass the current bucket brigade down to the next filter on the filter
332 * stack. The filter returns an apr_status_t value. If the bottom-most
333 * filter doesn't write to the network, then ::AP_NOBODY_WROTE is returned.
334 * @param filter The next filter in the chain
335 * @param bucket The current bucket brigade
337 * @remark Ownership of the brigade is retained by the caller. On return,
338 * the contents of the brigade are UNDEFINED, and the caller must
339 * either call apr_brigade_cleanup or apr_brigade_destroy on
342 AP_DECLARE(apr_status_t) ap_pass_brigade(ap_filter_t *filter,
343 apr_bucket_brigade *bucket);
346 * Pass the current bucket brigade down to the next filter on the filter
347 * stack checking for filter errors. The filter returns an apr_status_t value.
348 * Returns ::OK if the brigade is successfully passed
349 * ::AP_FILTER_ERROR on a filter error
350 * ::HTTP_INTERNAL_SERVER_ERROR on all other errors
351 * @param r The request rec
352 * @param bucket The current bucket brigade
353 * @param fmt The format string. If NULL defaults to "ap_pass_brigade returned"
354 * @param ... The arguments to use to fill out the format string
355 * @remark Ownership of the brigade is retained by the caller. On return,
356 * the contents of the brigade are UNDEFINED, and the caller must
357 * either call apr_brigade_cleanup or apr_brigade_destroy on
360 AP_DECLARE(apr_status_t) ap_pass_brigade_fchk(request_rec *r,
361 apr_bucket_brigade *bucket,
364 __attribute__((format(printf,3,4)));
367 * This function is used to register an input filter with the system.
368 * After this registration is performed, then a filter may be added
369 * into the filter chain by using ap_add_input_filter() and simply
370 * specifying the name.
372 * @param name The name to attach to the filter function
373 * @param filter_func The filter function to name
374 * @param filter_init The function to call before the filter handlers
376 * @param ftype The type of filter function, either ::AP_FTYPE_CONTENT_SET or
377 * ::AP_FTYPE_CONNECTION
378 * @see add_input_filter()
380 AP_DECLARE(ap_filter_rec_t *) ap_register_input_filter(const char *name,
381 ap_in_filter_func filter_func,
382 ap_init_filter_func filter_init,
383 ap_filter_type ftype);
385 /** @deprecated @see ap_register_output_filter_protocol */
386 AP_DECLARE(ap_filter_rec_t *) ap_register_output_filter(const char *name,
387 ap_out_filter_func filter_func,
388 ap_init_filter_func filter_init,
389 ap_filter_type ftype);
391 /* For httpd-?.? I suggest replacing the above with
392 #define ap_register_output_filter(name,ffunc,init,ftype) \
393 ap_register_output_filter_protocol(name,ffunc,init,ftype,0)
397 * This function is used to register an output filter with the system.
398 * After this registration is performed, then a filter may be added
399 * directly to the filter chain by using ap_add_output_filter() and
400 * simply specifying the name, or as a provider under mod_filter.
402 * @param name The name to attach to the filter function
403 * @param filter_func The filter function to name
404 * @param filter_init The function to call before the filter handlers
406 * @param ftype The type of filter function, either ::AP_FTYPE_CONTENT_SET or
407 * ::AP_FTYPE_CONNECTION
408 * @param proto_flags Protocol flags: logical OR of AP_FILTER_PROTO_* bits
409 * @return the filter rec
410 * @see ap_add_output_filter()
412 AP_DECLARE(ap_filter_rec_t *) ap_register_output_filter_protocol(
414 ap_out_filter_func filter_func,
415 ap_init_filter_func filter_init,
416 ap_filter_type ftype,
417 unsigned int proto_flags);
420 * Adds a named filter into the filter chain on the specified request record.
421 * The filter will be installed with the specified context pointer.
423 * Filters added in this way will always be placed at the end of the filters
424 * that have the same type (thus, the filters have the same order as the
425 * calls to ap_add_filter). If the current filter chain contains filters
426 * from another request, then this filter will be added before those other
429 * To re-iterate that last comment. This function is building a FIFO
430 * list of filters. Take note of that when adding your filter to the chain.
432 * @param name The name of the filter to add
433 * @param ctx Context data to provide to the filter
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_input_filter(const char *name, void *ctx,
438 request_rec *r, conn_rec *c);
441 * Variant of ap_add_input_filter() that accepts a registered filter handle
442 * (as returned by ap_register_input_filter()) rather than a filter name
444 * @param f The filter handle to add
445 * @param ctx Context data to provide to the filter
446 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
447 * @param c The connection to add the fillter for
449 AP_DECLARE(ap_filter_t *) ap_add_input_filter_handle(ap_filter_rec_t *f,
455 * Returns the filter handle for use with ap_add_input_filter_handle.
457 * @param name The filter name to look up
459 AP_DECLARE(ap_filter_rec_t *) ap_get_input_filter_handle(const char *name);
462 * Add a filter to the current request. Filters are added in a FIFO manner.
463 * The first filter added will be the first filter called.
464 * @param name The name of the filter to add
465 * @param ctx Context data to set in the filter
466 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
467 * @param c The connection to add this filter for
468 * @note If adding a connection-level output filter (i.e. where the type
469 * is >= AP_FTYPE_CONNECTION) during processing of a request, the request
470 * object r must be passed in to ensure the filter chains are modified
471 * correctly. f->r will still be initialized as NULL in the new filter.
473 AP_DECLARE(ap_filter_t *) ap_add_output_filter(const char *name, void *ctx,
474 request_rec *r, conn_rec *c);
477 * Variant of ap_add_output_filter() that accepts a registered filter handle
478 * (as returned by ap_register_output_filter()) rather than a filter name
480 * @param f The filter handle to add
481 * @param ctx Context data to set in the filter
482 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
483 * @param c The connection to add the filter for
484 * @note If adding a connection-level output filter (i.e. where the type
485 * is >= AP_FTYPE_CONNECTION) during processing of a request, the request
486 * object r must be passed in to ensure the filter chains are modified
487 * correctly. f->r will still be initialized as NULL in the new filter.
489 AP_DECLARE(ap_filter_t *) ap_add_output_filter_handle(ap_filter_rec_t *f,
495 * Returns the filter handle for use with ap_add_output_filter_handle.
497 * @param name The filter name to look up
499 AP_DECLARE(ap_filter_rec_t *) ap_get_output_filter_handle(const char *name);
502 * Remove an input filter from either the request or connection stack
503 * it is associated with.
504 * @param f The filter to remove
507 AP_DECLARE(void) ap_remove_input_filter(ap_filter_t *f);
510 * Remove an output filter from either the request or connection stack
511 * it is associated with.
512 * @param f The filter to remove
515 AP_DECLARE(void) ap_remove_output_filter(ap_filter_t *f);
518 * Remove an input filter from either the request or connection stack
519 * it is associated with.
520 * @param next The filter stack to search
521 * @param handle The filter handle (name) to remove
522 * @return APR_SUCCESS on removal or error
524 AP_DECLARE(apr_status_t) ap_remove_input_filter_byhandle(ap_filter_t *next,
527 * Remove an output filter from either the request or connection stack
528 * it is associated with.
529 * @param next The filter stack to search
530 * @param handle The filter handle (name) to remove
531 * @return APR_SUCCESS on removal or error
533 AP_DECLARE(apr_status_t) ap_remove_output_filter_byhandle(ap_filter_t *next,
536 /* The next two filters are for abstraction purposes only. They could be
537 * done away with, but that would require that we break modules if we ever
538 * want to change our filter registration method. The basic idea, is that
539 * all filters have a place to store data, the ctx pointer. These functions
540 * fill out that pointer with a bucket brigade, and retrieve that data on
541 * the next call. The nice thing about these functions, is that they
542 * automatically concatenate the bucket brigades together for you. This means
543 * that if you have already stored a brigade in the filters ctx pointer, then
544 * when you add more it will be tacked onto the end of that brigade. When
545 * you retrieve data, if you pass in a bucket brigade to the get function,
546 * it will append the current brigade onto the one that you are retrieving.
550 * Prepare a bucket brigade to be setaside. If a different brigade was
551 * set-aside earlier, then the two brigades are concatenated together.
553 * If *save_to is NULL, the brigade will be created, and a cleanup registered
554 * to clear the brigade address when the pool is destroyed.
555 * @param f The current filter
556 * @param save_to The brigade that was previously set-aside. Regardless, the
557 * new bucket brigade is returned in this location.
558 * @param b The bucket brigade to save aside. This brigade is always empty
560 * @param p Ensure that all data in the brigade lives as long as this pool
562 AP_DECLARE(apr_status_t) ap_save_brigade(ap_filter_t *f,
563 apr_bucket_brigade **save_to,
564 apr_bucket_brigade **b, apr_pool_t *p);
567 * Prepare the filter to allow brigades to be set aside. This can be used
568 * within an input filter to allocate space to set aside data in the input
569 * filters, or can be used within an output filter by being called via
570 * ap_filter_setaside_brigade().
571 * @param f The current filter
572 * @param p The pool that was used to create the brigade. In a request
573 * filter this will be the request pool, in a connection filter this will
574 * be the connection pool.
575 * @returns OK if a brigade was created, DECLINED otherwise.
577 AP_DECLARE(int) ap_filter_prepare_brigade(ap_filter_t *f, apr_pool_t **p);
580 * Prepare a bucket brigade to be setaside, creating a dedicated pool if
581 * necessary within the filter to handle the lifetime of the setaside brigade.
582 * @param f The current filter
583 * @param bb The bucket brigade to set aside. This brigade is always empty
586 AP_DECLARE(apr_status_t) ap_filter_setaside_brigade(ap_filter_t *f,
587 apr_bucket_brigade *bb);
590 * Reinstate a brigade setaside earlier, and calculate the amount of data we
591 * should write based on the presence of flush buckets, size limits on in
592 * memory buckets, and the number of outstanding requests in the pipeline.
593 * This is a safety mechanism to protect against a module that might try
594 * generate data too quickly for downstream to handle without yielding as
597 * If the brigade passed in is empty, we reinstate the brigade and return
598 * immediately on the assumption that any buckets needing to be flushed were
599 * flushed before being passed to ap_filter_setaside_brigade().
601 * @param f The current filter
602 * @param bb The bucket brigade to restore to.
603 * @param flush_upto Work out the bucket we need to flush up to, based on the
604 * presence of a flush bucket, size limits on in-memory
605 * buckets, size limits on the number of requests outstanding
607 * @return APR_SUCCESS.
609 AP_DECLARE(apr_status_t) ap_filter_reinstate_brigade(ap_filter_t *f,
610 apr_bucket_brigade *bb,
611 apr_bucket **flush_upto);
614 * This function calculates whether there are any as yet unsent
615 * buffered brigades in downstream filters, and returns non zero
618 * A filter should use this to determine whether the passing of data
619 * downstream might block, and so defer the passing of brigades
620 * downstream with ap_filter_setaside_brigade().
622 * This function can be called safely from a handler.
624 AP_DECLARE(int) ap_filter_should_yield(ap_filter_t *f);
627 * This function determines whether there is unwritten data in the output
628 * filters, and if so, attempts to make a single write to each filter
629 * with unwritten data.
631 * @param c The connection.
632 * @return If no unwritten data remains, this function returns DECLINED.
633 * If some unwritten data remains, this function returns OK. If any
634 * attempt to write data failed, this functions returns a positive integer.
636 AP_DECLARE_NONSTD(int) ap_filter_output_pending(conn_rec *c);
639 * This function determines whether there is pending data in the input
640 * filters. Pending data is data that has been read from the underlying
641 * socket but not yet returned to the application.
643 * @param c The connection.
644 * @return If no pending data remains, this function returns DECLINED.
645 * If some pending data remains, this function returns OK.
647 AP_DECLARE_NONSTD(int) ap_filter_input_pending(conn_rec *c);
650 * Flush function for apr_brigade_* calls. This calls ap_pass_brigade
651 * to flush the brigade if the brigade buffer overflows.
652 * @param bb The brigade to flush
653 * @param ctx The filter to pass the brigade to
654 * @note this function has nothing to do with FLUSH buckets. It is simply
655 * a way to flush content out of a brigade and down a filter stack.
657 AP_DECLARE_NONSTD(apr_status_t) ap_filter_flush(apr_bucket_brigade *bb,
661 * Flush the current brigade down the filter stack.
662 * @param f The filter we are passing to
663 * @param bb The brigade to flush
665 AP_DECLARE(apr_status_t) ap_fflush(ap_filter_t *f, apr_bucket_brigade *bb);
668 * Write a buffer for the current filter, buffering if possible.
669 * @param f the filter we are writing to
670 * @param bb The brigade to buffer into
671 * @param data The data to write
672 * @param nbyte The number of bytes in the data
674 #define ap_fwrite(f, bb, data, nbyte) \
675 apr_brigade_write(bb, ap_filter_flush, f, data, nbyte)
678 * Write a buffer for the current filter, buffering if possible.
679 * @param f the filter we are writing to
680 * @param bb The brigade to buffer into
681 * @param str The string to write
683 #define ap_fputs(f, bb, str) \
684 apr_brigade_write(bb, ap_filter_flush, f, str, strlen(str))
687 * Write a character for the current filter, buffering if possible.
688 * @param f the filter we are writing to
689 * @param bb The brigade to buffer into
690 * @param c The character to write
692 #define ap_fputc(f, bb, c) \
693 apr_brigade_putc(bb, ap_filter_flush, f, c)
696 * Write an unspecified number of strings to the current filter
697 * @param f the filter we are writing to
698 * @param bb The brigade to buffer into
699 * @param ... The strings to write
701 AP_DECLARE_NONSTD(apr_status_t) ap_fputstrs(ap_filter_t *f,
702 apr_bucket_brigade *bb,
707 * Output data to the filter in printf format
708 * @param f the filter we are writing to
709 * @param bb The brigade to buffer into
710 * @param fmt The format string
711 * @param ... The arguments to use to fill out the format string
713 AP_DECLARE_NONSTD(apr_status_t) ap_fprintf(ap_filter_t *f,
714 apr_bucket_brigade *bb,
717 __attribute__((format(printf,3,4)));
720 * set protocol requirements for an output content filter
721 * (only works with AP_FTYPE_RESOURCE and AP_FTYPE_CONTENT_SET)
722 * @param f the filter in question
723 * @param proto_flags Logical OR of AP_FILTER_PROTO_* bits
725 AP_DECLARE(void) ap_filter_protocol(ap_filter_t* f, unsigned int proto_flags);
727 /** Filter changes contents (so invalidating checksums/etc) */
728 #define AP_FILTER_PROTO_CHANGE 0x1
730 /** Filter changes length of contents (so invalidating content-length/etc) */
731 #define AP_FILTER_PROTO_CHANGE_LENGTH 0x2
733 /** Filter requires complete input and can't work on byteranges */
734 #define AP_FILTER_PROTO_NO_BYTERANGE 0x4
736 /** Filter should not run in a proxy */
737 #define AP_FILTER_PROTO_NO_PROXY 0x8
739 /** Filter makes output non-cacheable */
740 #define AP_FILTER_PROTO_NO_CACHE 0x10
742 /** Filter is incompatible with "Cache-Control: no-transform" */
743 #define AP_FILTER_PROTO_TRANSFORM 0x20
753 #endif /* !AP_FILTER_H */