← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/httpd24/src/include/util_filter.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/httpd24/src/include/util_filter.h
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
7
 
 *
8
 
 *     http://www.apache.org/licenses/LICENSE-2.0
9
 
 *
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.
15
 
 */
16
 
 
17
 
/**
18
 
 * @file util_filter.h
19
 
 * @brief Apache filter library
20
 
 */
21
 
 
22
 
#ifndef AP_FILTER_H
23
 
#define AP_FILTER_H
24
 
 
25
 
#include "apr.h"
26
 
#include "apr_buckets.h"
27
 
 
28
 
#include "httpd.h"
29
 
 
30
 
#if APR_HAVE_STDARG_H
31
 
#include <stdarg.h>
32
 
#endif
33
 
 
34
 
#ifdef __cplusplus
35
 
extern "C" {
36
 
#endif
37
 
 
38
 
/**
39
 
 * @brief input filtering modes
40
 
 */
41
 
typedef enum {
42
 
    /** The filter should return at most readbytes data. */
43
 
    AP_MODE_READBYTES,
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).
47
 
     */
48
 
    AP_MODE_GETLINE,
49
 
    /** The filter should implicitly eat any CRLF pairs that it sees. */
50
 
    AP_MODE_EATCRLF,
51
 
    /** The filter read should be treated as speculative and any returned
52
 
     *  data should be stored for later retrieval in another mode. */
53
 
    AP_MODE_SPECULATIVE,
54
 
    /** The filter read should be exhaustive and read until it can not
55
 
     *  read any more.
56
 
     *  Use this mode with extreme caution.
57
 
     */
58
 
    AP_MODE_EXHAUSTIVE,
59
 
    /** The filter should initialize the connection if needed,
60
 
     *  NNTP or FTP over SSL for example.
61
 
     */
62
 
    AP_MODE_INIT
63
 
} ap_input_mode_t;
64
 
 
65
 
/**
66
 
 * @defgroup APACHE_CORE_FILTER Filter Chain
67
 
 * @ingroup  APACHE_CORE
68
 
 *
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.
73
 
 *
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.
78
 
 *
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.
84
 
 *
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).
89
 
 *
90
 
 * @{
91
 
 */
92
 
 
93
 
/* forward declare the filter type */
94
 
typedef struct ap_filter_t ap_filter_t;
95
 
 
96
 
/**
97
 
 * @name Filter callbacks
98
 
 *
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
101
 
 * to be filtered.
102
 
 *
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.
106
 
 *
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).
111
 
 *
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.
116
 
 *
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.
126
 
 *
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.
130
 
 *
131
 
 * @ingroup filter
132
 
 * @{
133
 
 */
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);
142
 
 
143
 
typedef union ap_filter_func {
144
 
    ap_out_filter_func out_func;
145
 
    ap_in_filter_func in_func;
146
 
} ap_filter_func;
147
 
 
148
 
/** @} */
149
 
 
150
 
/**
151
 
 * Filters have different types/classifications. These are used to group
152
 
 * and sort the filters to properly sequence their operation.
153
 
 *
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().
157
 
 */
158
 
typedef enum {
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.
175
 
     *
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
184
 
} ap_filter_type;
185
 
 
186
 
/**
187
 
 * This is the request-time context structure for an installed filter (in
188
 
 * the output filter chain). It provides the callback to use for filtering,
189
 
 * the request this filter is associated with (which is important when
190
 
 * an output chain also includes sub-request filters), the context for this
191
 
 * installed filter, and the filter ordering/chaining fields.
192
 
 *
193
 
 * Filter callbacks are free to use ->ctx as they please, to store context
194
 
 * during the filter process. Generally, this is superior over associating
195
 
 * the state directly with the request. A callback should not change any of
196
 
 * the other fields.
197
 
 */
198
 
 
199
 
typedef struct ap_filter_rec_t ap_filter_rec_t;
200
 
typedef struct ap_filter_provider_t ap_filter_provider_t;
201
 
 
202
 
