← Back to branch summary

~ubuntu-branches/ubuntu/feisty/apache2/feisty

« back to all changes in this revision

Viewing changes to modules/proxy/ajp_header.c

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Barth
  • Date: 2006-12-09 21:05:45 UTC
  • mfrom: (0.6.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20061209210545-h70s0xaqc2v8vqr2
Tags: 2.2.3-3.2
http://bugs.debian.org/396265
* Non-maintainer upload.
* 043_ajp_connection_reuse: Patch from upstream Bugzilla, fixing a critical
  issue with regard to connection reuse in mod_proxy_ajp.
  Closes: #396265

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/proxy/ajp_header.c
 
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
#include "ajp_header.h"
 
18
#include "ajp.h"
 
19
 
 
20
static const char *response_trans_headers[] = {
 
21
    "Content-Type",
 
22
    "Content-Language",
 
23
    "Content-Length",
 
24
    "Date",
 
25
    "Last-Modified",
 
26
    "Location",
 
27
    "Set-Cookie",
 
28
    "Set-Cookie2",
 
29
    "Servlet-Engine",
 
30
    "Status",
 
31
    "WWW-Authenticate"
 
32
};
 
33
 
 
34
static const char *long_res_header_for_sc(int sc)
 
35
{
 
36
    const char *rc = NULL;
 
37
    sc = sc & 0X00FF;
 
38
    if(sc <= SC_RES_HEADERS_NUM && sc > 0) {
 
39
        rc = response_trans_headers[sc - 1];
 
40
    }
 
41
 
 
42
    return rc;
 
43
}
 
44
 
 
45
#define UNKNOWN_METHOD (-1)
 
46
 
 
47
static int sc_for_req_header(const char *header_name)
 
48
{
 
49
    char header[16];
 
50
    apr_size_t len = strlen(header_name);
 
51
    const char *p = header_name;
 
52
    int i = 0;
 
53
 
 
54
    /* ACCEPT-LANGUAGE is the longest headeer
 
55
     * that is of interest.
 
56
     */
 
57
    if (len < 4 || len > 15)
 
58
        return UNKNOWN_METHOD;
 
59
 
 
60
    while (*p)
 
61
        header[i++] = apr_toupper(*p++);
 
62
    header[i] = '\0';
 
63
    p = &header[1];
 
64
 
 
65
    switch (header[0]) {
 
66
        case 'A':
 
67
            if (memcmp(p, "CCEPT", 5) == 0) {
 
68
                if (!header[6])
 
69
                    return SC_ACCEPT;
 
70
                else if (header[6] == '-') {
 
71
                    p += 6;
 
72
                    if (memcmp(p, "CHARSET", 7) == 0)
 
73
                        return SC_ACCEPT_CHARSET;
 
74
                    else if (memcmp(p,  "ENCODING", 8) == 0)
 
75
                        return SC_ACCEPT_ENCODING;
 
76
                    else if (memcmp(p, "LANGUAGE", 8) == 0)
 
77
                        return SC_ACCEPT_LANGUAGE;
 
78
                    else
 
79
                        return UNKNOWN_METHOD;
 
80
                }
 
81
                else
 
82
                    return UNKNOWN_METHOD;
 
83
            }
 
84
            else if (memcmp(p, "UTHORIZATION", 12) == 0)
 
85
                return SC_AUTHORIZATION;
 
86
            else
 
87
                return UNKNOWN_METHOD;
 
88
        break;
 
89
        case 'C':
 
90
            if(memcmp(p, "OOKIE2", 6) == 0)
 
91
                return SC_COOKIE2;
 
92
            else if (memcmp(p, "OOKIE", 5) == 0)
 
93
                return SC_COOKIE;
 
94
            else if(memcmp(p, "ONNECTION", 9) == 0)
 
95
                return SC_CONNECTION;
 
96
            else if(memcmp(p, "ONTENT-TYPE", 11) == 0)
 
97
                return SC_CONTENT_TYPE;
 
98
            else if(memcmp(p, "ONTENT-LENGTH", 13) == 0)
 
99
                return SC_CONTENT_LENGTH;
 
100
            else
 
101
                return UNKNOWN_METHOD;
 
102
        break;
 
103
        case 'H':
 
104
            if(memcmp(p, "OST", 3) == 0)
 
105
                return SC_HOST;
 
106
            else
 
107
                return UNKNOWN_METHOD;
 
108
        break;
 
109
        case 'P':
 
110
            if(memcmp(p, "RAGMA", 5) == 0)
 
111
                return SC_PRAGMA;
 
112
            else
 
113
                return UNKNOWN_METHOD;
 
114
        break;
 
115
        case 'R':
 
116
            if(memcmp(p, "EFERER", 6) == 0)
 
117
                return SC_REFERER;
 
118
            else
 
119
                return UNKNOWN_METHOD;
 
120
        break;
 
121
        case 'U':
 
122
            if(memcmp(p, "SER-AGENT", 9) == 0)
 
123
                return SC_USER_AGENT;
 
124
            else
 
125
                return UNKNOWN_METHOD;
 
126
        break;
 
127
        default:
 
128
            return UNKNOWN_METHOD;
 
129
    }
 
130
 
 
131
    /* NOTREACHED */
 
132
}
 
133
 
 
134
/* Apache method number to SC methods transform table */
 
135
static const unsigned char sc_for_req_method_table[] = {
 
136
    SC_M_GET,
 
137
    SC_M_PUT,
 
138
    SC_M_POST,
 
139
    SC_M_DELETE,
 
140
    0,                      /* M_DELETE */
 
141
    SC_M_OPTIONS,
 
142
    SC_M_TRACE,
 
143
    0,                      /* M_PATCH  */
 
144
    SC_M_PROPFIND,
 
145
    SC_M_PROPPATCH,
 
146
    SC_M_MKCOL,
 
147
    SC_M_COPY,
 
148
    SC_M_MOVE,
 
149
    SC_M_LOCK,
 
150
    SC_M_UNLOCK,
 
151
    SC_M_VERSION_CONTROL,
 
152
    SC_M_CHECKOUT,
 
153
    SC_M_UNCHECKOUT,
 
154
    SC_M_CHECKIN,
 
155
    SC_M_UPDATE,
 
156
    SC_M_LABEL,
 
157
    SC_M_REPORT,
 
158
    SC_M_MKWORKSPACE,
 
159
    SC_M_MKACTIVITY,
 
160
    SC_M_BASELINE_CONTROL,
 
161
    SC_M_MERGE,
 
162
    0                       /* M_INVALID */
 
163
};
 
164
 
 
165
static int sc_for_req_method_by_id(int method_id)
 
166
{
 
167
    if (method_id < 0 || method_id > M_INVALID)
 
168
        return UNKNOWN_METHOD;
 
169
    else
 
170
        return sc_for_req_method_table[method_id] ?
 
171
               sc_for_req_method_table[method_id] : UNKNOWN_METHOD;
 
172
}
 
173
 
 
174
/*
 
175
 * Message structure
 
176
 *
 
177
 *
 
178
AJPV13_REQUEST/AJPV14_REQUEST=
 
179
    request_prefix (1) (byte)
 
180
    method         (byte)
 
181
    protocol       (string)
 
182
    req_uri        (string)
 
183
    remote_addr    (string)
 
184
    remote_host    (string)
 
185
    server_name    (string)
 
186
    server_port    (short)
 
187
    is_ssl         (boolean)
 
188
    num_headers    (short)
 
189
    num_headers*(req_header_name header_value)
 
190
 
 
191
    ?context       (byte)(string)
 
192
    ?servlet_path  (byte)(string)
 
193
    ?remote_user   (byte)(string)
 
194
    ?auth_type     (byte)(string)
 
195
    ?query_string  (byte)(string)
 
196
    ?jvm_route     (byte)(string)
 
197
    ?ssl_cert      (byte)(string)
 
198
    ?ssl_cipher    (byte)(string)
 
199
    ?ssl_session   (byte)(string)
 
200
    ?ssl_key_size  (byte)(int)      via JkOptions +ForwardKeySize
 
201
    request_terminator (byte)
 
202
    ?body          content_length*(var binary)
 
203
 
 
204
 */
 
205
 
 
206
static apr_status_t ajp_marshal_into_msgb(ajp_msg_t *msg,
 
207
                                          request_rec *r,
 
208
                                          apr_uri_t *uri)
 
209
{
 
210
    int method;
 
211
    apr_uint32_t i, num_headers = 0;
 
212
    apr_byte_t is_ssl;
 
213
    char *remote_host;
 
214
    const char *session_route, *envvar;
 
215
    const apr_array_header_t *arr = apr_table_elts(r->subprocess_env);
 
216
    const apr_table_entry_t *elts = (const apr_table_entry_t *)arr->elts;
 
217
 
 
218
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
 
219
                         "Into ajp_marshal_into_msgb");
 
220
 
 
221
    if ((method = sc_for_req_method_by_id(r->method_number)) == UNKNOWN_METHOD) {
 
222
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
223
               "ajp_marshal_into_msgb - No such method %s",
 
224
               r->method);
 
225
        return AJP_EBAD_METHOD;
 
226
    }
 
