← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libapache-mod-jk/oneiric

« back to all changes in this revision

Viewing changes to native/common/jk_ajp14.c

  • Committer: Bazaar Package Importer
  • Author(s): Steve Kowalik
  • Date: 2006-08-05 16:30:53 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060805163053-myf66gm6j1a21ps6
Tags: 1:1.2.18-1ubuntu1
Merge from Debian unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
native/common/jk_ajp14.c
 
1
/*
 
2
 *  Copyright 1999-2004 The Apache Software Foundation
 
3
 *
 
4
 *  Licensed under the Apache License, Version 2.0 (the "License");
 
5
 *  you may not use this file except in compliance with the License.
 
6
 *  You may obtain a copy of the License at
 
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
 * Description: Next generation bi-directional protocol handler.           *
 
19
 * Author:      Henri Gomez <hgomez@apache.org>                            *
 
20
 * Version:     $Revision: 300507 $                                          *
 
21
 ***************************************************************************/
 
22
 
 
23
 
 
24
#include "jk_global.h"
 
25
#include "jk_util.h"
 
26
#include "jk_map.h"
 
27
#include "jk_ajp_common.h"
 
28
#include "jk_ajp14.h"
 
29
#include "jk_md5.h"
 
30
 
 
31
/*
 
32
 * Compute the MD5 with ENTROPY / SECRET KEY
 
33
 */
 
34
 
 
35
void ajp14_compute_md5(jk_login_service_t *s, jk_logger_t *l)
 
36
{
 
37
    JK_TRACE_ENTER(l);
 
38
    jk_md5((const unsigned char *)s->entropy,
 
39
           (const unsigned char *)s->secret_key, s->computed_key);
 
40
 
 
41
    if (JK_IS_DEBUG_LEVEL(l))
 
42
        jk_log(l, JK_LOG_DEBUG, "(%s/%s) -> (%s)",
 
43
               s->entropy, s->secret_key, s->computed_key);
 
44
    JK_TRACE_EXIT(l);
 
45
}
 
46
 
 
47
 
 
48
/*
 
49
 * Build the Login Init Command
 
50
 *
 
51
 * +-------------------------+---------------------------+---------------------------+
 
52
 * | LOGIN INIT CMD (1 byte) | NEGOCIATION DATA (32bits) | WEB SERVER INFO (CString) |
 
53
 * +-------------------------+---------------------------+---------------------------+
 
54
 *
 
55
 */
 
56
 
 
57
int ajp14_marshal_login_init_into_msgb(jk_msg_buf_t *msg,
 
58
                                       jk_login_service_t *s, jk_logger_t *l)
 
59
{
 
60
    JK_TRACE_ENTER(l);
 
61
    /* To be on the safe side */
 
62
    jk_b_reset(msg);
 
63
 
 
64
    /*
 
65
     * LOGIN
 
66
     */
 
67
    if (jk_b_append_byte(msg, AJP14_LOGINIT_CMD)) {
 
68
        JK_TRACE_EXIT(l);
 
69
        return JK_FALSE;
 
70
    }
 
71
    /*
 
72
     * NEGOCIATION FLAGS
 
73
     */
 
74
    if (jk_b_append_long(msg, s->negociation)) {
 
75
        JK_TRACE_EXIT(l);
 
76
        return JK_FALSE;
 
77
    }
 
78
    /*
 
79
     * WEB-SERVER NAME
 
80
     */
 
81
    if (jk_b_append_string(msg, s->web_server_name)) {
 
82
        jk_log(l, JK_LOG_ERROR,
 
83
               "failed appending the web_server_name string");
 
84
        JK_TRACE_EXIT(l);
 
85
        return JK_FALSE;
 
86
    }
 
87
 
 
88
    JK_TRACE_EXIT(l);
 
89
    return JK_TRUE;
 
90
}
 
91
 
 
92
 
 
93
/*
 
94
 * Decode the Login Seed Command
 
95
 *
 
96
 * +-------------------------+---------------------------+
 
97
 * | LOGIN SEED CMD (1 byte) | MD5 of entropy (32 chars) |
 
98
 * +-------------------------+---------------------------+
 
99
 *
 
100
 */
 