/**
203
 
 * @brief This structure is used for recording information about the
204
 
 * registered filters. It associates a name with the filter's callback
205
 
 * and filter type.
206
 
 *
207
 
 * At the moment, these are simply linked in a chain, so a ->next pointer
208
 
 * is available.
209
 
 *
210
 
 * It is used for any filter that can be inserted in the filter chain.
211
 
 * This may be either a httpd-2.0 filter or a mod_filter harness.
212
 
 * In the latter case it contains dispatch, provider and protocol information.
213
 
 * In the former case, the new fields (from dispatch) are ignored.
214
 
 */
215
 
struct ap_filter_rec_t {
216
 
    /** The registered name for this filter */
217
 
    const char *name;
218
 
 
219
 
    /** The function to call when this filter is invoked. */
220
 
    ap_filter_func filter_func;
221
 
 
222
 
    /** The function to call directly before the handlers are invoked
223
 
     * for a request.  The init function is called once directly
224
 
     * before running the handlers for a request or subrequest.  The
225
 
     * init function is never called for a connection filter (with
226
 
     * ftype >= AP_FTYPE_CONNECTION).  Any use of this function for
227
 
     * filters for protocols other than HTTP is specified by the
228
 
     * module supported that protocol.
229
 
     */
230
 
    ap_init_filter_func filter_init_func;
231
 
 
232
 
    /** The next filter_rec in the list */
233
 
    struct ap_filter_rec_t *next;
234
 
 
235
 
    /** Providers for this filter */
236
 
    ap_filter_provider_t *providers;
237
 
 
238
 
    /** The type of filter, either AP_FTYPE_CONTENT or AP_FTYPE_CONNECTION.
239
 
     * An AP_FTYPE_CONTENT filter modifies the data based on information
240
 
     * found in the content.  An AP_FTYPE_CONNECTION filter modifies the
241
 
     * data based on the type of connection.
242
 
     */
243
 
    ap_filter_type ftype;
244
 
 
245
 
    /** Trace level for this filter */
246
 
    int debug;
247
 
 
248
 
    /** Protocol flags for this filter */
249
 
    unsigned int proto_flags;
250
 
};
251
 
 
252
 
/**
253
 
 * @brief The representation of a filter chain.
254
 
 *
255
 
 * Each request has a list
256
 
 * of these structures which are called in turn to filter the data.  Sub
257
 
 * requests get an exact copy of the main requests filter chain.
258
 
 */
259
 
struct ap_filter_t {
260
 
    /** The internal representation of this filter.  This includes
261
 
     *  the filter's name, type, and the actual function pointer.
262
 
     */
263
 
    ap_filter_rec_t *frec;
264
 
 
265
 
    /** A place to store any data associated with the current filter */
266
 
    void *ctx;
267
 
 
268
 
    /** The next filter in the chain */
269
 
    ap_filter_t *next;
270
 
 
271
 
    /** The request_rec associated with the current filter.  If a sub-request
272
 
     *  adds filters, then the sub-request is the request associated with the
273
 
     *  filter.
274
 
     */
275
 
    request_rec *r;
276
 
 
277
 
    /** The conn_rec associated with the current filter.  This is analogous
278
 
     *  to the request_rec, except that it is used for connection filters.
279
 
     */
280
 
    conn_rec *c;
281
 
};
282
 
 
283
 
/**
284
 
 * Get the current bucket brigade from the next filter on the filter
285
 
 * stack.  The filter returns an apr_status_t value.  If the bottom-most
286
 
 * filter doesn't read from the network, then ::AP_NOBODY_READ is returned.
287
 
 * The bucket brigade will be empty when there is nothing left to get.
288
 
 * @param filter The next filter in the chain
289
 
 * @param bucket The current bucket brigade.  The original brigade passed
290
 
 *               to ap_get_brigade() must be empty.
291
 
 * @param mode   The way in which the data should be read
292
 
 * @param block  How the operations should be performed
293
 
 *               ::APR_BLOCK_READ, ::APR_NONBLOCK_READ
294
 
 * @param readbytes How many bytes to read from the next filter.
295
 
 */