227
 
 
228
    is_ssl = (apr_byte_t) ap_proxy_conn_is_https(r->connection);
 
229
 
 
230
    if (r->headers_in && apr_table_elts(r->headers_in)) {
 
231
        const apr_array_header_t *t = apr_table_elts(r->headers_in);
 
232
        num_headers = t->nelts;
 
233
    }
 
234
 
 
235
    remote_host = (char *)ap_get_remote_host(r->connection, r->per_dir_config, REMOTE_HOST, NULL);
 
236
 
 
237
    ajp_msg_reset(msg);
 
238
 
 
239
    if (ajp_msg_append_uint8(msg, CMD_AJP13_FORWARD_REQUEST)     ||
 
240
        ajp_msg_append_uint8(msg, method)                        ||
 
241
        ajp_msg_append_string(msg, r->protocol)                  ||
 
242
        ajp_msg_append_string(msg, uri->path)                    ||
 
243
        ajp_msg_append_string(msg, r->connection->remote_ip)     ||
 
244
        ajp_msg_append_string(msg, remote_host)                  ||
 
245
        ajp_msg_append_string(msg, ap_get_server_name(r))        ||
 
246
        ajp_msg_append_uint16(msg, (apr_uint16_t)r->connection->local_addr->port) ||
 
247
        ajp_msg_append_uint8(msg, is_ssl)                        ||
 
248
        ajp_msg_append_uint16(msg, (apr_uint16_t) num_headers)) {
 
249
 
 
250
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
251
               "ajp_marshal_into_msgb: "
 
252
               "Error appending the message begining");
 