101
 
 
102
int ajp14_unmarshal_login_seed(jk_msg_buf_t *msg,
 
103
                               jk_login_service_t *s, jk_logger_t *l)
 
104
{
 
105
    JK_TRACE_ENTER(l);
 
106
 
 
107
    if (jk_b_get_bytes
 
108
        (msg, (unsigned char *)s->entropy, AJP14_ENTROPY_SEED_LEN) < 0) {
 
109
        jk_log(l, JK_LOG_ERROR,
 
110
               "can't get seed");
 
111
        JK_TRACE_EXIT(l);
 
112
        return JK_FALSE;
 
113
    }
 
114
 
 
115
    s->entropy[AJP14_ENTROPY_SEED_LEN] = 0;     /* Just to have a CString */
 
116
    JK_TRACE_EXIT(l);
 
117
    return JK_TRUE;
 
118
}
 
119
 
 
120
/*
 
121
 * Build the Login Computed Command
 
122
 *
 
123
 * +-------------------------+---------------------------------------+
 
124
 * | LOGIN COMP CMD (1 byte) | MD5 of RANDOM + SECRET KEY (32 chars) |
 
125
 * +-------------------------+---------------------------------------+
 
126
 *
 
127
 */
 
128
 
 
129
int ajp14_marshal_login_comp_into_msgb(jk_msg_buf_t *msg,
 
130
                                       jk_login_service_t *s, jk_logger_t *l)
 
131
{
 
132
    JK_TRACE_ENTER(l);
 
133
 
 
134
    /* To be on the safe side */
 
135
    jk_b_reset(msg);
 
136
 
 
137
    /*
 
138
     * LOGIN
 
139
     */
 
140
    if (jk_b_append_byte(msg, AJP14_LOGCOMP_CMD)) {
 
141
        JK_TRACE_EXIT(l);
 
142
        return JK_FALSE;
 
143
    }
 
144
    /*
 
145
     * COMPUTED-SEED
 
146
     */
 
147
    if (jk_b_append_bytes
 
148
        (msg, (const unsigned char *)s->computed_key,
 
149
         AJP14_COMPUTED_KEY_LEN)) {
 
150
        jk_log(l, JK_LOG_ERROR,
 
151
               "failed appending the COMPUTED MD5 bytes");
 
152
        JK_TRACE_EXIT(l);
 
153
        return JK_FALSE;
 
154
    }
 
155
 
 
156
    JK_TRACE_EXIT(l);
 
157
    return JK_TRUE;
 
158
}
 
159
 
 
160
 
 
161
/*
 
162
 * Decode the LogOk Command
 
163
 *
 
164
 * +--------------------+------------------------+-------------------------------+
 
165
 * | LOGOK CMD (1 byte) | NEGOCIED DATA (32bits) | SERVLET ENGINE INFO (CString) |
 
166
 * +--------------------+------------------------+-------------------------------+
 
167
 *
 
168
 */
 
169
 
 
170
int ajp14_unmarshal_log_ok(jk_msg_buf_t *msg,
 
171
                           jk_login_service_t *s, jk_logger_t *l)
 
172
{
 
173
    unsigned long nego;
 
174
    char *sname;
 
175
 
 
176
    JK_TRACE_ENTER(l);
 
177
 
 
178
    nego = jk_b_get_long(msg);
 
179
 
 
180
    if (nego == 0xFFFFFFFF) {
 
181
        jk_log(l, JK_LOG_ERROR,
 
182
               "can't get negociated data");
 
183
        JK_TRACE_EXIT(l);
 
184
        return JK_FALSE;
 
185
    }
 
186
 
 
187
    sname = (char *)jk_b_get_string(msg);
 
188
 
 
189
    if (!sname) {
 
190
        jk_log(l, JK_LOG_ERROR,
 
191
               "can't get servlet engine name");
 
192
        JK_TRACE_EXIT(l);
 
193
        return JK_FALSE;
 
194
    }
 
195
 
 
196
    if (s->servlet_engine_name) /* take care of removing previously allocated data */
 
197
        free(s->servlet_engine_name);
 
198
 
 
199
    s->servlet_engine_name = strdup(sname);
 
200
 
 
201
    if (!s->servlet_engine_name) {
 
202
        jk_log(l, JK_LOG_ERROR,
 
203
               "can't malloc servlet engine name");
 
204
        JK_TRACE_EXIT(l);
 
205
        return JK_FALSE;
 
206
    }
 
207
 
 
208
    JK_TRACE_EXIT(l);
 
209
    return JK_TRUE;
 
210
}
 