296
 
AP_DECLARE(apr_status_t) ap_get_brigade(ap_filter_t *filter,
297
 
                                        apr_bucket_brigade *bucket,
298
 
                                        ap_input_mode_t mode,
299
 
                                        apr_read_type_e block,
300
 
                                        apr_off_t readbytes);
301
 
 
302
 
/**
303
 
 * Pass the current bucket brigade down to the next filter on the filter
304
 
 * stack.  The filter returns an apr_status_t value.  If the bottom-most
305
 
 * filter doesn't write to the network, then ::AP_NOBODY_WROTE is returned.
306
 
 * @param filter The next filter in the chain
307
 
 * @param bucket The current bucket brigade
308
 
 *
309
 
 * @remark Ownership of the brigade is retained by the caller. On return,
310
 
 *         the contents of the brigade are UNDEFINED, and the caller must
311
 
 *         either call apr_brigade_cleanup or apr_brigade_destroy on
312
 
 *         the brigade.
313
 
 */
314
 
AP_DECLARE(apr_status_t) ap_pass_brigade(ap_filter_t *filter,
315
 
                                         apr_bucket_brigade *bucket);
316
 
 
317
 
/**
318
 
 * Pass the current bucket brigade down to the next filter on the filter
319
 
 * stack checking for filter errors.  The filter returns an apr_status_t value.
320
 
 * Returns ::OK if the brigade is successfully passed
321
 
 *         ::AP_FILTER_ERROR on a filter error
322
 
 *         ::HTTP_INTERNAL_SERVER_ERROR on all other errors
323
 
 * @param r      The request rec
324
 
 * @param bucket The current bucket brigade
325
 
 * @param fmt The format string. If NULL defaults to "ap_pass_brigade returned"
326
 
 * @param ... The arguments to use to fill out the format string
327
 
 * @remark Ownership of the brigade is retained by the caller. On return,
328
 
 *         the contents of the brigade are UNDEFINED, and the caller must
329
 
 *         either call apr_brigade_cleanup or apr_brigade_destroy on
330
 
 *         the brigade.
331
 
 */
332
 
AP_DECLARE(apr_status_t) ap_pass_brigade_fchk(request_rec *r,
333
 
                                              apr_bucket_brigade *bucket,
334
 
                                              const char *fmt,
335
 
                                              ...);
336
 
 
337
 
 
338
 
/**
339
 
 * This function is used to register an input filter with the system.
340
 
 * After this registration is performed, then a filter may be added
341
 
 * into the filter chain by using ap_add_input_filter() and simply
342
 
 * specifying the name.
343
 
 *
344
 
 * @param name The name to attach to the filter function
345
 
 * @param filter_func The filter function to name
346
 
 * @param filter_init The function to call before the filter handlers
347
 
                      are invoked
348
 
 * @param ftype The type of filter function, either ::AP_FTYPE_CONTENT_SET or
349
 
 *              ::AP_FTYPE_CONNECTION
350
 
 * @see add_input_filter()
351
 
 */
352
 
AP_DECLARE(ap_filter_rec_t *) ap_register_input_filter(const char *name,
353
 
                                          ap_in_filter_func filter_func,
354
 
                                          ap_init_filter_func filter_init,
355
 
                                          ap_filter_type ftype);
356
 
 
357
 
/** @deprecated @see ap_register_output_filter_protocol */
358
 
AP_DECLARE(ap_filter_rec_t *) ap_register_output_filter(const char *name,
359
 
                                            ap_out_filter_func filter_func,
360
 
                                            ap_init_filter_func filter_init,
361
 
                                            ap_filter_type ftype);
362
 
 
363
 
/* For httpd-?.? I suggest replacing the above with
364
 
#define ap_register_output_filter(name,ffunc,init,ftype) \
365
 
             ap_register_output_filter_protocol(name,ffunc,init,ftype,0)
366
 
*/
367
 
 
368
 