253
        return APR_EGENERAL;
 
254
    }
 
255
 
 
256
    for (i = 0 ; i < num_headers ; i++) {
 
257
        int sc;
 
258
        const apr_array_header_t *t = apr_table_elts(r->headers_in);
 
259
        const apr_table_entry_t *elts = (apr_table_entry_t *)t->elts;
 
260
 
 
261
        if ((sc = sc_for_req_header(elts[i].key)) != UNKNOWN_METHOD) {
 
262
            if (ajp_msg_append_uint16(msg, (apr_uint16_t)sc)) {
 
263
                ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
264
                       "ajp_marshal_into_msgb: "
 
265
                       "Error appending the header name");
 
266
                return AJP_EOVERFLOW;
 
267
            }
 
268
        }
 
269
        else {
 
270
            if (ajp_msg_append_string(msg, elts[i].key)) {
 
271
                ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
272
                       "ajp_marshal_into_msgb: "
 
273
                       "Error appending the header name");
 
274
                return AJP_EOVERFLOW;
 
275
            }
 
276
        }
 
277
 
 
278
        if (ajp_msg_append_string(msg, elts[i].val)) {
 
279
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
280
                   "ajp_marshal_into_msgb: "
 
281
                   "Error appending the header value");
 
282
            return AJP_EOVERFLOW;
 
