static void image_ttf_face_names(INT32 args)
{
int n,i;
int has[8]={0,0,0,0,0,0,0,0}; /* iso8859=20, unicode=30, any=1 */
char *hasname[8]={"copyright","family","style","full",
"expose","version","postscript","trademark"};
struct array *a,*b;
image_ttf_face__names(args);
if (sp[-1].type!=T_ARRAY)
Pike_error("Image.TTF.Face->names(): internal error, weird _names()\n");
a=sp[-1].u.array;
n=0;
for (i=0; i<a->size; i++)
{
int ihas=1;
int what;
b=a->item[i].u.array;
what=b->item[3].u.integer;
if (what>=8 || what<0) continue; /* weird */
switch (b->item[0].u.integer*100+b->item[1].u.integer)
{
case 301: /* M$: unicode */
case 300: /* M$: unicode (?) */
ihas=30;
break;
case 202: /* ISO: iso-8859-1 */
ihas=20;
break;
}
if (ihas<has[what]) continue; /* worse */
push_text(hasname[what]);
if (ihas==30) /* unicode, M$ but weird enough correct byteorder */
{
ptrdiff_t n = b->item[4].u.string->len/2;
struct pike_string *ps=begin_wide_shared_string(n,1);
p_wchar1 *d=STR1(ps);
p_wchar0 *s=STR0(b->item[4].u.string);
while (n--) *(d++)=((p_wchar1)s[0]<<8)|(p_wchar1)s[1],s+=2;
push_string(end_shared_string(ps));
}
else
push_svalue(b->item+4);
n++;
}
f_aggregate_mapping(n*2);
stack_swap();
pop_stack();
}
/*
**! method: string digest()
**! Get the result of the hashing operation.
**! name: digest, hexdigest - Return the resulting hash
**! see_also: Mhash.to_hex
**! returns:
**! The resulting digest.
*/
void f_hash_digest(INT32 args)
{
int len, i;
struct pike_string *res;
len = get_digest();
res = begin_shared_string(len);
for(i = 0; i < len; i++) {
STR0(res)[i] = THIS->res[i];
}
res = end_shared_string(res);
pop_n_elems(args);
push_string(res);
}
/* php_caudium_set_header() sets a header in the header mapping. Called in a
* thread safe manner from php_caudium_sapi_header_handler.
*/
INLINE static void
php_caudium_set_header(char *header_name, char *value, char *p)
{
struct svalue hsval;
struct pike_string *hval, *ind, *hind;
struct mapping *headermap;
struct svalue *s_headermap, *soldval;
int vallen;
GET_THIS();
/* hval = make_shared_string(value); */
ind = make_shared_string(" _headers");
hind = make_shared_binary_string(header_name,
(int)(p - header_name));
s_headermap = low_mapping_string_lookup(REQUEST_DATA, ind);
if(!s_headermap || s_headermap->type != PIKE_T_MAPPING)
{
struct svalue mappie;
mappie.type = PIKE_T_MAPPING;
headermap = allocate_mapping(1);
mappie.u.mapping = headermap;
mapping_string_insert(REQUEST_DATA, ind, &mappie);
free_mapping(headermap);
hval = make_shared_string(value);
} else {
headermap = s_headermap->u.mapping;
soldval = low_mapping_string_lookup(headermap, hind);
vallen = strlen(value);
if(soldval != NULL &&
soldval->type == PIKE_T_STRING &&
soldval->u.string->size_shift == 0) {
/* Existing, valid header. Prepend.*/
hval = begin_shared_string(soldval->u.string->len + 1 + vallen);
MEMCPY(hval->str, soldval->u.string->str, soldval->u.string->len);
STR0(hval)[soldval->u.string->len] = '\0';
MEMCPY(hval->str+soldval->u.string->len+1, value, vallen);
hval = end_shared_string(hval);
} else {
hval = make_shared_string(value);
}
}
hsval.type = PIKE_T_STRING;
hsval.u.string = hval;
mapping_string_insert(headermap, hind, &hsval);
free_string(hval);
free_string(ind);
free_string(hind);
}
static void f_buf_append( INT32 args )
{
struct pike_string *str;
struct svalue skey, sval; /* header, value */
int slash_n = 0, cnt, num;
unsigned char *pp,*ep;
struct svalue *tmp;
int os=0, i, j=0, l, qmark = -1;
unsigned char *in, *query;
if( Pike_sp[-1].type != T_STRING )
Pike_error("Wrong type of argument to append()\n");
str = Pike_sp[-1].u.string;
if( str->len >= BUF->free ) {
pop_n_elems(args);
push_int(413); /* Request Entity Too Large */
return;
}
MEMCPY( BUF->pos, str->str, str->len );
for( ep = (BUF->pos + str->len), pp = MAX(BUF->data, BUF->pos-3);
pp < ep && slash_n < 2; pp++ )
if( *pp == '\n' ) slash_n++;
else if( *pp != '\r' ) slash_n=0;
BUF->free -= str->len;
BUF->pos += str->len;
BUF->pos[0] = 0;
pop_n_elems( args );
if( slash_n != 2 )
{
/* need more data */
push_int( 0 );
return;
}
skey.type = sval.type = T_STRING;
sval.u.string = make_shared_binary_string( (char *)pp, BUF->pos - pp);
mapping_insert(BUF->other, SVAL(data), &sval); /* data */
free_string(sval.u.string);
in = BUF->data;
l = pp - BUF->data;
/* find method */
for( i = 0; i < l; i++ ) {
if( in[i] == ' ' )
break;
else if(in[i] == '\n') {
push_int( 400 ); /* Bad Request */
return;
}
}
sval.u.string = make_shared_binary_string((char *)in, i);
mapping_insert(BUF->other, SVAL(method), &sval);
free_string(sval.u.string);
i++; in += i; l -= i;
/* find file */
for( i = 0; i < l; i++ ) {
if(in[i] == ' ') {
break;
} else if(in[i] == '\n') {
push_int( 400 ); /* Bad Request */
return;
}
}
sval.u.string = make_shared_binary_string((char *)in, i);
mapping_insert(BUF->other, SVAL(raw_url), &sval);
free_string(sval.u.string);
/* Decode file part and return pointer to query, if any */
query = char_decode_url(in, i);
/* Decoded, query-less file up to the first \0 */
sval.u.string = make_shared_string((char *)in);
mapping_insert(BUF->other, SVAL(file), &sval);
free_string(sval.u.string);
if(query != NULL) {
/* Store the query string */
sval.u.string = make_shared_binary_string((char *)query, i - (query-in)); /* Also up to first null */
mapping_insert(BUF->other, SVAL(query), &sval);
free_string(sval.u.string);
}
i++; in += i; l -= i;
/* find protocol */
for( i = 0; i < l; i++ ) {
if( in[i] == '\n' ) break;
else if(in[i] == ' ') {
push_int( 400 ); /* Bad Request */
return;
}
}
if( in[i-1] != '\r' )
i++;
sval.u.string = make_shared_binary_string((char *)in, i-1);
mapping_insert(BUF->other, SVAL(protocol), &sval);
free_string(sval.u.string);
in += i; l -= i;
if( *in == '\n' ) (in++),(l--);
for(i = 0; i < l; i++)
{
if(in[i] >= 'A' && in[i] <= 'Z') in[i] |= 32; /* Lowercasing the header */
else if( in[i] == ':' )
{
/* in[os..i-1] == the header */
skey.u.string = make_shared_binary_string((char*)in+os, i - os);
os = i+1;
while(in[os]==' ') os++; /* Remove initial spaces */
for(j=os;j<l;j++) if( in[j] == '\n' || in[j]=='\r') break;
if((tmp = low_mapping_lookup(BUF->headers, &skey)) &&
tmp->type == T_STRING)
{
int len = j - os + 1;
int len2 = len +tmp->u.string->len;
sval.u.string = begin_shared_string(len2);
MEMCPY(sval.u.string->str,
tmp->u.string->str, tmp->u.string->len);
sval.u.string->str[tmp->u.string->len] = ',';
MEMCPY(sval.u.string->str + tmp->u.string->len + 1,
(char*)in + os, len);
sval.u.string = end_shared_string(sval.u.string);
} else {
sval.u.string = make_shared_binary_string((char*)in + os, j - os);
}
mapping_insert(BUF->headers, &skey, &sval);
if( in[j+1] == '\n' ) j++;
os = j+1;
i = j;
free_string(sval.u.string);
free_string(skey.u.string);
}
}
push_int(1);
}
newstr = make_shared_binary_string((char *)mystr, nlen+exist);
#ifndef HAVE_ALLOCA
free(mystr);
#endif
return newstr;
}
#if 0
/* Code to add a string to a string */
value = begin_shared_string(count2 - data + exist->u.string->len+1);
MEMCPY(value->str, exist->u.string->str, exist->u.string->len+1);
MEMCPY(value->str + exist->u.string->len + 1,
heads + data, count2 - data + 1);
value->str[count2 - data + 1 + exist->u.string->len] = '\0';
value = end_shared_string(value);
sval.u.string = value;
mapping_insert(headermap, &skey, &sval);
#endif
static int get_next_header(unsigned char *heads, int len,
struct mapping *headermap)
{
int data, count, colon, count2=0;
struct svalue skey, sval;
skey.type = T_STRING;
sval.type = T_STRING;
for(count=0, colon=0; count < len; count++) {
switch(heads[count]) {
*! __REAL_MINOR__, __REAL_BUILD__);
*! @endcode
*!
*! @seealso
*! @[__VERSION__], @[__MINOR__], @[__BUILD__],
*! @[__REAL_VERSION__], @[__REAL_MINOR__], @[__REAL_BUILD__],
*/
PMOD_EXPORT void f_version(INT32 args)
{
pop_n_elems(args);
push_static_text ("Pike v"
DEFINETOSTR (PIKE_MAJOR_VERSION)
"."
DEFINETOSTR (PIKE_MINOR_VERSION)
" release "
DEFINETOSTR (PIKE_BUILD_VERSION));
}
void push_compact_version(void)
{
push_constant_string_code (str, {
p_wchar2 *wstr;
str = begin_wide_shared_string (3, 2);
wstr = STR2(str);
wstr[0] = PIKE_MAJOR_VERSION;
wstr[1] = PIKE_MINOR_VERSION;
wstr[2] = PIKE_BUILD_VERSION;
str = end_shared_string (str);
});
}
/* This function reads some data from the file cache..
* Called when we want some data to send.
*/
static INLINE struct pike_string* gimme_some_data(size_t pos)
{
struct buffer *b;
ptrdiff_t len;
struct pipe *this = THIS;
/* We have a file cache, read from it */
if (this->fd!=-1)
{
char buffer[READ_BUFFER_SIZE];
if (this->pos<=pos) return NULL; /* no data */
len=this->pos-pos;
if (len>READ_BUFFER_SIZE) len=READ_BUFFER_SIZE;
THREADS_ALLOW();
fd_lseek(this->fd, pos, SEEK_SET);
THREADS_DISALLOW();
do {
THREADS_ALLOW();
len = fd_read(this->fd, buffer, len);
THREADS_DISALLOW();
if (len < 0) {
if (errno != EINTR) {
return(NULL);
}
check_threads_etc();
}
} while(len < 0);
/*
* FIXME: What if len is 0?
*/
return make_shared_binary_string(buffer,len);
}
if (pos<this->pos)
return make_shared_string("buffer underflow"); /* shit */
/* We want something in the next buffer */
while (this->firstbuffer && pos>=this->pos+this->firstbuffer->s->len)
{
/* Free the first buffer, and update THIS->pos */
b=this->firstbuffer;
this->pos+=b->s->len;
this->bytes_in_buffer-=b->s->len;
this->firstbuffer=b->next;
if (!b->next)
this->lastbuffer=NULL;
sbuffers-=b->s->len;
nbuffers--;
free_string(b->s);
free((char *)b);
/* Wake up first input if it was sleeping and we
* have room for more in the buffer.
*/
if (this->sleeping &&
this->firstinput &&
this->bytes_in_buffer<MAX_BYTES_IN_BUFFER)
{
if (this->firstinput->type == I_BLOCKING_OBJ) {
if (!read_some_data()) {
this->sleeping = 0;
input_finish();
}
} else {
this->sleeping=0;
push_callback(offset_input_read_callback);
push_int(0);
push_callback(offset_input_close_callback);
apply(this->firstinput->u.obj, "set_nonblocking", 3);
pop_stack();
}
}
}
while (!this->firstbuffer)
{
if (this->firstinput)
{
#if defined(HAVE_MMAP) && defined(HAVE_MUNMAP)
if (this->firstinput->type==I_MMAP)
{
char *src;
struct pike_string *tmp;
if (pos >= this->firstinput->len + this->pos) /* end of mmap */
{
this->pos += this->firstinput->len;
input_finish();
continue;
}
len = this->firstinput->len + this->pos - pos;
if (len > READ_BUFFER_SIZE) len=READ_BUFFER_SIZE;
tmp = begin_shared_string( len );
src = this->firstinput->u.mmap + pos - this->pos;
/* This thread_allow/deny is at the cost of one extra memory copy */
THREADS_ALLOW();
MEMCPY(tmp->str, src, len);
THREADS_DISALLOW();
return end_shared_string(tmp);
}
else
#endif
if (this->firstinput->type!=I_OBJ)
{
/* FIXME: What about I_BLOCKING_OBJ? */
input_finish(); /* shouldn't be anything else ... maybe a finished object */
}
}
return NULL; /* no data */
}
if (pos==this->pos)
{
add_ref(this->firstbuffer->s);
return this->firstbuffer->s;
}
return make_shared_binary_string(this->firstbuffer->s->str+
pos-this->pos,
this->firstbuffer->s->len-
pos+this->pos);
}