211
 
 
212
 
 
213
/*
 
214
 * Decode the Log Nok Command 
 
215
 *
 
216
 * +---------------------+-----------------------+
 
217
 * | LOGNOK CMD (1 byte) | FAILURE CODE (32bits) |
 
218
 * +---------------------+-----------------------+
 
219
 *
 
220
 */
 
221
 
 
222
int ajp14_unmarshal_log_nok(jk_msg_buf_t *msg, jk_logger_t *l)
 
223
{
 
224
    unsigned long status;
 
225
 
 
226
    JK_TRACE_ENTER(l);
 
227
 
 
228
    status = jk_b_get_long(msg);
 
229
 
 
230
    if (status == 0xFFFFFFFF) {
 
231
        jk_log(l, JK_LOG_ERROR,
 
232
               "can't get failure code");
 
233
        JK_TRACE_EXIT(l);
 
234
        return JK_FALSE;
 
235
    }
 
236
 
 
237
    jk_log(l, JK_LOG_INFO, "Can't Log with servlet engine - code %08lx",
 
238
           status);
 
239
    JK_TRACE_EXIT(l);
 
240
    return JK_TRUE;
 
241
}
 
242
 
 
243
 
 
244
/* 
 
245
 * Build the Shutdown Cmd
 
246
 *
 
247
 * +-----------------------+---------------------------------------+
 
248
 * | SHUTDOWN CMD (1 byte) | MD5 of RANDOM + SECRET KEY (32 chars) |
 
249
 * +-----------------------+---------------------------------------+
 
250
 *
 
251
 */
 
252
 
 
253
int ajp14_marshal_shutdown_into_msgb(jk_msg_buf_t *msg,
 
254
                                     jk_login_service_t *s, jk_logger_t *l)
 
255
{
 
256
 
 
257
    JK_TRACE_ENTER(l);
 
258
 
 
259
    /* To be on the safe side */
 
260
    jk_b_reset(msg);
 
261
 
 
262
    /*
 
263
     * SHUTDOWN CMD
 
264
     */
 
265
    if (jk_b_append_byte(msg, AJP14_SHUTDOWN_CMD)) {
 
266
        JK_TRACE_EXIT(l);
 
267
        return JK_FALSE;
 
268
    }
 
269
    /*
 
270
     * COMPUTED-SEED
 
271
     */
 
272
    if (jk_b_append_bytes
 
273
        (msg, (const unsigned char *)s->computed_key,
 
274
         AJP14_COMPUTED_KEY_LEN)) {
 
275
        jk_log(l, JK_LOG_ERROR,
 
276
               "failed appending the COMPUTED MD5 bytes");
 
277
        JK_TRACE_EXIT(l);
 
278
        return JK_FALSE;
 
279
    }
 
280
 
 
281
    JK_TRACE_EXIT(l);
 
282
    return JK_TRUE;
 
283
}
 
284
 
 
285
/*
 
286
 * Decode the Shutdown Nok Command
 
287
 *
 
288
 * +----------------------+-----------------------+
 
289
 * | SHUTNOK CMD (1 byte) | FAILURE CODE (32bits) |
 
290
 * +----------------------+-----------------------+
 
291
 *
 
292
 */
 
293
int ajp14_unmarshal_shutdown_nok(jk_msg_buf_t *msg, jk_logger_t *l)
 