283
        }
 
284
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
 
285
                   "ajp_marshal_into_msgb: Header[%d] [%s] = [%s]",
 
286
                   i, elts[i].key, elts[i].val);
 
287
    }
 
288
 
 
289
/* XXXX need to figure out how to do this
 
290
    if (s->secret) {
 
291
        if (ajp_msg_append_uint8(msg, SC_A_SECRET) ||
 
292
            ajp_msg_append_string(msg, s->secret)) {
 
293
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
294
                   "Error ajp_marshal_into_msgb - "
 
295
                   "Error appending secret");
 
296
            return APR_EGENERAL;
 
297
        }
 
298
    }
 
299
 */
 
300
 
 
301
    if (r->user) {
 
302
        if (ajp_msg_append_uint8(msg, SC_A_REMOTE_USER) ||
 
303
            ajp_msg_append_string(msg, r->user)) {
 
304
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
305
                   "ajp_marshal_into_msgb: "
 
306
                   "Error appending the remote user");
 
307
            return AJP_EOVERFLOW;
 
308
        }
 
309
    }
 
310
    if (r->ap_auth_type) {
 
311
        if (ajp_msg_append_uint8(msg, SC_A_AUTH_TYPE) ||
 
312
            ajp_msg_append_string(msg, r->ap_auth_type)) {
 
313
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
314
                   "ajp_marshal_into_msgb: "
 
315
                   "Error appending the auth type");
 
316
            return AJP_EOVERFLOW;
 
317
        }
 
318
    }
 
319
    /* XXXX  ebcdic (args converted?) */
 
320
    if (uri->query) {
 
321
        if (ajp_msg_append_uint8(msg, SC_A_QUERY_STRING) ||
 
322
            ajp_msg_append_string(msg, uri->query)) {
 
323
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
324
                   "ajp_marshal_into_msgb: "
 
325
                   "Error appending the query string");
 
326
            return AJP_EOVERFLOW;
 
327
        }
 
328
    }
 
329
    if ((session_route = apr_table_get(r->notes, "session-route"))) {
 
330
        if (ajp_msg_append_uint8(msg, SC_A_JVM_ROUTE) ||
 
331
            ajp_msg_append_string(msg, session_route)) {
 
332
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
333
                   "ajp_marshal_into_msgb: "
 
334
                   "Error appending the jvm route");
 
335
            return AJP_EOVERFLOW;
 
336
        }
 
337
    }
 
338
/* XXX: Is the subprocess_env a right place?
 
339
 * <Location /examples>
 
340
 *   ProxyPass ajp://remote:8009/servlets-examples
 
341
 *   SetEnv SSL_SESSION_ID CUSTOM_SSL_SESSION_ID
 
342
 * </Location>
 
343
 */
 
344
    /*
 
345
     * Only lookup SSL variables if we are currently running HTTPS.
 
346
     * Furthermore ensure that only variables get set in the AJP message
 
347
     * that are not NULL and not empty.
 
348
     */
 
349
    if (is_ssl) {
 
350
        if ((envvar = ap_proxy_ssl_val(r->pool, r->server, r->connection, r,
 
351
                                       AJP13_SSL_CLIENT_CERT_INDICATOR))
 
352
            && envvar[0]) {
 
353
            if (ajp_msg_append_uint8(msg, SC_A_SSL_CERT)
 
354
                || ajp_msg_append_string(msg, envvar)) {
 
355
                ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
356
                             "ajp_marshal_into_msgb: "
 
357
                             "Error appending the SSL certificates");
 
358
                return AJP_EOVERFLOW;
 
359
            }
 
360
        }
 
361
 
 
362
        if ((envvar = ap_proxy_ssl_val(r->pool, r->server, r->connection, r,
 
363
                                       AJP13_SSL_CIPHER_INDICATOR))
 
364
            && envvar[0]) {
 
365
            if (ajp_msg_append_uint8(msg, SC_A_SSL_CIPHER)
 
366
                || ajp_msg_append_string(msg, envvar)) {
 
367
                ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
368
                             "ajp_marshal_into_msgb: "
 
369
                             "Error appending the SSL ciphers");
 
370
                return AJP_EOVERFLOW;
 
371
            }
 
