| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "httpd.h" |
| #include "http_core.h" |
| #include "http_log.h" |
| #include "util_fcgi.h" |
| |
| /* we know core's module_index is 0 */ |
| #undef APLOG_MODULE_INDEX |
| #define APLOG_MODULE_INDEX AP_CORE_MODULE_INDEX |
| |
| AP_DECLARE(void) ap_fcgi_header_to_array(ap_fcgi_header *h, |
| unsigned char a[]) |
| { |
| a[AP_FCGI_HDR_VERSION_OFFSET] = h->version; |
| a[AP_FCGI_HDR_TYPE_OFFSET] = h->type; |
| a[AP_FCGI_HDR_REQUEST_ID_B1_OFFSET] = h->requestIdB1; |
| a[AP_FCGI_HDR_REQUEST_ID_B0_OFFSET] = h->requestIdB0; |
| a[AP_FCGI_HDR_CONTENT_LEN_B1_OFFSET] = h->contentLengthB1; |
| a[AP_FCGI_HDR_CONTENT_LEN_B0_OFFSET] = h->contentLengthB0; |
| a[AP_FCGI_HDR_PADDING_LEN_OFFSET] = h->paddingLength; |
| a[AP_FCGI_HDR_RESERVED_OFFSET] = h->reserved; |
| } |
| |
| AP_DECLARE(void) ap_fcgi_header_from_array(ap_fcgi_header *h, |
| unsigned char a[]) |
| { |
| h->version = a[AP_FCGI_HDR_VERSION_OFFSET]; |
| h->type = a[AP_FCGI_HDR_TYPE_OFFSET]; |
| h->requestIdB1 = a[AP_FCGI_HDR_REQUEST_ID_B1_OFFSET]; |
| h->requestIdB0 = a[AP_FCGI_HDR_REQUEST_ID_B0_OFFSET]; |
| h->contentLengthB1 = a[AP_FCGI_HDR_CONTENT_LEN_B1_OFFSET]; |
| h->contentLengthB0 = a[AP_FCGI_HDR_CONTENT_LEN_B0_OFFSET]; |
| h->paddingLength = a[AP_FCGI_HDR_PADDING_LEN_OFFSET]; |
| h->reserved = a[AP_FCGI_HDR_RESERVED_OFFSET]; |
| } |
| |
| AP_DECLARE(void) ap_fcgi_header_fields_from_array(unsigned char *version, |
| unsigned char *type, |
| apr_uint16_t *request_id, |
| apr_uint16_t *content_len, |
| unsigned char *padding_len, |
| unsigned char a[]) |
| { |
| *version = a[AP_FCGI_HDR_VERSION_OFFSET]; |
| *type = a[AP_FCGI_HDR_TYPE_OFFSET]; |
| *request_id = (a[AP_FCGI_HDR_REQUEST_ID_B1_OFFSET] << 8) |
| + a[AP_FCGI_HDR_REQUEST_ID_B0_OFFSET]; |
| *content_len = (a[AP_FCGI_HDR_CONTENT_LEN_B1_OFFSET] << 8) |
| + a[AP_FCGI_HDR_CONTENT_LEN_B0_OFFSET]; |
| *padding_len = a[AP_FCGI_HDR_PADDING_LEN_OFFSET]; |
| } |
| |
| AP_DECLARE(void) ap_fcgi_begin_request_body_to_array(ap_fcgi_begin_request_body *h, |
| unsigned char a[]) |
| { |
| a[AP_FCGI_BRB_ROLEB1_OFFSET] = h->roleB1; |
| a[AP_FCGI_BRB_ROLEB0_OFFSET] = h->roleB0; |
| a[AP_FCGI_BRB_FLAGS_OFFSET] = h->flags; |
| a[AP_FCGI_BRB_RESERVED0_OFFSET] = h->reserved[0]; |
| a[AP_FCGI_BRB_RESERVED1_OFFSET] = h->reserved[1]; |
| a[AP_FCGI_BRB_RESERVED2_OFFSET] = h->reserved[2]; |
| a[AP_FCGI_BRB_RESERVED3_OFFSET] = h->reserved[3]; |
| a[AP_FCGI_BRB_RESERVED4_OFFSET] = h->reserved[4]; |
| } |
| |
| AP_DECLARE(void) ap_fcgi_fill_in_header(ap_fcgi_header *header, |
| unsigned char type, |
| apr_uint16_t request_id, |
| apr_uint16_t content_len, |
| unsigned char padding_len) |
| { |
| header->version = AP_FCGI_VERSION_1; |
| |
| header->type = type; |
| |
| header->requestIdB1 = ((request_id >> 8) & 0xff); |
| header->requestIdB0 = ((request_id) & 0xff); |
| |
| header->contentLengthB1 = ((content_len >> 8) & 0xff); |
| header->contentLengthB0 = ((content_len) & 0xff); |
| |
| header->paddingLength = padding_len; |
| |
| header->reserved = 0; |
| } |
| |
| AP_DECLARE(void) ap_fcgi_fill_in_request_body(ap_fcgi_begin_request_body *brb, |
| int role, |
| unsigned char flags) |
| { |
| brb->roleB1 = ((role >> 8) & 0xff); |
| brb->roleB0 = (role & 0xff); |
| brb->flags = flags; |
| brb->reserved[0] = 0; |
| brb->reserved[1] = 0; |
| brb->reserved[2] = 0; |
| brb->reserved[3] = 0; |
| brb->reserved[4] = 0; |
| } |
| |
| AP_DECLARE(apr_size_t) ap_fcgi_encoded_env_len(apr_table_t *env, |
| apr_size_t maxlen, |
| int *starting_elem) |
| { |
| const apr_array_header_t *envarr; |
| const apr_table_entry_t *elts; |
| apr_size_t envlen, actualenvlen; |
| int i; |
| |
| if (maxlen > AP_FCGI_MAX_CONTENT_LEN) { |
| maxlen = AP_FCGI_MAX_CONTENT_LEN; |
| } |
| |
| envarr = apr_table_elts(env); |
| elts = (const apr_table_entry_t *) envarr->elts; |
| |
| /* envlen - speculative, may overflow the limit |
| * actualenvlen - len required without overflowing |
| */ |
| envlen = actualenvlen = 0; |
| for (i = *starting_elem; i < envarr->nelts; ) { |
| apr_size_t keylen, vallen; |
| |
| if (!elts[i].key) { |
| (*starting_elem)++; |
| i++; |
| continue; |
| } |
| |
| keylen = strlen(elts[i].key); |
| |
| if (keylen >> 7 == 0) { |
| envlen += 1; |
| } |
| else { |
| envlen += 4; |
| } |
| |
| envlen += keylen; |
| |
| vallen = elts[i].val ? strlen(elts[i].val) : 0; |
| |
| if (vallen >> 7 == 0) { |
| envlen += 1; |
| } |
| else { |
| envlen += 4; |
| } |
| |
| envlen += vallen; |
| |
| if (envlen > maxlen) { |
| break; |
| } |
| |
| actualenvlen = envlen; |
| (*starting_elem)++; |
| i++; |
| } |
| |
| return actualenvlen; |
| } |
| |
| AP_DECLARE(apr_status_t) ap_fcgi_encode_env(request_rec *r, |
| apr_table_t *env, |
| void *buffer, |
| apr_size_t buflen, |
| int *starting_elem) |
| { |
| apr_status_t rv = APR_SUCCESS; |
| const apr_array_header_t *envarr; |
| const apr_table_entry_t *elts; |
| char *itr; |
| int i; |
| |
| envarr = apr_table_elts(env); |
| elts = (const apr_table_entry_t *) envarr->elts; |
| |
| itr = buffer; |
| |
| for (i = *starting_elem; i < envarr->nelts; ) { |
| apr_size_t keylen, vallen; |
| |
| if (!elts[i].key) { |
| (*starting_elem)++; |
| i++; |
| continue; |
| } |
| |
| keylen = strlen(elts[i].key); |
| |
| if (keylen >> 7 == 0) { |
| if (buflen < 1) { |
| rv = APR_ENOSPC; /* overflow */ |
| break; |
| } |
| itr[0] = keylen & 0xff; |
| itr += 1; |
| buflen -= 1; |
| } |
| else { |
| if (buflen < 4) { |
| rv = APR_ENOSPC; /* overflow */ |
| break; |
| } |
| itr[0] = ((keylen >> 24) & 0xff) | 0x80; |
| itr[1] = ((keylen >> 16) & 0xff); |
| itr[2] = ((keylen >> 8) & 0xff); |
| itr[3] = ((keylen) & 0xff); |
| itr += 4; |
| buflen -= 4; |
| } |
| |
| vallen = elts[i].val ? strlen(elts[i].val) : 0; |
| |
| if (vallen >> 7 == 0) { |
| if (buflen < 1) { |
| rv = APR_ENOSPC; /* overflow */ |
| break; |
| } |
| itr[0] = vallen & 0xff; |
| itr += 1; |
| buflen -= 1; |
| } |
| else { |
| if (buflen < 4) { |
| rv = APR_ENOSPC; /* overflow */ |
| break; |
| } |
| itr[0] = ((vallen >> 24) & 0xff) | 0x80; |
| itr[1] = ((vallen >> 16) & 0xff); |
| itr[2] = ((vallen >> 8) & 0xff); |
| itr[3] = ((vallen) & 0xff); |
| itr += 4; |
| buflen -= 4; |
| } |
| |
| if (buflen < keylen) { |
| rv = APR_ENOSPC; /* overflow */ |
| break; |
| } |
| memcpy(itr, elts[i].key, keylen); |
| itr += keylen; |
| buflen -= keylen; |
| |
| if (buflen < vallen) { |
| rv = APR_ENOSPC; /* overflow */ |
| break; |
| } |
| |
| if (elts[i].val) { |
| memcpy(itr, elts[i].val, vallen); |
| itr += vallen; |
| } |
| |
| if (buflen == vallen) { |
| (*starting_elem)++; |
| i++; |
| break; /* filled up predicted space, as expected */ |
| } |
| |
| buflen -= vallen; |
| |
| (*starting_elem)++; |
| i++; |
| } |
| |
| if (rv != APR_SUCCESS) { |
| ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(02492) |
| "ap_fcgi_encode_env: out of space " |
| "encoding environment"); |
| } |
| |
| return rv; |
| } |