294
{
 
295
    unsigned long status;
 
296
 
 
297
    JK_TRACE_ENTER(l);
 
298
    status = jk_b_get_long(msg);
 
299
 
 
300
    if (status == 0xFFFFFFFF) {
 
301
        jk_log(l, JK_LOG_ERROR,
 
302
               "can't get failure code");
 
303
        JK_TRACE_EXIT(l);
 
304
        return JK_FALSE;
 
305
    }
 
306
 
 
307
    jk_log(l, JK_LOG_INFO, "Can't shutdown servlet engine - code %08lx",
 
308
           status);
 
309
    JK_TRACE_EXIT(l);
 
310
    return JK_TRUE;
 
311
}
 
312
 
 
313
/*
 
314
 * Build the Unknown Packet
 
315
 *
 
316
 * +-----------------------------+---------------------------------+------------------------------+
 
317
 * | UNKNOWN PACKET CMD (1 byte) | UNHANDLED MESSAGE SIZE (16bits) | UNHANDLED MESSAGE (bytes...) |
 
318
 * +-----------------------------+---------------------------------+------------------------------+
 
319
 *
 
320
 */
 
321
 
 
322
int ajp14_marshal_unknown_packet_into_msgb(jk_msg_buf_t *msg,
 
323
                                           jk_msg_buf_t *unk, jk_logger_t *l)
 
324
{
 
325
    JK_TRACE_ENTER(l);
 
326
 
 
327
    /* To be on the safe side */
 
328
    jk_b_reset(msg);
 
329
 
 
330
    /*
 
331
     * UNKNOWN PACKET CMD
 
332
     */
 
333
    if (jk_b_append_byte(msg, AJP14_UNKNOW_PACKET_CMD)) {
 
334
        JK_TRACE_EXIT(l);
 
335
        return JK_FALSE;
 
336
    }
 
337
    /*
 
338
     * UNHANDLED MESSAGE SIZE
 
339
     */
 
340
    if (jk_b_append_int(msg, (unsigned short)unk->len)) {
 
341
        JK_TRACE_EXIT(l);
 
342
        return JK_FALSE;
 
343
    }
 
344
    /*
 
345
     * UNHANDLED MESSAGE (Question : Did we have to send all the message or only part of)
 
346
     *                                       (           ie: only 1k max                                                                )
 
347
     */
 
348
    if (jk_b_append_bytes(msg, unk->buf, unk->len)) {
 
349
        jk_log(l, JK_LOG_ERROR,
 
350
               "failed appending the UNHANDLED MESSAGE");
 
351
        JK_TRACE_EXIT(l);
 
352
        return JK_FALSE;
 
353
    }
 
354
 
 
355
    JK_TRACE_EXIT(l);
 
356
    return JK_TRUE;
 
357
}
 
358
 
 
359
/*
 
360
 * Build the Context Query Cmd (autoconf)
 
361
 *
 
362
 * +--------------------------+---------------------------------+
 
363
 * | CONTEXT QRY CMD (1 byte) | VIRTUAL HOST NAME (CString (*)) |
 
364
 * +--------------------------+---------------------------------+
 
365
 *
 
366
 */
 
367
 
 
368
int ajp14_marshal_context_query_into_msgb(jk_msg_buf_t *msg,
 
369
                                          char *virtual, jk_logger_t *l)
 
370
{
 
371
    JK_TRACE_ENTER(l);
 
372
 
 
373
    /* To be on the safe side */
 
374
    jk_b_reset(msg);
 
375
 
 
376
    /*
 
377
     * CONTEXT QUERY CMD
 
378
     */
 
379
    if (jk_b_append_byte(msg, AJP14_CONTEXT_QRY_CMD)) {
 
380
        JK_TRACE_EXIT(l);
 
381
        return JK_FALSE;
 
382
    }
 
383
    /*
 
384
     * VIRTUAL HOST CSTRING
 
385
     */
 
386
    if (jk_b_append_string(msg, virtual)) {
 
387
        jk_log(l, JK_LOG_ERROR,
 
388
               "failed appending the virtual host string");
 
389
        JK_TRACE_EXIT(l);
 
390
        return JK_FALSE;
 
391
    }
 
392
 
 
393
    JK_TRACE_EXIT(l);
 
394
    return JK_TRUE;
 
395
}
 