372
        }
 
373
 
 
374
        if ((envvar = ap_proxy_ssl_val(r->pool, r->server, r->connection, r,
 
375
                                       AJP13_SSL_SESSION_INDICATOR))
 
376
            && envvar[0]) {
 
377
            if (ajp_msg_append_uint8(msg, SC_A_SSL_SESSION)
 
378
                || ajp_msg_append_string(msg, envvar)) {
 
379
                ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
380
                             "ajp_marshal_into_msgb: "
 
381
                             "Error appending the SSL session");
 
382
                return AJP_EOVERFLOW;
 
383
            }
 
384
        }
 
385
 
 
386
        /* ssl_key_size is required by Servlet 2.3 API */
 
387
        if ((envvar = ap_proxy_ssl_val(r->pool, r->server, r->connection, r,
 
388
                                       AJP13_SSL_KEY_SIZE_INDICATOR))
 
389
            && envvar[0]) {
 
390
 
 
391
            if (ajp_msg_append_uint8(msg, SC_A_SSL_KEY_SIZE)
 
392
                || ajp_msg_append_uint16(msg, (unsigned short) atoi(envvar))) {
 
393
                ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
394
                             "Error ajp_marshal_into_msgb - "
 
395
                             "Error appending the SSL key size");
 
396
                return APR_EGENERAL;
 
397
            }
 
398
        }
 
399
    }
 
400
    /* Use the environment vars prefixed with AJP_
 
401
     * and pass it to the header striping that prefix.
 
402
     */
 
403
    for (i = 0; i < (apr_uint32_t)arr->nelts; i++) {
 
404
        if (!strncmp(elts[i].key, "AJP_", 4)) {
 
405
            if (ajp_msg_append_uint8(msg, SC_A_REQ_ATTRIBUTE) ||
 
406
                ajp_msg_append_string(msg, elts[i].key + 4)   ||
 
407
                ajp_msg_append_string(msg, elts[i].val)) {
 
408
                ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
409
                        "ajp_marshal_into_msgb: "
 
410
                        "Error appending attribute %s=%s",
 
411
                        elts[i].key, elts[i].val);
 
412
                return AJP_EOVERFLOW;
 
413
            }
 
414
        }
 
415
    }
 
416
 
 
417
    if (ajp_msg_append_uint8(msg, SC_A_ARE_DONE)) {
 
418
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
419
               "ajp_marshal_into_msgb: "
 
420
               "Error appending the message end");
 
421
        return AJP_EOVERFLOW;
 
422
    }
 
423
 
 
424
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
 
425
            "ajp_marshal_into_msgb: Done");
 
426
    return APR_SUCCESS;
 
427
}
 
428
 
 
429
/*
 
430
AJPV13_RESPONSE/AJPV14_RESPONSE:=
 
431
    response_prefix (2)
 
432
    status          (short)
 
433
    status_msg      (short)
 
434
    num_headers     (short)
 
435
    num_headers*(res_header_name header_value)
 
436
    *body_chunk
 
437
    terminator      boolean <! -- recycle connection or not  -->
 
438
 
 
439
req_header_name :=
 
440
    sc_req_header_name | (string)
 
441
 
 
442
res_header_name :=
 
443
    sc_res_header_name | (string)
 
444
 
 
445
header_value :=
 
446
    (string)
 
447
 
 
448
body_chunk :=
 
449
    length  (short)
 
450
    body    length*(var binary)
 
451
 
 
452
 */
 
453
 
 
454
 
 
455
static apr_status_t ajp_unmarshal_response(ajp_msg_t *msg,
 
456
                                           request_rec *r,
 
457
                                           proxy_dir_conf *dconf)
 