/**
369
 
 * This function is used to register an output filter with the system.
370
 
 * After this registration is performed, then a filter may be added
371
 
 * directly to the filter chain by using ap_add_output_filter() and
372
 
 * simply specifying the name, or as a provider under mod_filter.
373
 
 *
374
 
 * @param name The name to attach to the filter function
375
 
 * @param filter_func The filter function to name
376
 
 * @param filter_init The function to call before the filter handlers
377
 
 *                    are invoked
378
 
 * @param ftype The type of filter function, either ::AP_FTYPE_CONTENT_SET or
379
 
 *              ::AP_FTYPE_CONNECTION
380
 
 * @param proto_flags Protocol flags: logical OR of AP_FILTER_PROTO_* bits
381
 
 * @return the filter rec
382
 
 * @see ap_add_output_filter()
383
 
 */
384
 
AP_DECLARE(ap_filter_rec_t *) ap_register_output_filter_protocol(
385
 
                                            const char *name,
386
 
                                            ap_out_filter_func filter_func,
387
 
                                            ap_init_filter_func filter_init,
388
 
                                            ap_filter_type ftype,
389
 
                                            unsigned int proto_flags);
390
 
 
391
 
/**
392
 
 * Adds a named filter into the filter chain on the specified request record.
393
 
 * The filter will be installed with the specified context pointer.
394
 
 *
395
 
 * Filters added in this way will always be placed at the end of the filters
396
 
 * that have the same type (thus, the filters have the same order as the
397
 
 * calls to ap_add_filter). If the current filter chain contains filters
398
 
 * from another request, then this filter will be added before those other
399
 
 * filters.
400
 
 *
401
 
 * To re-iterate that last comment.  This function is building a FIFO
402
 
 * list of filters.  Take note of that when adding your filter to the chain.
403
 
 *
404
 
 * @param name The name of the filter 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
408
 
 */
409
 
AP_DECLARE(ap_filter_t *) ap_add_input_filter(const char *name, void *ctx,
410
 
                                              request_rec *r, conn_rec *c);
411
 
 
412
 
/**
413
 
 * Variant of ap_add_input_filter() that accepts a registered filter handle
414
 
 * (as returned by ap_register_input_filter()) rather than a filter name
415
 
 *
416
 
 * @param f The filter handle to add
417
 
 * @param ctx Context data to provide to the filter
418
 
 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
419
 
 * @param c The connection to add the fillter for
420
 
 */
421
 
AP_DECLARE(ap_filter_t *) ap_add_input_filter_handle(ap_filter_rec_t *f,
422
 
                                                     void *ctx,
423
 
                                                     request_rec *r,
424
 
                                                     conn_rec *c);
425
 
 
426
 
/**
427
 
 * Returns the filter handle for use with ap_add_input_filter_handle.
428
 
 *
429
 
 * @param name The filter name to look up
430
 
 */
431
 
AP_DECLARE(ap_filter_rec_t *) ap_get_input_filter_handle(const char *name);
432
 
 
433
 
/**
434
 
 * Add a filter to the current request.  Filters are added in a FIFO manner.
435
 
 * The first filter added will be the first filter called.
436
 
 * @param name The name of the filter to add
437
 
 * @param ctx Context data to set in the filter
438
 
 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
439
 
 * @param c The connection to add this filter for
440
 
 * @note If adding a connection-level output filter (i.e. where the type
441
 
 * is >= AP_FTYPE_CONNECTION) during processing of a request, the request
442
 
 * object r must be passed in to ensure the filter chains are modified
443
 
 * correctly.  f->r will still be initialized as NULL in the new filter.
444
 
 */
445
 
AP_DECLARE(ap_filter_t *) ap_add_output_filter(const char *name, void *ctx,
446
 
                                               request_rec *r, conn_rec *c);
447
 
 
448
 
