/* Set the input file (file object, (max) bytes to read ) */
static void f_input(INT32 args) {
NBIO_INT_T len = -1;
switch(args) {
case 2:
if(ARG(2).type != T_INT) {
SIMPLE_BAD_ARG_ERROR("_Caudium.nbio()->input", 2, "integer");
} else {
len = ARG(2).u.integer;
}
/* FALL THROUGH */
case 1:
if(ARG(1).type != T_OBJECT) {
SIMPLE_BAD_ARG_ERROR("_Caudium.nbio()->input", 1, "object");
} else {
/* Allocate a new input object and add it to our linked list */
new_input(ARG(1), len, 0);
}
break;
case 0:
SIMPLE_TOO_FEW_ARGS_ERROR("_Caudium.nbio()->input", 1);
break;
}
pop_n_elems(args-1);
}
static void f_crypt_md5(INT32 args)
{
char salt[8];
char *ret, *saltp ="";
char *choice =
"cbhisjKlm4k65p7qrJfLMNQOPxwzyAaBDFgnoWXYCZ0123tvdHueEGISRTUV89./";
if (args < 1)
SIMPLE_TOO_FEW_ARGS_ERROR("crypt_md5", 1);
if (Pike_sp[-args].type != T_STRING)
SIMPLE_BAD_ARG_ERROR("crypt_md5", 1, "string");
if (args > 1)
{
if (Pike_sp[1-args].type != T_STRING)
SIMPLE_BAD_ARG_ERROR("crypt_md5", 2, "string");
saltp = Pike_sp[1-args].u.string->str;
} else {
unsigned int i, r;
for (i = 0; i < sizeof(salt); i++)
{
r = my_rand();
salt[i] = choice[r % (size_t) strlen(choice)];
}
saltp = salt;
}
ret = (char *)crypt_md5(Pike_sp[-args].u.string->str, saltp);
pop_n_elems(args);
push_string(make_shared_string(ret));
}
/*! @decl int match(string str)
*!
*! Returns 1 if @[str] matches the regexp bound to the regexp object.
*! Zero otherwise.
*!
*! @decl array(string) match(array(string) strs)
*!
*! Returns an array containing strings in @[strs] that match the
*! regexp bound to the regexp object.
*!
*! @bugs
*! The current implementation doesn't support searching
*! in strings containing the NUL character or any
*! wide character.
*!
*! @seealso
*! @[split]
*/
static void regexp_match(INT32 args)
{
int i;
struct regexp *regexp = THIS->regexp;
if(args < 1)
SIMPLE_TOO_FEW_ARGS_ERROR("Regexp.SimpleRegexp->match", 1);
if(Pike_sp[-args].type == T_STRING)
{
if(Pike_sp[-args].u.string->size_shift)
SIMPLE_BAD_ARG_ERROR("Regexp.SimpleRegexp->match", 1,
"Expected string (8bit)");
i = pike_regexec(regexp, (char *)STR0(Pike_sp[-args].u.string));
pop_n_elems(args);
push_int(i);
return;
}
else if(Pike_sp[-args].type == T_ARRAY)
{
struct array *arr;
int i, n;
arr = Pike_sp[-args].u.array;
for(i = n = 0; i < arr->size; i++)
{
struct svalue *sv = ITEM(arr) + i;
if(sv->type != T_STRING || sv->u.string->size_shift)
SIMPLE_BAD_ARG_ERROR("Regexp.SimpleRegexp->match", 1,
"Expected string (8bit)");
if(pike_regexec(regexp, (char *)STR0(sv->u.string)))
{
ref_push_string(sv->u.string);
n++;
}
}
f_aggregate(n);
stack_pop_n_elems_keep_top(args);
return;
}
else
SIMPLE_BAD_ARG_ERROR("Regexp.SimpleRegexp->match", 1,
"string|array(string)");
}
static void f_extension( INT32 args ) {
int i, found=0;
struct pike_string *src;
char *orig, *ptr;
if(Pike_sp[-1].type != T_STRING)
SIMPLE_BAD_ARG_ERROR("Caudium.extension", 1, "string");
src = Pike_sp[-1].u.string;
if(src->size_shift) {
Pike_error("Caudium.extension(): Only 8-bit strings allowed.\n");
}
orig = src->str;
for(i = src->len-1; i >= 0; i--) {
if(orig[i] == 0x2E) {
found = 1;
i++;
break;
}
}
if(found) {
int len = src->len - i;
switch(orig[src->len-1]) {
case '#': case '~':
/* Remove unix backup extension */
len--;
}
pop_n_elems(args);
push_string(make_shared_binary_string(orig+i, len));
} else {
pop_n_elems(args);
push_text("");
}
}
/* Set the done callback */
static void f_set_done_callback(INT32 args)
{
switch(args) {
case 2:
assign_svalue(&(THIS->args), &ARG(2));
case 1:
if (Pike_sp[-args].type != T_FUNCTION)
SIMPLE_BAD_ARG_ERROR("_Caudium.nbio()->set_done_callback", 1, "function");
assign_svalue(&(THIS->cb), &Pike_sp[-args]);
break;
case 0:
free_svalue(&THIS->cb);
free_svalue(&THIS->args);
THIS->cb.type=T_INT;
THIS->args.type=T_INT;
THIS->args.u.integer = 0;
return;
default:
Pike_error("_Caudium.nbio()->set_done_callback: Too many arguments.\n");
break;
}
pop_n_elems(args - 1);
}
/* Set the output data (string) */
static void f_write(INT32 args) {
if(args) {
if(ARG(1).type != T_STRING) {
SIMPLE_BAD_ARG_ERROR("_Caudium.nbio()->write", 1, "string");
} else {
int len = ARG(1).u.string->len << ARG(1).u.string->size_shift;
if(len > 0)
new_input(ARG(1), len, 0);
}
} else {
SIMPLE_TOO_FEW_ARGS_ERROR("_Caudium.nbio()->write", 1);
}
pop_n_elems(args-1);
}
/* Our nb input read callback */
static void f__input_read_cb(INT32 args)
{
int avail_size = 0, len;
struct pike_string *str;
input *inp = THIS->inputs;
if(inp == NULL) {
Pike_error("Input read callback without inputs.");
}
if(args != 2)
Pike_error("Invalid number of arguments to read callback.");
if(ARG(2).type != T_STRING) {
SIMPLE_BAD_ARG_ERROR("_Caudium.nbio()->_input_read_cb", 2, "string");
}
str = ARG(2).u.string;
len = str->len << str->size_shift;
inp->pos += len;
if(inp->len != -1 && inp->pos >= inp->len) {
len -= inp->pos - inp->len; /* Don't "read" too much */
DERR(fprintf(stderr, "Read all wanted input data.\n"));
free_input(inp);
}
DERR(fprintf(stderr, "Input read callback (got %d bytes).\n", len));
if(THIS->buf_size) {
avail_size = THIS->buf_size - (THIS->buf_len + THIS->buf_pos);
}
if(avail_size < len) {
alloc_data_buf(THIS->buf_size + (len - avail_size));
}
DERR(fprintf(stderr, "Copying %d bytes to buf starting at 0x%x (pos %d).\n",
len, (int)(THIS->buf + THIS->buf_pos + THIS->buf_len), THIS->buf_pos + THIS->buf_len));
memcpy(THIS->buf + THIS->buf_pos + THIS->buf_len, str->str, len);
THIS->buf_len += len;
if((THIS->buf_len + THIS->buf_pos) > READ_BUFFER_SIZE) {
DERR(fprintf(stderr, "Read buffer full (%d bytes).\n", THIS->buf_size));
push_int(0); push_int(0); push_int(0);
apply_low(inp->u.file, inp->set_nb_off, 3);
pop_stack();
inp->mode = SLEEPING;
}
pop_n_elems(args);
if(THIS->outp->mode == IDLE) {
DERR(fprintf(stderr, "Waking up output.\n"));
THIS->outp->mode = ACTIVE;
f__output_write_cb(0);
} else {
DERR(fprintf(stderr, "Output is awake.\n"));
}
}
void image_polyfill(INT32 args)
{
struct vertex *v;
double *buf;
ONERROR err;
if (!THIS->img)
Pike_error("Image.Image->polyfill: no image\n");
buf=xalloc(sizeof(double)*(THIS->xsize+1));
SET_ONERROR(err, free, buf);
v=polyfill_begin();
while (args)
{
struct vertex *v_tmp;
if (sp[-1].type!=T_ARRAY)
{
polyfill_free(v);
SIMPLE_BAD_ARG_ERROR("Image.Image->polyfill", args,
"array(int|float)");
}
if ((v_tmp=polyfill_add(&v, sp[-1].u.array, args,
"Image.Image->polyfill()"))) {
v = v_tmp;
} else {
polyfill_free(v);
Pike_error("Image.Image->polyfill: Bad argument %d, bad vertex\n", args);
}
args--;
pop_stack();
}
if (!v) {
free(buf);
return; /* no vertices */
}
polyfill_some(THIS,v,buf);
polyfill_free(v);
UNSET_ONERROR(err);
free(buf);
ref_push_object(THISOBJ);
}
/* Set the output file (file object) */
static void f_output(INT32 args) {
if(args) {
if(ARG(1).type != T_OBJECT) {
SIMPLE_BAD_ARG_ERROR("_Caudium.nbio()->output", 1, "object");
} else {
output *outp;
if(THIS->outp != NULL) {
free_output(THIS->outp);
THIS->outp = NULL;
}
outp = malloc(sizeof(output));
outp->file = ARG(1).u.object;
outp->fd = fd_from_object(outp->file);
outp->set_nb_off = find_identifier("set_nonblocking", outp->file->prog);
outp->set_b_off = find_identifier("set_blocking", outp->file->prog);
outp->write_off = find_identifier("write", outp->file->prog);
if (outp->write_off < 0 || outp->set_nb_off < 0 || outp->set_b_off < 0)
{
free(outp);
Pike_error("_Caudium.nbio()->output: illegal file object%s%s%s\n",
((outp->write_off < 0)?"; no write":""),
((outp->set_nb_off < 0)?"; no set_nonblocking":""),
((outp->set_b_off < 0)?"; no set_blocking":""));
}
DERR(fprintf(stderr, "New output (fd = %d)\n", outp->fd));
outp->mode = ACTIVE;
add_ref(outp->file);
THIS->outp = outp;
noutputs++;
/* Set up the read callback. We don't need a close callback since
* it never will be called w/o a read_callback (which we don't want one).
*/
set_outp_write_cb(outp);
}
} else {
SIMPLE_TOO_FEW_ARGS_ERROR("_Caudium.nbio()->output", 1);
}
pop_n_elems(args-1);
}
/*
** method: string http_encode(string m)
** Encode with HTTP specification the given string
** arg: string m
** The string to encode.
** returns:
** The encoded string
*/
static void f_http_encode(INT32 args)
{
char *o, *out, *in;
unsigned char *i;
int unsafe = 0;
int out_len, in_len;
struct pike_string *ret;
struct pike_string *src;
if(Pike_sp[-1].type != T_STRING)
SIMPLE_BAD_ARG_ERROR("Caudium.http_encode", 1, "string");
src = Pike_sp[-1].u.string;
if(src->size_shift) {
Pike_error("Caudium.http_encode(): Only 8-bit strings allowed.\n");
}
in = src->str;
in_len = src->len-1;
/* count unsafe characters */
for(i=in; *i; i++) if(!is_safe((int )*i)) unsafe++;
/* no need to convert */
if(unsafe == 0) {
pop_n_elems(args-1);
return;
}
out_len = in_len + (unsafe * 2) + 1;
ret = begin_shared_string(out_len);
out = ret->str;
for(o=out, i=in; *i; i++) {
if (!is_safe(*i)) {
*o++ = '%';
*o++ = hex_chars[*i >> 4];
*o++ = hex_chars[*i & 15];
} else *o++ = *i;
static void f_read( INT32 args )
{
char *read_buf;
struct svalue *logfun, *file;
FD f = -1;
int cls, c, my_fd=1, state=0, tzs=0;
char *char_pointer;
INT32 v=0, yy=0, mm=0, dd=0, h=0, m=0, s=0, tz=0;
ptrdiff_t offs0=0, len=0;
struct svalue *old_sp;
/* #define DYNAMIC_BUF */
#ifdef DYNAMIC_BUF
dynamic_buffer buf;
#else
#define BUFSET(X) do { if(bufpos == bufsize) { bufsize *= 2; buf = realloc(buf, bufsize+1); } buf[bufpos++] = c; } while(0)
#define PUSHBUF() do { push_string( make_shared_binary_string( buf,bufpos ) ); bufpos=0; } while(0)
char *buf;
int bufsize=CLF_BLOCK_SIZE, bufpos=0;
#endif
if(args>2 && sp[-1].type == T_INT) {
offs0 = sp[-1].u.integer;
pop_n_elems(1);
--args;
}
old_sp = sp;
get_all_args("CommonLog.read", args, "%*%*", &logfun, &file);
if(logfun->type != T_FUNCTION)
SIMPLE_BAD_ARG_ERROR("CommonLog.read", 1, "function");
if(file->type == T_OBJECT)
{
f = fd_from_object(file->u.object);
if(f == -1)
Pike_error("CommonLog.read: File is not open.\n");
my_fd = 0;
} else if(file->type == T_STRING &&
file->u.string->size_shift == 0) {
#ifdef PIKE_SECURITY
if(!CHECK_SECURITY(SECURITY_BIT_SECURITY))
{
if(!CHECK_SECURITY(SECURITY_BIT_CONDITIONAL_IO))
Pike_error("Permission denied.\n");
push_text("read");
push_int(0);
ref_push_string(file->u.string);
push_text("r");
push_int(00666);
safe_apply(OBJ2CREDS(CURRENT_CREDS)->user,"valid_open",5);
switch(Pike_sp[-1].type)
{
case PIKE_T_INT:
switch(Pike_sp[-1].u.integer)
{
case 0: /* return 0 */
errno=EPERM;
Pike_error("CommonLog.read(): Failed to open file for reading (errno=%d).\n",
errno);
case 2: /* ok */
pop_stack();
break;
case 3: /* permission denied */
Pike_error("CommonLog.read: permission denied.\n");
default:
Pike_error("Error in user->valid_open, wrong return value.\n");
}
break;
default:
Pike_error("Error in user->valid_open, wrong return type.\n");
case PIKE_T_STRING:
/* if(Pike_sp[-1].u.string->shift_size) */
/* file=Pike_sp[-1]; */
pop_stack();
}
}
#endif
do {
THREADS_ALLOW();
f=fd_open((char *)STR0(file->u.string), fd_RDONLY, 0);
THREADS_DISALLOW();
if (f >= 0 || errno != EINTR) break;
check_threads_etc();
} while (1);
if(f < 0)
Pike_error("CommonLog.read(): Failed to open file for reading (errno=%d).\n",
errno);
} else
SIMPLE_BAD_ARG_ERROR("CommonLog.read", 2, "string|Stdio.File");
#ifdef HAVE_LSEEK64
lseek64(f, offs0, SEEK_SET);
#else
fd_lseek(f, offs0, SEEK_SET);
#endif
read_buf = malloc(CLF_BLOCK_SIZE+1);
#ifndef DYNAMIC_BUF
buf = malloc(bufsize);
#endif
while(1) {
do {
THREADS_ALLOW();
len = fd_read(f, read_buf, CLF_BLOCK_SIZE);
THREADS_DISALLOW();
if (len >= 0 || errno != EINTR) break;
check_threads_etc();
} while (1);
if(len == 0)
break; /* nothing more to read. */
if(len < 0)
break;
char_pointer = read_buf;
while(len--) {
offs0++;
c = char_pointer[0] & 0xff;
char_pointer ++;
cls = char_class[c];
#ifdef TRACE_DFA
fprintf(stderr, "DFA(%d): '%c' ", state, (c<32? '.':c));
switch(cls) {
case CLS_WSPACE: fprintf(stderr, "CLS_WSPACE"); break;
case CLS_CRLF: fprintf(stderr, "CLS_CRLF"); break;
case CLS_TOKEN: fprintf(stderr, "CLS_TOKEN"); break;
case CLS_DIGIT: fprintf(stderr, "CLS_DIGIT"); break;
case CLS_QUOTE: fprintf(stderr, "CLS_QUOTE"); break;
case CLS_LBRACK: fprintf(stderr, "CLS_LBRACK"); break;
case CLS_RBRACK: fprintf(stderr, "CLS_RBRACK"); break;
case CLS_SLASH: fprintf(stderr, "CLS_SLASH"); break;
case CLS_COLON: fprintf(stderr, "CLS_COLON"); break;
case CLS_HYPHEN: fprintf(stderr, "CLS_HYPHEN"); break;
case CLS_PLUS: fprintf(stderr, "CLS_PLUS"); break;
default: fprintf(stderr, "???");
}
fprintf(stderr, " %d items on stack\n", sp-old_sp);
#endif
switch(state) {
case 0:
if(sp != old_sp) {
if(sp == old_sp+15) {
f_aggregate(15);
push_int64(offs0);
apply_svalue(logfun, 2);
pop_stack();
} else
pop_n_elems(sp-old_sp);
}
if(cls > CLS_CRLF) {
if(cls == CLS_HYPHEN) {
push_int(0);
state = 2;
break;
}
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
low_my_putchar( c, &buf );
#else
bufpos = 0;
BUFSET(c);
#endif
state=1;
}
break;
case 1:
if(cls > CLS_CRLF) {
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
break;
}
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* remotehost */
#else
PUSHBUF();
#endif
state = (cls == CLS_WSPACE? 2:0);
break;
case 2:
if(cls > CLS_CRLF) {
if(cls == CLS_HYPHEN) {
push_int(0);
state = 4;
break;
}
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
low_my_putchar( c, &buf );
#else
bufpos = 0;
BUFSET(c);
#endif
state=3;
} else if(cls == CLS_CRLF)
state=0;
break;
case 3:
if(cls > CLS_CRLF) {
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
break;
}
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* rfc931 */
#else
PUSHBUF(); /* rfc931 */
#endif
state = (cls == CLS_WSPACE? 4:0);
break;
case 4:
if(cls > CLS_CRLF) {
if(cls == CLS_HYPHEN) {
push_int(0);
state = 6;
break;
}
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
low_my_putchar( c, &buf );
#else
bufpos = 0;
BUFSET(c);
#endif
state=5;
} else if(cls == CLS_CRLF)
state=0;
break;
case 5:
if(cls > CLS_CRLF) {
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
break;
}
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* authuser */
#else
PUSHBUF(); /* authuser */
#endif
state = (cls == CLS_WSPACE? 6:0);
break;
case 6:
if(cls == CLS_LBRACK)
state = 15;
else if(cls == CLS_CRLF)
state = 0;
else if(cls == CLS_HYPHEN) {
push_int(0);
push_int(0);
push_int(0);
state = 7;
}
break;
case 7:
if(cls == CLS_QUOTE) {
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
#else
bufpos = 0;
#endif
state = 31;
} else if(cls == CLS_CRLF)
state = 0;
else if(cls == CLS_HYPHEN) {
push_int(0);
push_int(0);
push_int(0);
state = 10;
}
break;
case 8:
if(cls == CLS_QUOTE)
state = 9;
else if(cls == CLS_CRLF) {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) );
#else
PUSHBUF();
#endif
state = 0;
} else
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
break;
case 9:
if(cls > CLS_CRLF) {
#ifdef DYNAMIC_BUF
low_my_putchar( '"', &buf);
low_my_putchar( c, &buf);
#else
BUFSET('"');
BUFSET(c);
#endif
state = 8;
break;
}
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* protocol */
#else
PUSHBUF(); /* protoocl */
#endif
state = (cls == CLS_CRLF? 0 : 10);
break;
case 10:
if(cls == CLS_DIGIT) {
v = c&0xf;
state = 11;
} else if(cls == CLS_CRLF)
state = 0;
else if(cls == CLS_HYPHEN) {
push_int(0);
state = 12;
}
break;
case 11:
if(cls == CLS_DIGIT)
v = v*10+(c&0xf);
else if(cls == CLS_WSPACE) {
push_int(v); /* status */
state = 12;
} else state = 0;
break;
case 12:
if(cls == CLS_DIGIT) {
v = c&0xf;
state = 13;
} else if(cls == CLS_CRLF)
state = 0;
else if(cls == CLS_HYPHEN) {
push_int(0);
state = 14;
}
break;
case 13:
if(cls == CLS_DIGIT)
v = v*10+(c&0xf);
else {
push_int(v); /* bytes */
state = (cls == CLS_CRLF? 0:14);
}
break;
case 14:
if(cls == CLS_CRLF)
state = 0;
break;
case 15:
if(cls == CLS_DIGIT) {
dd = c&0xf;
state = 16;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 16:
/* getting day */
if(cls == CLS_DIGIT)
dd = dd*10+(c&0xf);
else if(cls == CLS_SLASH)
state = 17;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 17:
if(cls == CLS_DIGIT) {
mm = c&0xf;
state = 18;
} else if(cls == CLS_TOKEN) {
mm = c|0x20;
state = 21;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 18:
/* getting numeric month */
if(cls == CLS_DIGIT)
mm = mm*10+(c&0xf);
else if(cls == CLS_SLASH)
state = 19;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 19:
if(cls == CLS_DIGIT) {
yy = c&0xf;
state = 20;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 20:
/* getting year */
if(cls == CLS_DIGIT)
yy = yy*10+(c&0xf);
else if(cls == CLS_COLON)
state = 22;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 21:
/* getting textual month */
if(cls == CLS_TOKEN)
mm = (mm<<8)|c|0x20;
else if(cls == CLS_SLASH) {
state = 19;
switch(mm) {
case ('j'<<16)|('a'<<8)|'n': mm=1; break;
case ('f'<<16)|('e'<<8)|'b': mm=2; break;
case ('m'<<16)|('a'<<8)|'r': mm=3; break;
case ('a'<<16)|('p'<<8)|'r': mm=4; break;
case ('m'<<16)|('a'<<8)|'y': mm=5; break;
case ('j'<<16)|('u'<<8)|'n': mm=6; break;
case ('j'<<16)|('u'<<8)|'l': mm=7; break;
case ('a'<<16)|('u'<<8)|'g': mm=8; break;
case ('s'<<16)|('e'<<8)|'p': mm=9; break;
case ('o'<<16)|('c'<<8)|'t': mm=10; break;
case ('n'<<16)|('o'<<8)|'v': mm=11; break;
case ('d'<<16)|('e'<<8)|'c': mm=12; break;
default:
state = 14;
}
}
break;
case 22:
if(cls == CLS_DIGIT) {
h = c&0xf;
state = 23;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 23:
/* getting hour */
if(cls == CLS_DIGIT)
h = h*10+(c&0xf);
else if(cls == CLS_COLON)
state = 24;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 24:
if(cls == CLS_DIGIT) {
m = c&0xf;
state = 25;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 25:
/* getting minute */
if(cls == CLS_DIGIT)
m = m*10+(c&0xf);
else if(cls == CLS_COLON)
state = 26;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 26:
if(cls == CLS_DIGIT) {
s = c&0xf;
state = 27;
} else
state = (cls == CLS_CRLF? 0:14);
break;
case 27:
/* getting second */
if(cls == CLS_DIGIT)
s = s*10+(c&0xf);
else if(cls == CLS_WSPACE)
state = 28;
else
state = (cls == CLS_CRLF? 0:14);
break;
case 28:
if(cls>=CLS_HYPHEN) {
state = 29;
tzs = cls!=CLS_PLUS;
tz = 0;
} else if(cls == CLS_DIGIT) {
state = 29;
tzs = 0;
tz = c&0xf;
} else if(cls==CLS_CRLF)
state = 0;
break;
case 29:
/* getting timezone */
if(cls == CLS_DIGIT)
tz = tz*10+(c&0xf);
else {
if(tzs)
tz = -tz;
push_int(yy);
push_int(mm);
push_int(dd);
push_int(h);
push_int(m);
push_int(s);
push_int(tz);
if(cls == CLS_RBRACK)
state = 7;
else
state = (cls == CLS_CRLF? 0 : 30);
}
break;
case 30:
if(cls == CLS_RBRACK)
state = 7;
else if(cls == CLS_CRLF)
state = 0;
break;
case 31:
if(cls == CLS_QUOTE) {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) );
#else
PUSHBUF();
#endif
push_int(0);
push_int(0);
state = 10;
} else if(cls >= CLS_TOKEN)
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
else {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* method */
#else
PUSHBUF(); /* method */
#endif
state = (cls == CLS_CRLF? 0 : 32);
}
break;
case 32:
if(cls == CLS_QUOTE) {
push_int(0);
push_int(0);
state = 10;
} else if(cls >= CLS_TOKEN) {
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
low_my_putchar( c, &buf );
#else
bufpos = 0;
BUFSET(c);
#endif
state = 33;
} else
if(cls == CLS_CRLF)
state = 0;
break;
case 33:
if(cls == CLS_QUOTE)
state = 34;
else if(cls == CLS_CRLF) {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) );
#else
PUSHBUF();
#endif
state = 0;
} else if(cls == CLS_WSPACE) {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) ); /* path */
#else
PUSHBUF(); /* path */
#endif
state = 35;
} else
#ifdef DYNAMIC_BUF
low_my_putchar( c, &buf );
#else
BUFSET(c);
#endif
break;
case 34:
if(cls >= CLS_TOKEN) {
#ifdef DYNAMIC_BUF
low_my_putchar( '"', &buf );
low_my_putchar( c, &buf );
#else
BUFSET('"');
BUFSET(c);
#endif
state = 33;
} else if(cls == CLS_CRLF) {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) );
#else
PUSHBUF();
#endif
state = 0;
} else {
#ifdef DYNAMIC_BUF
push_string( low_free_buf( &buf ) );
#else
PUSHBUF();
#endif
push_text("HTTP/0.9");
state = 10;
}
break;
case 35:
if(cls == CLS_QUOTE) {
push_text("HTTP/0.9");
state = 10;
} else if(cls >= CLS_TOKEN) {
#ifdef DYNAMIC_BUF
buf.s.str = NULL;
initialize_buf( &buf );
low_my_putchar( c, &buf );
#else
bufpos = 0;
BUFSET(c);
#endif
state = 8;
} else
if(cls == CLS_CRLF)
state = 0;
break;
}
}
}