458
{
 
459
    apr_uint16_t status;
 
460
    apr_status_t rc;
 
461
    const char *ptr;
 
462
    apr_uint16_t  num_headers;
 
463
    int i;
 
464
 
 
465
    rc = ajp_msg_get_uint16(msg, &status);
 
466
 
 
467
    if (rc != APR_SUCCESS) {
 
468
         ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
469
                "ajp_unmarshal_response: Null status");
 
470
        return rc;
 
471
    }
 
472
    r->status = status;
 
473
 
 
474
    rc = ajp_msg_get_string(msg, &ptr);
 
475
    if (rc == APR_SUCCESS) {
 
476
        r->status_line =  apr_psprintf(r->pool, "%d %s", status, ptr);
 
477
#if defined(AS400) || defined(_OSD_POSIX)
 
478
        ap_xlate_proto_from_ascii(r->status_line, strlen(r->status_line));
 
479
#endif
 
480
    } else {
 
481
        r->status_line = NULL;
 
482
    }
 
483
 
 
484
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
 
485
           "ajp_unmarshal_response: status = %d", status);
 
486
 
 
487
    rc = ajp_msg_get_uint16(msg, &num_headers);
 
488
    if (rc == APR_SUCCESS) {
 
489
        r->headers_out = apr_table_make(r->pool, num_headers);
 
490
    } else {
 
491
        r->headers_out = NULL;
 
492
        num_headers = 0;
 
493
    }
 
494
 
 
495
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
 
496
           "ajp_unmarshal_response: Number of headers is = %d",
 
497
           num_headers);
 
498
 
 
499
    for(i = 0 ; i < (int) num_headers ; i++) {
 
500
        apr_uint16_t name;
 
501
        const char *stringname;
 
502
        const char *value;
 
503
        rc  = ajp_msg_peek_uint16(msg, &name);
 
504
        if (rc != APR_SUCCESS) {
 
505
            return rc;
 
506
        }
 
507
 
 
508
        if ((name & 0XFF00) == 0XA000) {
 
509
            ajp_msg_get_uint16(msg, &name);
 
510
            stringname = long_res_header_for_sc(name);
 
511
            if (stringname == NULL) {
 
512
                ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
513
                       "ajp_unmarshal_response: "
 
514
                       "No such sc (%08x)",
 
515
                       name);
 
516
                return AJP_EBAD_HEADER;
 
517
            }
 
518
        } else {
 
519
            name = 0;
 
520
            rc = ajp_msg_get_string(msg, &stringname);
 
521
            if (rc != APR_SUCCESS) {
 
522
                ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
523
                       "ajp_unmarshal_response: "
 
524
                       "Null header name");
 
525
                return rc;
 
526
            }
 
527
#if defined(AS400) || defined(_OSD_POSIX)
 
528
            ap_xlate_proto_from_ascii(stringname, strlen(stringname));
 
529
#endif
 
530
        }
 
531
 
 
532
        rc = ajp_msg_get_string(msg, &value);
 
533
        if (rc != APR_SUCCESS) {
 
534
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
535
                   "ajp_unmarshal_response: "
 
536
                   "Null header value");
 
537
            return rc;
 
538
        }
 
539
 
 
540
        /* Set-Cookie need additional processing */
 
541
        if (!strcasecmp(stringname, "Set-Cookie")) {
 
542
            value = ap_proxy_cookie_reverse_map(r, dconf, value);
 
543
        }
 
544
        /* Location, Content-Location, URI and Destination need additional
 
545
         * processing */
 
546
        else if (!strcasecmp(stringname, "Location")
 
547
                 || !strcasecmp(stringname, "Content-Location")
 
548
                 || !strcasecmp(stringname, "URI")
 
549
                 || !strcasecmp(stringname, "Destination"))
 
550
        {
 
551
          value = ap_proxy_location_reverse_map(r, dconf, value);
 
552
        }
 
553
 
 
554
#if defined(AS400) || defined(_OSD_POSIX)
 
555
        ap_xlate_proto_from_ascii(value, strlen(value));
 
556
#endif
 
557
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
 
558
               "ajp_unmarshal_response: Header[%d] [%s] = [%s]",
 
559
                       i, stringname, value);
 
