int php_http_match(const char *haystack_str, const char *needle_str, int flags)
{
int result = 0;
if (!haystack_str || !needle_str) {
return result;
}
if (flags & PHP_HTTP_MATCH_FULL) {
if (flags & PHP_HTTP_MATCH_CASE) {
result = !strcmp(haystack_str, needle_str);
} else {
result = !strcasecmp(haystack_str, needle_str);
}
} else {
const char *found;
char *haystack = estrdup(haystack_str), *needle = estrdup(needle_str);
if (flags & PHP_HTTP_MATCH_CASE) {
found = zend_memnstr(haystack, needle, strlen(needle), haystack+strlen(haystack));
} else {
found = php_stristr(haystack, needle, strlen(haystack), strlen(needle));
}
if (found) {
if (!(flags & PHP_HTTP_MATCH_WORD)
|| ( (found == haystack || !PHP_HTTP_IS_CTYPE(alnum, *(found - 1)))
&& (!*(found + strlen(needle)) || !PHP_HTTP_IS_CTYPE(alnum, *(found + strlen(needle))))
)
) {
result = 1;
}
}
PTR_FREE(haystack);
PTR_FREE(needle);
}
return result;
}
php_http_message_parser_state_t php_http_message_parser_parse(php_http_message_parser_t *parser, php_http_buffer_t *buffer, unsigned flags, php_http_message_t **message)
{
char *str = NULL;
size_t len = 0;
size_t cut = 0;
while (buffer->used || !php_http_message_parser_states[php_http_message_parser_state_is(parser)].need_data) {
#if DBG_PARSER
fprintf(stderr, "#MP: %s (f: %u, t:%d, l:%zu)\n",
php_http_message_parser_state_name(php_http_message_parser_state_is(parser)),
flags,
message && *message ? (*message)->type : -1,
buffer->used
);
_dpf(0, buffer->data, buffer->used);
#endif
switch (php_http_message_parser_state_pop(parser))
{
case PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE:
return php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE);
case PHP_HTTP_MESSAGE_PARSER_STATE_START:
{
char *ptr = buffer->data;
while (ptr - buffer->data < buffer->used && PHP_HTTP_IS_CTYPE(space, *ptr)) {
++ptr;
}
php_http_buffer_cut(buffer, 0, ptr - buffer->data);
if (buffer->used) {
php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER);
}
break;
}
case PHP_HTTP_MESSAGE_PARSER_STATE_HEADER:
{
unsigned header_parser_flags = (flags & PHP_HTTP_MESSAGE_PARSER_CLEANUP) ? PHP_HTTP_HEADER_PARSER_CLEANUP : 0;
switch (php_http_header_parser_parse(&parser->header, buffer, header_parser_flags, *message ? &(*message)->hdrs : NULL, (php_http_info_callback_t) php_http_message_info_callback, message)) {
case PHP_HTTP_HEADER_PARSER_STATE_FAILURE:
return PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE;
case PHP_HTTP_HEADER_PARSER_STATE_DONE:
php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE);
break;
default:
if (buffer->used || !(flags & PHP_HTTP_MESSAGE_PARSER_CLEANUP)) {
return php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER);
} else {
php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE);
}
}
break;
}
case PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE:
{
zval h, *h_ptr, *h_loc = NULL, *h_con = NULL, *h_ce;
zend_bool chunked = 0;
zend_long content_length = -1;
zend_string *content_range = NULL;
/* Content-Range has higher precedence than Content-Length,
* and content-length denotes the original length of the entity,
* so let's *NOT* remove CR/CL, because that would fundamentally
* change the meaning of the whole message
*/
if ((h_ptr = php_http_message_header(*message, ZEND_STRL("Transfer-Encoding")))) {
zend_string *zs = zval_get_string(h_ptr);
chunked = zend_string_equals_literal(zs, "chunked");
zend_string_release(zs);
Z_TRY_ADDREF_P(h_ptr);
zend_hash_str_update(&(*message)->hdrs, "X-Original-Transfer-Encoding", lenof("X-Original-Transfer-Encoding"), h_ptr);
zend_hash_str_del(&(*message)->hdrs, "Transfer-Encoding", lenof("Transfer-Encoding"));
/* reset */
ZVAL_LONG(&h, 0);
zend_hash_str_update(&(*message)->hdrs, "Content-Length", lenof("Content-Length"), &h);
} else if ((h_ptr = php_http_message_header(*message, ZEND_STRL("Content-Length")))) {
content_length = zval_get_long(h_ptr);
Z_TRY_ADDREF_P(h_ptr);
zend_hash_str_update(&(*message)->hdrs, "X-Original-Content-Length", lenof("X-Original-Content-Length"), h_ptr);
}
if ((content_range = php_http_message_header_string(*message, ZEND_STRL("Content-Range")))) {
ZVAL_STR_COPY(&h, content_range);
zend_hash_str_update(&(*message)->hdrs, "Content-Range", lenof("Content-Range"), &h);
}
/* so, if curl sees a 3xx code, a Location header and a Connection:close header
* it decides not to read the response body.
*/
if ((flags & PHP_HTTP_MESSAGE_PARSER_EMPTY_REDIRECTS)
&& (*message)->type == PHP_HTTP_RESPONSE
&& (*message)->http.info.response.code/100 == 3
&& (h_loc = php_http_message_header(*message, ZEND_STRL("Location")))
&& (h_con = php_http_message_header(*message, ZEND_STRL("Connection")))
) {
zend_string *con = zval_get_string(h_con);
if (php_http_match(con->val, "close", PHP_HTTP_MATCH_WORD)) {
zend_string_release(con);
php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_DONE);
break;
}
zend_string_release(con);
}
if ((h_ce = php_http_message_header(*message, ZEND_STRL("Content-Encoding")))) {
zend_string *ce = zval_get_string(h_ce);
if (php_http_match(ce->val, "gzip", PHP_HTTP_MATCH_WORD)
|| php_http_match(ce->val, "x-gzip", PHP_HTTP_MATCH_WORD)
|| php_http_match(ce->val, "deflate", PHP_HTTP_MATCH_WORD)
) {
if (parser->inflate) {
php_http_encoding_stream_reset(&parser->inflate);
} else {
parser->inflate = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_inflate_ops(), 0);
}
Z_TRY_ADDREF_P(h_ce);
zend_hash_str_update(&(*message)->hdrs, "X-Original-Content-Encoding", lenof("X-Original-Content-Encoding"), h_ce);
zend_hash_str_del(&(*message)->hdrs, "Content-Encoding", lenof("Content-Encoding"));
}
zend_string_release(ce);
}
if ((flags & PHP_HTTP_MESSAGE_PARSER_DUMB_BODIES)) {
php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB);
} else {
if (chunked) {
parser->dechunk = php_http_encoding_stream_init(parser->dechunk, php_http_encoding_stream_get_dechunk_ops(), 0);
php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED);
break;
}
if (content_range) {
ulong total = 0, start = 0, end = 0;
if (!strncasecmp(content_range->val, "bytes", lenof("bytes"))
&& ( content_range->val[lenof("bytes")] == ':'
|| content_range->val[lenof("bytes")] == ' '
|| content_range->val[lenof("bytes")] == '='
)
) {
char *total_at = NULL, *end_at = NULL;
char *start_at = content_range->val + sizeof("bytes");
start = strtoul(start_at, &end_at, 10);
if (end_at) {
end = strtoul(end_at + 1, &total_at, 10);
if (total_at && strncmp(total_at + 1, "*", 1)) {
total = strtoul(total_at + 1, NULL, 10);
}
if (end >= start && (!total || end <= total)) {
parser->body_length = end + 1 - start;
php_http_message_parser_state_push(parser, 1, !parser->body_length?PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH);
zend_string_release(content_range);
break;
}
}
}
zend_string_release(content_range);
}
if (content_length >= 0) {
parser->body_length = content_length;
php_http_message_parser_state_push(parser, 1, !parser->body_length?PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH);
break;
}
if ((*message)->type == PHP_HTTP_REQUEST) {
php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_DONE);
} else {
php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB);
}
}
break;
}
case PHP_HTTP_MESSAGE_PARSER_STATE_BODY:
{
if (len) {
if (parser->inflate) {
char *dec_str = NULL;
size_t dec_len;
if (SUCCESS != php_http_encoding_stream_update(parser->inflate, str, len, &dec_str, &dec_len)) {
return php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE);
}
if (str != buffer->data) {
PTR_FREE(str);
}
str = dec_str;
len = dec_len;
}
php_stream_write(php_http_message_body_stream((*message)->body), str, len);
}
if (cut) {
php_http_buffer_cut(buffer, 0, cut);
}
if (str != buffer->data) {
PTR_FREE(str);
}
str = NULL;
len = 0;
cut = 0;
break;
}
case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB:
{
str = buffer->data;
len = buffer->used;
cut = len;
php_http_message_parser_state_push(parser, 2, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE, PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
break;
}
case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH:
{
len = MIN(parser->body_length, buffer->used);
str = buffer->data;
cut = len;
parser->body_length -= len;
php_http_message_parser_state_push(parser, 2, !parser->body_length?PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH, PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
break;
}
case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED:
{
/*
* - pass available data through the dechunk stream
* - pass decoded data along
* - if stream zeroed:
* Y: - cut processed string out of buffer, but leave length of unprocessed dechunk stream data untouched
* - body done
* N: - parse ahaed
*/
char *dec_str = NULL;
size_t dec_len;
if (SUCCESS != php_http_encoding_stream_update(parser->dechunk, buffer->data, buffer->used, &dec_str, &dec_len)) {
return PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE;
}
str = dec_str;
len = dec_len;
if (php_http_encoding_stream_done(parser->dechunk)) {
cut = buffer->used - PHP_HTTP_BUFFER(parser->dechunk->ctx)->used;
php_http_message_parser_state_push(parser, 2, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE, PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
} else {
cut = buffer->used;
php_http_message_parser_state_push(parser, 2, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED, PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
}
break;
}
case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:
{
php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_DONE);
if (parser->dechunk && parser->dechunk->ctx) {
char *dec_str = NULL;
size_t dec_len;
if (SUCCESS != php_http_encoding_stream_finish(parser->dechunk, &dec_str, &dec_len)) {
return php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE);
}
php_http_encoding_stream_dtor(parser->dechunk);
if (dec_str && dec_len) {
str = dec_str;
len = dec_len;
cut = 0;
php_http_message_parser_state_push(parser, 2, PHP_HTTP_MESSAGE_PARSER_STATE_UPDATE_CL, PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
}
}
break;
}
case PHP_HTTP_MESSAGE_PARSER_STATE_UPDATE_CL:
{
zval zcl;
ZVAL_LONG(&zcl, php_http_message_body_size((*message)->body));
zend_hash_str_update(&(*message)->hdrs, "Content-Length", lenof("Content-Length"), &zcl);
break;
}
case PHP_HTTP_MESSAGE_PARSER_STATE_DONE:
{
char *ptr = buffer->data;
while (ptr - buffer->data < buffer->used && PHP_HTTP_IS_CTYPE(space, *ptr)) {
++ptr;
}
php_http_buffer_cut(buffer, 0, ptr - buffer->data);
if (!(flags & PHP_HTTP_MESSAGE_PARSER_GREEDY)) {
return PHP_HTTP_MESSAGE_PARSER_STATE_DONE;
}
break;
}
}
}
return php_http_message_parser_state_is(parser);
}
/* O I M G
* 1 1 1 1 - not used
* 1 1 A ! - forbidden
* 1 A 1 ! - forbidden
* A 1 1 ! - forbidden
* A A 1 1 - replicated
* A 1 A 1 - output
* 1 A A A/A - input
* A A A A - batch
*/
static struct operator_matrix_s* linop_matrix_priv2(unsigned int N, const long out_dims[N], const long in_dims[N], const long matrix_dims[N], const complex float* matrix)
{
// to get assertions and cost estimate
long max_dims[N];
md_tenmul_dims(N, max_dims, out_dims, in_dims, matrix_dims);
PTR_ALLOC(struct operator_matrix_s, data);
SET_TYPEID(operator_matrix_s, data);
data->N = N;
PTR_ALLOC(long[N], out_dims1);
md_copy_dims(N, *out_dims1, out_dims);
data->out_dims = *PTR_PASS(out_dims1);
PTR_ALLOC(long[N], mat_dims1);
md_copy_dims(N, *mat_dims1, matrix_dims);
data->mat_dims = *PTR_PASS(mat_dims1);
PTR_ALLOC(long[N], in_dims1);
md_copy_dims(N, *in_dims1, in_dims);
data->in_dims = *PTR_PASS(in_dims1);
complex float* mat = md_alloc(N, matrix_dims, CFL_SIZE);
md_copy(N, matrix_dims, mat, matrix, CFL_SIZE);
data->mat = mat;
data->mat_gram = NULL;
#ifdef USE_CUDA
data->mat_gpu = NULL;
data->mat_gram_gpu = NULL;
#endif
#if 1
// pre-multiply gram matrix (if there is a cost reduction)
unsigned long out_flags = md_nontriv_dims(N, out_dims);
unsigned long in_flags = md_nontriv_dims(N, in_dims);
unsigned long del_flags = in_flags & ~out_flags;
unsigned long new_flags = out_flags & ~in_flags;
/* we double (again) for the gram matrix
*/
PTR_ALLOC(long[2 * N], mat_dims2);
PTR_ALLOC(long[2 * N], in_dims2);
PTR_ALLOC(long[2 * N], gmt_dims2);
PTR_ALLOC(long[2 * N], gin_dims2);
PTR_ALLOC(long[2 * N], grm_dims2);
PTR_ALLOC(long[2 * N], gout_dims2);
shadow_dims(N, *gmt_dims2, matrix_dims);
shadow_dims(N, *mat_dims2, matrix_dims);
shadow_dims(N, *in_dims2, in_dims);
shadow_dims(N, *gout_dims2, in_dims);
shadow_dims(N, *gin_dims2, in_dims);
shadow_dims(N, *grm_dims2, matrix_dims);
/* move removed input dims into shadow position
* for the gram matrix can have an output there
*/
for (unsigned int i = 0; i < N; i++) {
if (MD_IS_SET(del_flags, i)) {
assert((*mat_dims2)[2 * i + 0] == (*in_dims2)[2 * i + 0]);
(*mat_dims2)[2 * i + 1] = (*mat_dims2)[2 * i + 0];
(*mat_dims2)[2 * i + 0] = 1;
(*in_dims2)[2 * i + 1] = (*gin_dims2)[2 * i + 0];
(*in_dims2)[2 * i + 0] = 1;
}
}
for (unsigned int i = 0; i < N; i++) {
if (MD_IS_SET(new_flags, i)) {
(*grm_dims2)[2 * i + 0] = 1;
(*grm_dims2)[2 * i + 1] = 1;
}
if (MD_IS_SET(del_flags, i)) {
(*gout_dims2)[2 * i + 1] = (*gin_dims2)[2 * i + 0];
(*gout_dims2)[2 * i + 0] = 1;
(*grm_dims2)[2 * i + 0] = in_dims[i];
(*grm_dims2)[2 * i + 1] = in_dims[i];
}
}
long gmx_dims[2 * N];
md_tenmul_dims(2 * N, gmx_dims, *gout_dims2, *gin_dims2, *grm_dims2);
long mult_mat = md_calc_size(N, max_dims);
long mult_gram = md_calc_size(2 * N, gmx_dims);
if (mult_gram < 2 * mult_mat) { // FIXME: rethink
debug_printf(DP_DEBUG2, "Gram matrix: 2x %ld vs %ld\n", mult_mat, mult_gram);
complex float* mat_gram = md_alloc(2 * N, *grm_dims2, CFL_SIZE);
md_ztenmulc(2 * N, *grm_dims2, mat_gram, *gmt_dims2, matrix, *mat_dims2, matrix);
data->mat_gram = mat_gram;
}
PTR_FREE(gmt_dims2);
PTR_FREE(mat_dims2);
PTR_FREE(in_dims2);
data->gin_dims = *PTR_PASS(gin_dims2);
data->gout_dims = *PTR_PASS(gout_dims2);
data->grm_dims = *PTR_PASS(grm_dims2);
#else
data->gin_dims = NULL;
data->gout_dims = NULL;
data->grm_dims = NULL;
#endif
return PTR_PASS(data);
}