/**
449
 
 * Variant of ap_add_output_filter() that accepts a registered filter handle
450
 
 * (as returned by ap_register_output_filter()) rather than a filter name
451
 
 *
452
 
 * @param f The filter handle to add
453
 
 * @param ctx Context data to set in the filter
454
 
 * @param r The request to add this filter for (or NULL if it isn't associated with a request)
455
 
 * @param c The connection to add the filter for
456
 
 * @note If adding a connection-level output filter (i.e. where the type
457
 
 * is >= AP_FTYPE_CONNECTION) during processing of a request, the request
458
 
 * object r must be passed in to ensure the filter chains are modified
459
 
 * correctly.  f->r will still be initialized as NULL in the new filter.
460
 
 */
461
 
AP_DECLARE(ap_filter_t *) ap_add_output_filter_handle(ap_filter_rec_t *f,
462
 
                                                      void *ctx,
463
 
                                                      request_rec *r,
464
 
                                                      conn_rec *c);
465
 
 
466
 
/**
467
 
 * Returns the filter handle for use with ap_add_output_filter_handle.
468
 
 *
469
 
 * @param name The filter name to look up
470
 
 */
471
 
AP_DECLARE(ap_filter_rec_t *) ap_get_output_filter_handle(const char *name);
472
 
 
473
 
/**
474
 
 * Remove an input filter from either the request or connection stack
475
 
 * it is associated with.
476
 
 * @param f The filter to remove
477
 
 */
478
 
 
479
 
AP_DECLARE(void) ap_remove_input_filter(ap_filter_t *f);
480
 
 
481
 
/**
482
 
 * Remove an output filter from either the request or connection stack
483
 
 * it is associated with.
484
 
 * @param f The filter to remove
485
 
 */
486
 
 
487
 
AP_DECLARE(void) ap_remove_output_filter(ap_filter_t *f);
488
 
 
489
 
/* The next two filters are for abstraction purposes only.  They could be
490
 
 * done away with, but that would require that we break modules if we ever
491
 
 * want to change our filter registration method.  The basic idea, is that
492
 
 * all filters have a place to store data, the ctx pointer.  These functions
493
 
 * fill out that pointer with a bucket brigade, and retrieve that data on
494
 
 * the next call.  The nice thing about these functions, is that they
495
 
 * automatically concatenate the bucket brigades together for you.  This means
496
 
 * that if you have already stored a brigade in the filters ctx pointer, then
497
 
 * when you add more it will be tacked onto the end of that brigade.  When
498
 
 * you retrieve data, if you pass in a bucket brigade to the get function,
499
 
 * it will append the current brigade onto the one that you are retrieving.
500
 
 */
501
 
 
502
 
/**
503
 
 * prepare a bucket brigade to be setaside.  If a different brigade was
504
 
 * set-aside earlier, then the two brigades are concatenated together.
505
 
 * @param f The current filter
506
 
 * @param save_to The brigade that was previously set-aside.  Regardless, the
507
 
 *             new bucket brigade is returned in this location.
508
 
 * @param b The bucket brigade to save aside.  This brigade is always empty
509
 
 *          on return
510
 
 * @param p Ensure that all data in the brigade lives as long as this pool
511
 
 */
512
 
AP_DECLARE(apr_status_t) ap_save_brigade(ap_filter_t *f,
513
 
                                         apr_bucket_brigade **save_to,
514
 
                                         apr_bucket_brigade **b, apr_pool_t *p);
515
 
 
516
 
/**
517
 
 * Flush function for apr_brigade_* calls.  This calls ap_pass_brigade
518
 
 * to flush the brigade if the brigade buffer overflows.
519
 
 * @param bb The brigade to flush
520
 
 * @param ctx The filter to pass the brigade to
521
 
 * @note this function has nothing to do with FLUSH buckets. It is simply
522
 
 * a way to flush content out of a brigade and down a filter stack.
523
 
 */
524
 
AP_DECLARE_NONSTD(apr_status_t) ap_filter_flush(apr_bucket_brigade *bb,
525
 
                                                void *ctx);
526
 
 
527
 
/**
528
 
 * Flush the current brigade down the filter stack.
529
 
 * @param f The filter we are passing to
530
 
 * @param bb The brigade to flush
531
 
 */
532
 