396
 
 
397
 
 
398
/*
 
399
 * Decode the Context Info Cmd (Autoconf)
 
400
 *
 
401
 * The Autoconf feature of AJP14, let us know which URL/URI could
 
402
 * be handled by the servlet-engine
 
403
 *
 
404
 * +---------------------------+---------------------------------+----------------------------+-------------------------------+-----------+
 
405
 * | CONTEXT INFO CMD (1 byte) | VIRTUAL HOST NAME (CString (*)) | CONTEXT NAME (CString (*)) | URL1 [\n] URL2 [\n] URL3 [\n] | NEXT CTX. |
 
406
 * +---------------------------+---------------------------------+----------------------------+-------------------------------+-----------+
 
407
 */
 
408
 
 
409
int ajp14_unmarshal_context_info(jk_msg_buf_t *msg,
 
410
                                 jk_context_t *c, jk_logger_t *l)
 
411
{
 
412
    char *vname;
 
413
    char *cname;
 
414
    char *uri;
 
415
 
 
416
    vname = (char *)jk_b_get_string(msg);
 
417
 
 
418
    JK_TRACE_ENTER(l);
 
419
    jk_log(l, JK_LOG_DEBUG,
 
420
           "get virtual %s for virtual %s",
 
421
           vname, c->virt);
 
422
 
 
423
    if (!vname) {
 
424
        jk_log(l, JK_LOG_ERROR,
 
425
               "can't get virtual hostname");
 
426
        JK_TRACE_EXIT(l);
 
427
        return JK_FALSE;
 
428
    }
 
429
 
 
430
    /* Check if we get the correct virtual host */
 
431
    if (c->virt != NULL && vname != NULL && strcmp(c->virt, vname)) {
 
432
        /* set the virtual name, better to add to a virtual list ? */
 
433
 
 
434
        if (context_set_virtual(c, vname) == JK_FALSE) {
 
435
            jk_log(l, JK_LOG_ERROR,
 
436
                   "can't malloc virtual hostname");
 
437
            JK_TRACE_EXIT(l);
 
438
            return JK_FALSE;
 
439
        }
 
440
    }
 
441
 
 
442
    for (;;) {
 
443
 
 
444
        cname = (char *)jk_b_get_string(msg);
 
445
 
 
446
        if (!cname) {
 
447
            jk_log(l, JK_LOG_ERROR,
 
448
                   "can't get context");
 
449
            JK_TRACE_EXIT(l);
 
450
            return JK_FALSE;
 
451
        }
 
452
 
 
453
        jk_log(l, JK_LOG_DEBUG,
 
454
               "get context %s for virtual %s",
 
455
               cname, vname);
 
456
 
 
457
        /* grab all contexts up to empty one which indicate end of contexts */
 
458
        if (!strlen(cname))
 
459
            break;
 
460
 
 
461
        /* create new context base (if needed) */
 
462
 
 
463
        if (context_add_base(c, cname) == JK_FALSE) {
 
464
            jk_log(l, JK_LOG_ERROR,
 
465
                   "can't add/set context %s",
 
466
                   cname);
 
467
            JK_TRACE_EXIT(l);
 
468
            return JK_FALSE;
 
469
        }
 
470
 
 
471
        for (;;) {
 
472
 
 
473
            uri = (char *)jk_b_get_string(msg);
 
474
 
 
475
            if (!uri) {
 
476
                jk_log(l, JK_LOG_ERROR,
 
477
                       "can't get URI");
 
478
                JK_TRACE_EXIT(l);
 
479
                return JK_FALSE;
 
480
            }
 
481
 
 
482
            if (!strlen(uri)) {
 
483
                jk_log(l, JK_LOG_DEBUG, "No more URI for context %s", cname);
 
484
                break;
 
485
            }
 
486
 
 
487
            jk_log(l, JK_LOG_INFO,
 
488
                   "Got URI (%s) for virtualhost %s and context %s", uri,
 
489
                   vname, cname);
 
490
 
 
491
            if (context_add_uri(c, cname, uri) == JK_FALSE) {
 
492
                jk_log(l, JK_LOG_ERROR,
 
493
                       "can't add/set uri (%s) for context %s",
 
494
                       uri, cname);
 
495
                JK_TRACE_EXIT(l);
 
496
                return JK_FALSE;
 
497
            }
 
498
        }
 
499
    }
 
500
 
 
501
    JK_TRACE_EXIT(l);
 
502
    return JK_TRUE;
 
503
}
 