560
 
 
561
        apr_table_add(r->headers_out, stringname, value);
 
562
 
 
563
        /* Content-type needs an additional handling */
 
564
        if (memcmp(stringname, "Content-Type", 12) == 0) {
 
565
             /* add corresponding filter */
 
566
            ap_set_content_type(r, apr_pstrdup(r->pool, value));
 
567
            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
 
568
               "ajp_unmarshal_response: ap_set_content_type done");
 
569
        }
 
570
    }
 
571
 
 
572
    return APR_SUCCESS;
 
573
}
 
574
 
 
575
/*
 
576
 * Build the ajp header message and send it
 
577
 */
 
578
apr_status_t ajp_send_header(apr_socket_t *sock,
 
579
                             request_rec *r,
 
580
                             apr_uri_t *uri)
 
581
{
 
582
    ajp_msg_t *msg;
 
583
    apr_status_t rc;
 
584
 
 
585
    rc = ajp_msg_create(r->pool, &msg);
 
586
    if (rc != APR_SUCCESS) {
 
587
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
588
               "ajp_send_header: ajp_msg_create failed");
 
589
        return rc;
 
590
    }
 
591
 
 
592
    rc = ajp_marshal_into_msgb(msg, r, uri);
 
593
    if (rc != APR_SUCCESS) {
 
594
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
595
               "ajp_send_header: ajp_marshal_into_msgb failed");
 
596
        return rc;
 
597
    }
 
598
 
 
599
    rc = ajp_ilink_send(sock, msg);
 
600
    if (rc != APR_SUCCESS) {
 
601
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
602
               "ajp_send_header: ajp_ilink_send failed");
 
603
        return rc;
 
604
    }
 
605
 
 
606
    return APR_SUCCESS;
 
607
}
 
608
 
 
609
/*
 
610
 * Read the ajp message and return the type of the message.
 
611
 */
 
612
apr_status_t ajp_read_header(apr_socket_t *sock,
 
613
                             request_rec  *r,
 
614
                             ajp_msg_t **msg)
 
615
{
 
616
    apr_byte_t result;
 
617
    apr_status_t rc;
 
618
 
 
619
    if (*msg) {
 
620
        rc = ajp_msg_reuse(*msg);
 
621
        if (rc != APR_SUCCESS) {
 
622
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
623
                   "ajp_read_header: ajp_msg_reuse failed");
 
624
            return rc;
 
625
        }
 
626
    }
 
627
    else {
 
628
        rc = ajp_msg_create(r->pool, msg);
 
629
        if (rc != APR_SUCCESS) {
 
630
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
631
                   "ajp_read_header: ajp_msg_create failed");
 
632
            return rc;
 
633
        }
 
634
    }
 
635
    ajp_msg_reset(*msg);
 
636
    rc = ajp_ilink_receive(sock, *msg);
 
637
    if (rc != APR_SUCCESS) {
 
638
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
639
               "ajp_read_header: ajp_ilink_receive failed");
 
640
        return rc;
 
641
    }
 
642
    rc = ajp_msg_peek_uint8(*msg, &result);
 
643
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
 
644
               "ajp_read_header: ajp_ilink_received %02x", result);
 
645
    return APR_SUCCESS;
 
646
}
 
647
 
 
648
/* parse the msg to read the type */
 
649
int ajp_parse_type(request_rec  *r, ajp_msg_t *msg)
 
650
{
 
651
    apr_byte_t result;
 
652
    ajp_msg_peek_uint8(msg, &result);
 
653
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
 
654
               "ajp_parse_type: got %02x", result);
 
655
    return (int) result;
 
656
}
 
657
 
 
658
/* parse the header */
 
659
apr_status_t ajp_parse_header(request_rec  *r, proxy_dir_conf *conf,
 
660
                              ajp_msg_t *msg)
 
661
{
 
662
    apr_byte_t result;
 
663
    apr_status_t rc;
 
664
 
 
665
    rc = ajp_msg_get_uint8(msg, &result);
 
666
    if (rc != APR_SUCCESS) {
 
667
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
668
               "ajp_parse_headers: ajp_msg_get_byte failed");
 
669
        return rc;
 
670
    }
 