AP_DECLARE(apr_status_t) ap_fflush(ap_filter_t *f, apr_bucket_brigade *bb);
533
 
 
534
 
/**
535
 
 * Write a buffer for the current filter, buffering if possible.
536
 
 * @param f the filter we are writing to
537
 
 * @param bb The brigade to buffer into
538
 
 * @param data The data to write
539
 
 * @param nbyte The number of bytes in the data
540
 
 */
541
 
#define ap_fwrite(f, bb, data, nbyte) \
542
 
        apr_brigade_write(bb, ap_filter_flush, f, data, nbyte)
543
 
 
544
 
/**
545
 
 * Write a buffer for the current filter, buffering if possible.
546
 
 * @param f the filter we are writing to
547
 
 * @param bb The brigade to buffer into
548
 
 * @param str The string to write
549
 
 */
550
 
#define ap_fputs(f, bb, str) \
551
 
        apr_brigade_puts(bb, ap_filter_flush, f, str)
552
 
 
553
 
/**
554
 
 * Write a character for the current filter, buffering if possible.
555
 
 * @param f the filter we are writing to
556
 
 * @param bb The brigade to buffer into
557
 
 * @param c The character to write
558
 
 */
559
 
#define ap_fputc(f, bb, c) \
560
 
        apr_brigade_putc(bb, ap_filter_flush, f, c)
561
 
 
562
 
/**
563
 
 * Write an unspecified number of strings to the current filter
564
 
 * @param f the filter we are writing to
565
 
 * @param bb The brigade to buffer into
566
 
 * @param ... The strings to write
567
 
 */
568
 
AP_DECLARE_NONSTD(apr_status_t) ap_fputstrs(ap_filter_t *f,
569
 
                                            apr_bucket_brigade *bb,
570
 
                                            ...)
571
 
                                AP_FN_ATTR_SENTINEL;
572
 
 
573
 
/**
574
 
 * Output data to the filter in printf format
575
 
 * @param f the filter we are writing to
576
 
 * @param bb The brigade to buffer into
577
 
 * @param fmt The format string
578
 
 * @param ... The arguments to use to fill out the format string
579
 
 */
580
 
AP_DECLARE_NONSTD(apr_status_t) ap_fprintf(ap_filter_t *f,
581
 
                                           apr_bucket_brigade *bb,
582
 
                                           const char *fmt,
583
 
                                           ...)
584
 
        __attribute__((format(printf,3,4)));
585
 
 
586
 
/**
587
 
 * set protocol requirements for an output content filter
588
 
 * (only works with AP_FTYPE_RESOURCE and AP_FTYPE_CONTENT_SET)
589
 
 * @param f the filter in question
590
 
 * @param proto_flags Logical OR of AP_FILTER_PROTO_* bits
591
 
 */
592
 
AP_DECLARE(void) ap_filter_protocol(ap_filter_t* f, unsigned int proto_flags);
593
 
 
594
 
/** Filter changes contents (so invalidating checksums/etc) */
595
 
#define AP_FILTER_PROTO_CHANGE 0x1
596
 
 
597
 
/** Filter changes length of contents (so invalidating content-length/etc) */
598
 
#define AP_FILTER_PROTO_CHANGE_LENGTH 0x2
599
 
 
600
 
/** Filter requires complete input and can't work on byteranges */
601
 
#define AP_FILTER_PROTO_NO_BYTERANGE 0x4
602
 
 
603
 
/** Filter should not run in a proxy */
604
 
#define AP_FILTER_PROTO_NO_PROXY 0x8
605
 
 
606
 
/** Filter makes output non-cacheable */
607
 
#define AP_FILTER_PROTO_NO_CACHE 0x10
608
 
 
609
 
/** Filter is incompatible with "Cache-Control: no-transform" */
610
 
#define AP_FILTER_PROTO_TRANSFORM 0x20
611
 
 
612
 
/**
613
 
 * @}
614
 
 */
615
 
 
616
 
#ifdef __cplusplus
617
 
}
618
 
#endif
619
 
 
620
 
#endif  /* !AP_FILTER_H */