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"
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
* @brief 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 APACHE_CORE_FILTER Filter Chain
76
* @ingroup APACHE_CORE
78
* Filters operate using a "chaining" mechanism. The filters are chained
79
* together into a sequence. When output is generated, it is passed through
80
* each of the filters on this chain, until it reaches the end (or "bottom")
81
* and is placed onto the network.
83
* The top of the chain, the code generating the output, is typically called
84
* a "content generator." The content generator's output is fed into the
85
* filter chain using the standard Apache output mechanisms: ap_rputs(),
86
* ap_rprintf(), ap_rwrite(), etc.
88
* Each filter is defined by a callback. This callback takes the output from
89
* the previous filter (or the content generator if there is no previous
90
* filter), operates on it, and passes the result to the next filter in the
91
* chain. This pass-off is performed using the ap_fc_* functions, such as
92
* ap_fc_puts(), ap_fc_printf(), ap_fc_write(), etc.
94
* When content generation is complete, the system will pass an "end of
95
* stream" marker into the filter chain. The filters will use this to flush
96
* out any internal state and to detect incomplete syntax (for example, an
97
* unterminated SSI directive).
100
/* forward declare the filter type */
101
typedef struct ap_filter_t ap_filter_t;
104
* @name Filter callbacks
106
* This function type is used for filter callbacks. It will be passed a
107
* pointer to "this" filter, and a "bucket" containing the content to be
110
* In filter->ctx, the callback will find its context. This context is
111
* provided here, so that a filter may be installed multiple times, each
112
* receiving its own per-install context pointer.
114
* Callbacks are associated with a filter definition, which is specified
115
* by name. See ap_register_input_filter() and ap_register_output_filter()
116
* for setting the association between a name for a filter and its
117
* associated callback (and other information).
119
* If the initialization function argument passed to the registration
120
* functions is non-NULL, it will be called iff the filter is in the input
121
* or output filter chains and before any data is generated to allow the
122
* filter to prepare for processing.
124
* The *bucket structure (and all those referenced by ->next and ->prev)
125
* should be considered "const". The filter is allowed to modify the
126
* next/prev to insert/remove/replace elements in the bucket list, but
127
* the types and values of the individual buckets should not be altered.
129
* For the input and output filters, the return value of a filter should be
130
* an APR status value. For the init function, the return value should
131
* be an HTTP error code or OK if it was successful.
136
typedef apr_status_t (*ap_out_filter_func)(ap_filter_t *f,
137
apr_bucket_brigade *b);
138
typedef apr_status_t (*ap_in_filter_func)(ap_filter_t *f,
139
apr_bucket_brigade *b,
140
ap_input_mode_t mode,
141
apr_read_type_e block,
142
apr_off_t readbytes);
143
typedef int (*ap_init_filter_func)(ap_filter_t *f);
145
typedef union ap_filter_func {
146
ap_out_filter_func out_func;
147
ap_in_filter_func in_func;
153
* Filters have different types/classifications. These are used to group
154
* and sort the filters to properly sequence their operation.
156
* The types have a particular sort order, which allows us to insert them
157
* into the filter chain in a determistic order. Within a particular grouping,
158
* the ordering is equivalent to the order of calls to ap_add_*_filter().
161
/** These filters are used to alter the content that is passed through
162
* them. Examples are SSI or PHP. */
163
AP_FTYPE_RESOURCE = 10,
164
/** These filters are used to alter the content as a whole, but after all
165
* AP_FTYPE_RESOURCE filters are executed. These filters should not
166
* change the content-type. An example is deflate. */
167
AP_FTYPE_CONTENT_SET = 20,
168
/** These filters are used to handle the protocol between server and
169
* client. Examples are HTTP and POP. */
170
AP_FTYPE_PROTOCOL = 30,
171
/** These filters implement transport encodings (e.g., chunking). */
172
AP_FTYPE_TRANSCODE = 40,
173
/** These filters will alter the content, but in ways that are
174
* more strongly associated with the connection. Examples are
175
* splitting an HTTP connection into multiple requests and
176
* buffering HTTP responses across multiple requests.
178
* It is important to note that these types of filters are not
179
* allowed in a sub-request. A sub-request's output can certainly
180
* be filtered by ::AP_FTYPE_RESOURCE filters, but all of the "final
181
* processing" is determined by the main request. */
182
AP_FTYPE_CONNECTION = 50,
183
/** These filters don't alter the content. They are responsible for
184
* sending/receiving data to/from the client. */
185
AP_FTYPE_NETWORK = 60
189
* This is the request-time context structure for an installed filter (in
190
* the output filter chain). It provides the callback to use for filtering,
191
* the request this filter is associated with (which is important when
192
* an output chain also includes sub-request filters), the context for this
193
* installed filter, and the filter ordering/chaining fields.
195
* Filter callbacks are free to use ->ctx as they please, to store context
196
* during the filter process. Generally, this is superior over associating
197
* the state directly with the request. A callback should not change any of
201
typedef struct ap_filter_rec_t ap_filter_rec_t;
202
typedef struct ap_filter_provider_t ap_filter_provider_t;
205
* @brief This structure is used for recording information about the
206
* registered filters. It associates a name with the filter's callback
209
* At the moment, these are simply linked in a chain, so a ->next pointer
212
* It is used for any filter that can be inserted in the filter chain.
213
* This may be either a httpd-2.0 filter or a mod_filter harness.
214
* In the latter case it contains dispatch, provider and protocol information.
215
* In the former case, the new fields (from dispatch) are ignored.
217
struct ap_filter_rec_t {
218
/** The registered name for this filter */
221
/** The function to call when this filter is invoked. */
222
ap_filter_func filter_func;
224
/** The function to call before the handlers are invoked. Notice
225
* that this function is called only for filters participating in
226
* the http protocol. Filters for other protocols are to be
227
* initialized by the protocols themselves.
229
ap_init_filter_func filter_init_func;
231
/** The type of filter, either AP_FTYPE_CONTENT or AP_FTYPE_CONNECTION.
232
* An AP_FTYPE_CONTENT filter modifies the data based on information
233
* found in the content. An AP_FTYPE_CONNECTION filter modifies the
234
* data based on the type of connection.
236
ap_filter_type ftype;
238
/** The next filter_rec in the list */
239
struct ap_filter_rec_t *next;
241
/** Providers for this filter */
242
ap_filter_provider_t *providers;
244
/** Trace level for this filter */
247
/** Protocol flags for this filter */
248
unsigned int proto_flags;
252
* @brief The representation of a filter chain.
254
* Each request has a list
255
* of these structures which are called in turn to filter the data. Sub
256
* requests get an exact copy of the main requests filter chain.
259
/** The internal representation of this filter. This includes
260
* the filter's name, type, and the actual function pointer.
262
ap_filter_rec_t *frec;
264
/** A place to store any data associated with the current filter */
267
/** The next filter in the chain */
270
/** The request_rec associated with the current filter. If a sub-request
271
* adds filters, then the sub-request is the request associated with the
276
/** The conn_rec associated with the current filter. This is analogous
277
* to the request_rec, except that it is used for input filtering.
283
* Get the current bucket brigade from the next filter on the filter
284
* stack. The filter returns an apr_status_t value. If the bottom-most
285
* filter doesn't read from the network, then ::AP_NOBODY_READ is returned.
286
* The bucket brigade will be empty when there is nothing left to get.
287
* @param filter The next filter in the chain
288
* @param bucket The current bucket brigade. The original brigade passed
289
* to ap_get_brigade() must be empty.
290
* @param mode The way in which the data should be read
291
* @param block How the operations should be performed
292
* ::APR_BLOCK_READ, ::APR_NONBLOCK_READ
293
* @param readbytes How many bytes to read from the next filter.
295
AP_DECLARE(apr_status_t) ap_get_brigade(ap_filter_t *filter,
296
apr_bucket_brigade *bucket,
297
ap_input_mode_t mode,
298
apr_read_type_e block,
299
apr_off_t readbytes);
302
* Pass the current bucket brigade down to the next filter on the filter
303
* stack. The filter returns an apr_status_t value. If the bottom-most
304
* filter doesn't write to the network, then ::AP_NOBODY_WROTE is returned.
305
* The caller relinquishes ownership of the brigade.
306
* @param filter The next filter in the chain
307
* @param bucket The current bucket brigade
309
AP_DECLARE(apr_status_t) ap_pass_brigade(ap_filter_t *filter,
310
apr_bucket_brigade *bucket);
313
* This function is used to register an input filter with the system.
314
* After this registration is performed, then a filter may be added
315
* into the filter chain by using ap_add_input_filter() and simply
316
* specifying the name.
318
* @param name The name to attach to the filter function
319
* @param filter_func The filter function to name
320
* @param filter_init The function to call before the filter handlers
322
* @param ftype The type of filter function, either ::AP_FTYPE_CONTENT or
323
* ::AP_FTYPE_CONNECTION
324
* @see add_input_filter()
326
AP_DECLARE(ap_filter_rec_t *) ap_register_input_filter(const char *name,
327
ap_in_filter_func filter_func,
328
ap_init_filter_func filter_init,
329
ap_filter_type ftype);
332
* This function is used to register an output filter with the system.
333
* After this registration is performed, then a filter may be added
334
* into the filter chain by using ap_add_output_filter() and simply
335
* specifying the name. It may also be used as a provider under mod_filter.
336
* This is (equivalent to) ap_register_output_filter_protocol with
337
* proto_flags=0, and is retained for back-compatibility with 2.0 modules.
339
* @param name The name to attach to the filter function
340
* @param filter_func The filter function to name
341
* @param filter_init The function to call before the filter handlers
343
* @param ftype The type of filter function, either ::AP_FTYPE_CONTENT or
344
* ::AP_FTYPE_CONNECTION
345
* @see ap_add_output_filter()
347
AP_DECLARE(ap_filter_rec_t *) ap_register_output_filter(const char *name,
348
ap_out_filter_func filter_func,
349
ap_init_filter_func filter_init,
350
ap_filter_type ftype);
352
/* For httpd-2.2 I suggest replacing the above with
353
#define ap_register_output_filter(name,ffunc,init,ftype) \
354
ap_register_output_filter_protocol(name,ffunc,init,ftype,0)
358
* This function is used to register an output filter with the system.
359
* After this registration is performed, then a filter may be added
360
* into the filter chain by using ap_add_output_filter() and simply
361
* specifying the name. It may also be used as a provider under mod_filter.
363
* @param name The name to attach to the filter function
364
* @param filter_func The filter function to name
365
* @param filter_init The function to call before the filter handlers
367
* @param ftype The type of filter function, either ::AP_FTYPE_CONTENT or
368
* ::AP_FTYPE_CONNECTION
369
* @param proto_flags Protocol flags: logical OR of AP_FILTER_PROTO_* bits
370
* @see ap_add_output_filter()
372
AP_DECLARE(ap_filter_rec_t *) ap_register_output_filter_protocol(
374
ap_out_filter_func filter_func,
375
ap_init_filter_func filter_init,
376
ap_filter_type ftype,
377
unsigned int proto_flags);
380
* Adds a named filter into the filter chain on the specified request record.
381
* The filter will be installed with the specified context pointer.
383
* Filters added in this way will always be placed at the end of the filters
384
* that have the same type (thus, the filters have the same order as the
385
* calls to ap_add_filter). If the current filter chain contains filters
386
* from another request, then this filter will be added before those other
389
* To re-iterate that last comment. This function is building a FIFO
390
* list of filters. Take note of that when adding your filter to the chain.
392
* @param name The name of the filter to add
393
* @param ctx Context data to provide to the filter
394
* @param r The request to add this filter for (or NULL if it isn't associated with a request)
395
* @param c The connection to add the fillter for
397
AP_DECLARE(ap_filter_t *) ap_add_input_filter(const char *name, void *ctx,
398
request_rec *r, conn_rec *c);
401
* Variant of ap_add_input_filter() that accepts a registered filter handle
402
* (as returned by ap_register_input_filter()) rather than a filter name
404
* @param f The filter handle to add
405
* @param ctx Context data to provide to the filter
406
* @param r The request to add this filter for (or NULL if it isn't associated with a request)
407
* @param c The connection to add the fillter for
409
AP_DECLARE(ap_filter_t *) ap_add_input_filter_handle(ap_filter_rec_t *f,
415
* Returns the filter handle for use with ap_add_input_filter_handle.
417
* @param name The filter name to look up
419
AP_DECLARE(ap_filter_rec_t *) ap_get_input_filter_handle(const char *name);
422
* Add a filter to the current request. Filters are added in a FIFO manner.
423
* The first filter added will be the first filter called.
424
* @param name The name of the filter to add
425
* @param ctx Context data to set in the filter
426
* @param r The request to add this filter for (or NULL if it isn't associated with a request)
427
* @param c The connection to add this filter for
429
AP_DECLARE(ap_filter_t *) ap_add_output_filter(const char *name, void *ctx,
430
request_rec *r, conn_rec *c);
433
* Variant of ap_add_output_filter() that accepts a registered filter handle
434
* (as returned by ap_register_output_filter()) rather than a filter name
436
* @param f The filter handle to add
437
* @param r The request to add this filter for (or NULL if it isn't associated with a request)
438
* @param c The connection to add the fillter for
440
AP_DECLARE(ap_filter_t *) ap_add_output_filter_handle(ap_filter_rec_t *f,
446
* Returns the filter handle for use with ap_add_output_filter_handle.
448
* @param name The filter name to look up
450
AP_DECLARE(ap_filter_rec_t *) ap_get_output_filter_handle(const char *name);
453
* Remove an input filter from either the request or connection stack
454
* it is associated with.
455
* @param f The filter to remove
458
AP_DECLARE(void) ap_remove_input_filter(ap_filter_t *f);
461
* Remove an output filter from either the request or connection stack
462
* it is associated with.
463
* @param f The filter to remove
466
AP_DECLARE(void) ap_remove_output_filter(ap_filter_t *f);
468
/* The next two filters are for abstraction purposes only. They could be
469
* done away with, but that would require that we break modules if we ever
470
* want to change our filter registration method. The basic idea, is that
471
* all filters have a place to store data, the ctx pointer. These functions
472
* fill out that pointer with a bucket brigade, and retrieve that data on
473
* the next call. The nice thing about these functions, is that they
474
* automatically concatenate the bucket brigades together for you. This means
475
* that if you have already stored a brigade in the filters ctx pointer, then
476
* when you add more it will be tacked onto the end of that brigade. When
477
* you retrieve data, if you pass in a bucket brigade to the get function,
478
* it will append the current brigade onto the one that you are retrieving.
482
* prepare a bucket brigade to be setaside. If a different brigade was
483
* set-aside earlier, then the two brigades are concatenated together.
484
* @param f The current filter
485
* @param save_to The brigade that was previously set-aside. Regardless, the
486
* new bucket brigade is returned in this location.
487
* @param b The bucket brigade to save aside. This brigade is always empty
489
* @param p Ensure that all data in the brigade lives as long as this pool
491
AP_DECLARE(apr_status_t) ap_save_brigade(ap_filter_t *f,
492
apr_bucket_brigade **save_to,
493
apr_bucket_brigade **b, apr_pool_t *p);
496
* Flush function for apr_brigade_* calls. This calls ap_pass_brigade
497
* to flush the brigade if the brigade buffer overflows.
498
* @param bb The brigade to flush
499
* @param ctx The filter to pass the brigade to
500
* @note this function has nothing to do with FLUSH buckets. It is simply
501
* a way to flush content out of a brigade and down a filter stack.
503
AP_DECLARE_NONSTD(apr_status_t) ap_filter_flush(apr_bucket_brigade *bb,
507
* Flush the current brigade down the filter stack.
508
* @param f The filter we are passing to
509
* @param bb The brigade to flush
511
AP_DECLARE(apr_status_t) ap_fflush(ap_filter_t *f, apr_bucket_brigade *bb);
514
* Write a buffer for the current filter, buffering if possible.
515
* @param f the filter we are writing to
516
* @param bb The brigade to buffer into
517
* @param data The data to write
518
* @param nbyte The number of bytes in the data
520
#define ap_fwrite(f, bb, data, nbyte) \
521
apr_brigade_write(bb, ap_filter_flush, f, data, nbyte)
524
* Write a buffer for the current filter, buffering if possible.
525
* @param f the filter we are writing to
526
* @param bb The brigade to buffer into
527
* @param str The string to write
529
#define ap_fputs(f, bb, str) \
530
apr_brigade_puts(bb, ap_filter_flush, f, str)
533
* Write a character for the current filter, buffering if possible.
534
* @param f the filter we are writing to
535
* @param bb The brigade to buffer into
536
* @param c The character to write
538
#define ap_fputc(f, bb, c) \
539
apr_brigade_putc(bb, ap_filter_flush, f, c)
542
* Write an unspecified number of strings to the current filter
543
* @param f the filter we are writing to
544
* @param bb The brigade to buffer into
545
* @param ... The strings to write
547
AP_DECLARE_NONSTD(apr_status_t) ap_fputstrs(ap_filter_t *f,
548
apr_bucket_brigade *bb,
552
* Output data to the filter in printf format
553
* @param f the filter we are writing to
554
* @param bb The brigade to buffer into
555
* @param fmt The format string
556
* @param ... The argumets to use to fill out the format string
558
AP_DECLARE_NONSTD(apr_status_t) ap_fprintf(ap_filter_t *f,
559
apr_bucket_brigade *bb,
562
__attribute__((format(printf,3,4)));
565
* set protocol requirements for an output content filter
566
* (only works with AP_FTYPE_RESOURCE and AP_FTYPE_CONTENT_SET)
567
* @param f the filter in question
568
* @param proto_flags Logical OR of AP_FILTER_PROTO_* bits
570
AP_DECLARE(void) ap_filter_protocol(ap_filter_t* f, unsigned int proto_flags);
572
/** Filter changes contents (so invalidating checksums/etc) */
573
#define AP_FILTER_PROTO_CHANGE 0x1
575
/** Filter changes length of contents (so invalidating content-length/etc) */
576
#define AP_FILTER_PROTO_CHANGE_LENGTH 0x2
578
/** Filter requires complete input and can't work on byteranges */
579
#define AP_FILTER_PROTO_NO_BYTERANGE 0x4
581
/** Filter should not run in a proxy */
582
#define AP_FILTER_PROTO_NO_PROXY 0x8
584
/** Filter makes output non-cacheable */
585
#define AP_FILTER_PROTO_NO_CACHE 0x10
587
/** Filter is incompatible with "Cache-Control: no-transform" */
588
#define AP_FILTER_PROTO_TRANSFORM 0x20
594
#endif /* !AP_FILTER_H */
added
removed
install-files/bin/apache/apache2.2.6/include/util_filter.h