671
    if (result != CMD_AJP13_SEND_HEADERS) {
 
672
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
673
               "ajp_parse_headers: wrong type %02x expecting 0x04", result);
 
674
        return AJP_EBAD_HEADER;
 
675
    }
 
676
    return ajp_unmarshal_response(msg, r, conf);
 
677
}
 
678
 
 
679
/* parse the body and return data address and length */
 
680
apr_status_t  ajp_parse_data(request_rec  *r, ajp_msg_t *msg,
 
681
                             apr_uint16_t *len, char **ptr)
 
682
{
 
683
    apr_byte_t result;
 
684
    apr_status_t rc;
 
685
    apr_uint16_t expected_len;
 
686
 
 
687
    rc = ajp_msg_get_uint8(msg, &result);
 
688
    if (rc != APR_SUCCESS) {
 
689
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
690
               "ajp_parse_data: ajp_msg_get_byte failed");
 
691
        return rc;
 
692
    }
 
693
    if (result != CMD_AJP13_SEND_BODY_CHUNK) {
 
694
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
695
               "ajp_parse_data: wrong type %02x expecting 0x03", result);
 
696
        return AJP_EBAD_HEADER;
 
697
    }
 
698
    rc = ajp_msg_get_uint16(msg, len);
 
699
    if (rc != APR_SUCCESS) {
 
700
        return rc;
 
701
    }
 
702
    /*
 
703
     * msg->len contains the complete length of the message including all
 
704
     * headers. So the expected length for a CMD_AJP13_SEND_BODY_CHUNK is
 
705
     * msg->len minus the sum of
 
706
     * AJP_HEADER_LEN    : The length of the header to every AJP message.
 
707
     * AJP_HEADER_SZ_LEN : The header giving the size of the chunk.
 
708
     * 1                 : The CMD_AJP13_SEND_BODY_CHUNK indicator byte (0x03).
 
709
     * 1                 : The last byte of this message always seems to be
 
710
     *                     0x00 and is not part of the chunk.
 
711
     */
 
712
    expected_len = msg->len - (AJP_HEADER_LEN + AJP_HEADER_SZ_LEN + 1 + 1);
 
713
    if (*len != expected_len) {
 
714
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
 
715
               "ajp_parse_data: Wrong chunk length. Length of chunk is %i,"
 
716
               " expected length is %i.", *len, expected_len);
 
717
        return AJP_EBAD_HEADER;
 
718
    }
 
719
    *ptr = (char *)&(msg->buf[msg->pos]);
 
720
    return APR_SUCCESS;
 
721
}
 
722
 
 
723
/*
 
724
 * Allocate a msg to send data
 
725
 */
 
726
apr_status_t  ajp_alloc_data_msg(apr_pool_t *pool, char **ptr, apr_size_t *len,
 
727
                                 ajp_msg_t **msg)
 
728
{
 
729
    apr_status_t rc;
 
730
 
 
731
    if ((rc = ajp_msg_create(pool, msg)) != APR_SUCCESS)
 
732
        return rc;
 
733
    ajp_msg_reset(*msg);
 
734
    *ptr = (char *)&((*msg)->buf[6]);
 
735
    *len = AJP_MSG_BUFFER_SZ-6;
 
736
 
 
737
    return APR_SUCCESS;
 
738
}
 
739
 
 
740
/*
 
741
 * Send the data message
 
742
 */
 
743
apr_status_t  ajp_send_data_msg(apr_socket_t *sock,
 
744
                                ajp_msg_t *msg, apr_size_t len)
 
745
{
 
746
 
 
747
    msg->buf[4] = (apr_byte_t)((len >> 8) & 0xFF);
 
748
    msg->buf[5] = (apr_byte_t)(len & 0xFF);
 
749
 
 
750
    msg->len += len + 2; /* + 1 XXXX where is '\0' */
 
751
 
 
752
    return ajp_ilink_send(sock, msg);
 
753
 
 
754
}