504
 
 
505
 
 
506
/*
 
507
 * Build the Context State Query Cmd
 
508
 *
 
509
 * We send the list of contexts where we want to know state, empty string end context list*
 
510
 * If cname is set, only ask about THIS context
 
511
 *
 
512
 * +----------------------------+----------------------------------+----------------------------+----+
 
513
 * | CONTEXT STATE CMD (1 byte) |  VIRTUAL HOST NAME (CString (*)) | CONTEXT NAME (CString (*)) | .. |
 
514
 * +----------------------------+----------------------------------+----------------------------+----+
 
515
 *
 
516
 */
 
517
 
 
518
int ajp14_marshal_context_state_into_msgb(jk_msg_buf_t *msg,
 
519
                                          jk_context_t *c,
 
520
                                          char *cname, jk_logger_t *l)
 
521
{
 
522
    jk_context_item_t *ci;
 
523
    int i;
 
524
 
 
525
    JK_TRACE_ENTER(l);
 
526
 
 
527
    /* To be on the safe side */
 
528
    jk_b_reset(msg);
 
529
 
 
530
    /*
 
531
     * CONTEXT STATE CMD
 
532
     */
 
533
    if (jk_b_append_byte(msg, AJP14_CONTEXT_STATE_CMD)) {
 
534
        JK_TRACE_EXIT(l);
 
535
        return JK_FALSE;
 
536
    }
 
537
    /*
 
538
     * VIRTUAL HOST CSTRING
 
539
     */
 
540
    if (jk_b_append_string(msg, c->virt)) {
 
541
        jk_log(l, JK_LOG_ERROR,
 
542
               "failed appending the virtual host string");
 
543
        JK_TRACE_EXIT(l);
 
544
        return JK_FALSE;
 
545
    }
 
546
 
 
547
    if (cname) {
 
548
 
 
549
        ci = context_find_base(c, cname);
 
550
 
 
551
        if (!ci) {
 
552
            jk_log(l, JK_LOG_ERROR,
 
553
                   "unknown context %s",
 
554
                   cname);
 
555
            JK_TRACE_EXIT(l);
 
556
            return JK_FALSE;
 
557
        }
 
558
 
 
559
        /*
 
560
         * CONTEXT CSTRING
 
561
         */
 
562
 
 
563
        if (jk_b_append_string(msg, cname)) {
 
564
            jk_log(l, JK_LOG_ERROR,
 
565
                   "failed appending the context string %s",
 
566
                   cname);
 
567
            JK_TRACE_EXIT(l);
 
568
            return JK_FALSE;
 
569
        }
 
570
    }
 
571
    else {                      /* Grab all contexts name */
 
572
 
 
573
        for (i = 0; i < c->size; i++) {
 
574
 
 
575
            /*
 
576
             * CONTEXT CSTRING
 
577
             */
 
578
            if (jk_b_append_string(msg, c->contexts[i]->cbase)) {
 
579
                jk_log(l, JK_LOG_ERROR,
 
580
                       "failed appending the context string %s",
 
581
                       c->contexts[i]->cbase);
 
582
                JK_TRACE_EXIT(l);
 
583
                return JK_FALSE;
 
584
            }
 
585
        }
 
586
    }
 
587
 
 
588
    /* End of context list, an empty string */
 
589
 
 
590
    if (jk_b_append_string(msg, "")) {
 
591
        jk_log(l, JK_LOG_ERROR,
 
592
               "failed appending end of contexts");
 
593
        JK_TRACE_EXIT(l);
 
594
        return JK_FALSE;
 
595
    }
 
596
 
 
597
    JK_TRACE_EXIT(l);
 
598
    return JK_TRUE;
 
599
}
 
600
 
 
601
 
 
602
/*
 
603
 * Decode the Context State Reply Cmd
 
604
 *
 
605
 * We get update of contexts list, empty string end context list*
 
606
 *
 
607
 * +----------------------------------+---------------------------------+----------------------------+------------------+----+
 
608
 * | CONTEXT STATE REPLY CMD (1 byte) | VIRTUAL HOST NAME (CString (*)) | CONTEXT NAME (CString (*)) | UP/DOWN (1 byte) | .. |
 
609
 * +----------------------------------+---------------------------------+----------------------------+------------------+----+
 
610
 *
 
611
 */
 
612
 
 
613
int ajp14_unmarshal_context_state_reply(jk_msg_buf_t *msg,
 
614
                                        jk_context_t *c, jk_logger_t *l)
 
615
{
 
616
    char *vname;
 
617
    char *cname;
 
618
    jk_context_item_t *ci;
 
619
 
 
620
    JK_TRACE_ENTER(l);
 
621
    /* get virtual name */
 
622
    vname = (char *)jk_b_get_string(msg);
 
623
 
 
624
    if (!vname) {
 
625
        jk_log(l, JK_LOG_ERROR,
 
626
               "can't get virtual hostname");
 
627
        JK_TRACE_EXIT(l);
 
628
        return JK_FALSE;
 
629
    }
 
630
 
 
631
    /* Check if we speak about the correct virtual */
 
632
    if (strcmp(c->virt, vname)) {
 
633
        jk_log(l, JK_LOG_ERROR,
 
634
               "incorrect virtual %s instead of %s",
 
635
               vname, c->virt);
 
636
        JK_TRACE_EXIT(l);
 
637
        return JK_FALSE;
 
638
    }
 
639
 
 
640
    for (;;) {
 
641
 
 
642
        /* get context name */
 
643
        cname = (char *)jk_b_get_string(msg);
 
644
 
 
645
        if (!cname) {
 
646
            jk_log(l, JK_LOG_ERROR,
 
647
                   "can't get context");
 
648
            JK_TRACE_EXIT(l);
 
649
            return JK_FALSE;
 
650
        }
 
651
 
 
652
        if (!strlen(cname))
 
653
            break;
 
654
 
 
655
        ci = context_find_base(c, cname);
 
656
 
 
657
        if (!ci) {
 
658
            jk_log(l, JK_LOG_ERROR,
 
659
                   "unknow context %s for virtual %s",
 
660
                   cname, vname);
 
661
            JK_TRACE_EXIT(l);
 
662
            return JK_FALSE;
 
663
        }
 
664
 
 
665
        ci->status = jk_b_get_int(msg);
 
666
 
 
667
        if (JK_IS_DEBUG_LEVEL(l))
 
668
            jk_log(l, JK_LOG_DEBUG,
 
669
                   "updated context %s to state %d",
 
670
                   cname, ci->status);
 
671
    }
 
672
 
 
673
    JK_TRACE_EXIT(l);
 
674
    return JK_TRUE;
 
675
}
 
676
 
 
677
/*
 
678
 * Decode the Context Update Cmd
 
679
 * 
 
680
 * +-----------------------------+---------------------------------+----------------------------+------------------+
 
681
 * | CONTEXT UPDATE CMD (1 byte) | VIRTUAL HOST NAME (CString (*)) | CONTEXT NAME (CString (*)) | UP/DOWN (1 byte) |
 
682
 * +-----------------------------+---------------------------------+----------------------------+------------------+
 
683
 * 
 
684
 */
 
685
 
 
686
int ajp14_unmarshal_context_update_cmd(jk_msg_buf_t *msg,
 
687
                                       jk_context_t *c, jk_logger_t *l)
 
688
{
 
689
    int rc;
 
690
    JK_TRACE_ENTER(l);
 
691
    rc = ajp14_unmarshal_context_state_reply(msg, c, l);
 
692
    JK_TRACE_EXIT(l);
 
693
    return rc;
 
694
}