cBuf * pack_data(cBuf *buf, cData *data)
{
buf = write_long(buf, data->type);
switch (data->type) {
case INTEGER:
buf = write_long(buf, data->u.val);
break;
case FLOAT:
buf = write_float(buf, data->u.fval);
break;
case STRING:
buf = string_pack(buf, data->u.str);
break;
case OBJNUM:
buf = write_long(buf, data->u.objnum);
break;
case LIST:
buf = pack_list(buf, data->u.list);
break;
case SYMBOL:
buf = write_ident(buf, data->u.symbol);
break;
case T_ERROR:
buf = write_ident(buf, data->u.error);
break;
case FROB:
buf = write_long(buf, data->u.frob->cclass);
buf = pack_data(buf, &data->u.frob->rep);
break;
case DICT:
buf = pack_dict(buf, data->u.dict);
break;
case BUFFER:
buf = write_long(buf, data->u.buffer->len);
buf = buffer_append(buf, data->u.buffer);
break;
#ifdef USE_PARENT_OBJS
case OBJECT:
break;
#endif
default: {
INSTANCE_RECORD(data->type, r);
buf = r->pack(buf, data);
}
}
return buf;
}
void mkdir(int fd, std::string name) {
std::vector<std::string> dirs = split(name, '/');
int inum = 1; //1 represents the root
SuperBlock sb(fd);
//Get the i-number for each directory along the path,
//Until the first directory along the path isn't found
//Create that directory
for(std::vector<std::string>::iterator it = dirs.begin(); it != dirs.end(); ++it) {
dout << *it << std::endl;
int child_inum = path_to_inum(fd, *it, inum);
//if the directory is not present
if(child_inum < 1) {
child_inum = sb.allocate_inode(fd);
if(child_inum < 1) {
std::cerr << "I-nodes depleted. Cannot allocate directory entry." << std::endl;
return;
}
INode node(child_inum);
node.flags = 0x8000 | 0x4000; //allocated and directory
//We've allocated an inode, now we need to allocate a data block
//Populate that data block with the entries for . and ..
//and associate it with the inode.
int block = sb.allocate_block(fd);
if(block < 0) {
std::cerr << "Data blocks depleted. Cannot allocate directory entry." << std::endl;
return;
}
char buffer[BLOCK_SIZE] = {};
write_long(child_inum, sizeof(child_inum), buffer);
buffer[sizeof(child_inum)] = '.';
write_long(inum, sizeof(inum), buffer + DIR_SIZE);
buffer[sizeof(inum) + DIR_SIZE] = '.';
buffer[sizeof(inum) + DIR_SIZE + 1] = '.';
lseek(fd, block, SEEK_SET);
write(fd, buffer, BLOCK_SIZE);
char dir_entry[DIR_SIZE];
write_long(child_inum, sizeof(child_inum), dir_entry);
strncpy(dir_entry + sizeof(child_inum), (*it).c_str(), DIR_SIZE - sizeof(child_inum));
//Add child inode to parent's directory listing
addDirEntry(fd, inum, dir_entry);
node.flush(fd);
}
inum = child_inum;
}
sb.flush(fd);
}
void write_times() {
struct timespec tf;
clock_gettime(CLOCK_MONOTONIC, &tf);
write_long(ts.tv_sec);
write_long(ts.tv_nsec);
write_long(tf.tv_sec);
write_long(tf.tv_nsec);
}
static cBuf * pack_list(cBuf *buf, cList *list)
{
cData *d;
if (!list) {
buf = write_long(buf, -1);
} else {
buf = write_long(buf, list_length(list));
for (d = list_first(list); d; d = list_next(list, d))
buf = pack_data(buf, d);
}
return buf;
}
int write_object_basic(FILE *fp, int index, object *obj)
{
int i;
/* begin of object data */
write_int(fp, index); /* object # */
printf("Writing object %s\n", obj->name );
write_chars(fp, obj->name, sizeof(obj->name));
write_chars(fp, obj->description, sizeof(obj->description));
for (i = 0; i != 3; i++)
write_chars(fp, obj->key[i], sizeof(obj->key[i]));
write_chars(fp, obj->use_output, sizeof(obj->use_output));
write_long(fp, obj->value);
write_short(fp, obj->weight);
write_char(fp, obj->type);
write_char(fp, obj->adjustment);
write_short(fp, obj->shotsmax);
write_short(fp, obj->shotscur);
write_short(fp, obj->ndice);
write_short(fp, obj->sdice);
write_short(fp, obj->pdice);
write_char(fp, obj->armor);
write_char(fp, obj->wearflag);
write_char(fp, obj->magicpower);
write_char(fp, obj->magicrealm);
write_short(fp, obj->special);
write_chars(fp, obj->flags, sizeof(obj->flags));
write_char(fp, obj->questnum);
write_char(fp,obj->strength);
write_char(fp,obj->dexterity);
write_char(fp,obj->constitution);
write_char(fp,obj->intelligence);
write_char(fp,obj->piety);
for (i = 0; i != 16; i++)
write_short(fp, obj->sets_flag[i]);
write_short(fp,obj->special1);
write_long(fp,obj->special2);
/* end of object data */
return(0);
}
void command_ls(t_env *env, char **splitted)
{
long i;
char c;
write_long(env, COMMAND_LS);
write_long(env, tab_len(splitted));
i = 1;
while (splitted[i])
write_str(env, splitted[i++]);
while ((c = read_byte(env)))
ft_putchar(c);
ft_putendl("SUCCESS");
(void)splitted;
}
static cBuf * pack_dict(cBuf *buf, cDict *dict)
{
Int i;
buf = pack_list(buf, dict->keys);
buf = pack_list(buf, dict->values);
if (dict->keys->len > 64) {
buf = write_long(buf, dict->hashtab_size);
for (i = 0; i < dict->hashtab_size; i++) {
buf = write_long(buf, dict->links[i]);
buf = write_long(buf, dict->hashtab[i]);
}
}
return buf;
}
cBuf * write_ident(cBuf *buf, Ident id)
{
Char *s;
Int len;
if (id == NOT_AN_IDENT) {
buf = write_long(buf, NOT_AN_IDENT);
return buf;
}
s = ident_name_size(id, &len);
buf = write_long(buf, len);
buf = buffer_append_uchars_single_ref(buf, (uChar *)s, len);
return buf;
}
static cBuf * pack_idents(cBuf *buf, Obj *obj)
{
Int i;
buf = write_long(buf, obj->methods->idents_size);
buf = write_long(buf, obj->methods->num_idents);
for (i = 0; i < obj->methods->num_idents; i++) {
if (obj->methods->idents[i].id != NOT_AN_IDENT) {
buf = write_ident(buf, obj->methods->idents[i].id);
buf = write_long(buf, obj->methods->idents[i].refs);
} else {
buf = write_long(buf, NOT_AN_IDENT);
}
}
return buf;
}
int WaveProc::write_header(FILE *out, unsigned int data_length)
{
fprintf(out, "RIFF");
write_long(out, fmt_chunk->riff_length);
fprintf(out, "WAVE");
fprintf(out, "fmt ");
write_long(out, 16);
write_word(out, fmt_chunk->format_type);
write_word(out, fmt_chunk->channel_numbers);
write_long(out, fmt_chunk->sample_rate);
write_long(out, fmt_chunk->bytes_per_second);
write_word(out, fmt_chunk->bytes_per_sample);
write_word(out, fmt_chunk->bits_per_sample);
fprintf(out, "data");
write_long(out, data_length);
return 0;
}
cBuf *pack_handled (cBuf *buf, cData *d)
{
HandledFrob *h = HANDLED_FROB(d);
buf = write_long (buf, h->cclass);
buf = pack_data (buf, &h->rep);
buf = write_ident(buf, h->handler);
return buf;
}
static void do_the_thing(t_env *env, char **splitted)
{
char *file;
int fd;
file = get_file_name(splitted[1]);
if ((fd = open(file, O_CREAT | O_TRUNC | O_WRONLY
, (int)read_long(env))) == -1)
{
write_long(env, 0);
ft_putendl("ERROR: can't create file");
return ;
}
write_long(env, 1);
read_file(env, fd);
close(fd);
free(file);
}
void write_log_delta (unsigned long when, unsigned char offset, unsigned char delta)
{
unsigned long since_last = when - when_last;
int rc;
rc = write_long (fd, since_last);
rc = write (fd, &offset, sizeof (offset));
rc = write (fd, &delta, sizeof (delta));
when_last = when;
}
void command_pwd(t_env *env, char **splitted)
{
char *path;
write_long(env, COMMAND_PWD);
path = read_str(env);
ft_putendl(path);
ft_putendl("SUCCESS");
free(path);
(void)splitted;
}
void close(Sink& snk, BOOST_IOS::openmode m)
{
try {
// Close zlib compressor.
base_type::close(snk, m);
if (m == BOOST_IOS::out) {
if (flags_ & f_header_done) {
// Write final fields of gzip file format.
write_long(this->crc(), snk);
write_long(this->total_in(), snk);
}
}
} catch(...) {
close_impl();
throw;
}
close_impl();
}
static cBuf * pack_methods(cBuf *buf, Obj *obj)
{
Int i;
if (!object_has_methods(obj)) {
buf = write_long(buf, -1);
return buf;
}
buf = write_long(buf, obj->methods->size);
buf = write_long(buf, obj->methods->blanks);
for (i = 0; i < obj->methods->size; i++) {
buf = write_long(buf, obj->methods->hashtab[i]);
if (obj->methods->tab[i].m) {
buf = pack_method(buf, obj->methods->tab[i].m);
} else {
/* Method begins with name identifier; write NOT_AN_IDENT. */
buf = write_long(buf, NOT_AN_IDENT);
}
buf = write_long(buf, obj->methods->tab[i].next);
}
buf = pack_strings(buf, obj);
buf = pack_idents(buf, obj);
return buf;
}
static int erl_json_ei_number(void* ctx, const char * val, unsigned int len) {
State* pState = (State*) ctx;
flog(stderr, "number", 0, val, len);
list_header_for_value(pState);
switch(numbers_as(pState)) {
case EEP0018_PARSE_NUMBERS_AS_NUMBER:
{
if(memchr(val, '.', len) || memchr(val, 'e', len) || memchr(val, 'E', len))
write_double(pState, strtod(val, 0));
else
write_long(pState, strtol(val, 0, 10));
break;
}
case EEP0018_PARSE_NUMBERS_AS_FLOAT:
{
write_double(pState, strtod(val, 0));
break;
}
case EEP0018_PARSE_NUMBERS_AS_TUPLE:
{
/*
While "1e1" is a valid JSON number, it is not a valid parameter to list_to_float/1
We fix that by inserting ".0" before the exponent e.
*/
const char* exp = memchr(val, 'e', len);
if(exp && exp > val) {
const char* dot = memchr(val, '.', exp - val);
if(!dot) {
char* tmp = alloca(len + 5);
memcpy(tmp, val, exp - val);
memcpy(tmp + (exp - val), ".0", 2);
memcpy(tmp + (exp - val) + 2, exp, len - (exp - val));
len += 2;
val = tmp;
tmp[len] = 0;
}
}
write_tuple_header(pState, 3);
write_atom(pState, "number", 6);
write_string(pState, val, len);
write_atom(pState, "a", 1); // a dummy
break;
}
}
return 1;
}
void write_log_state (unsigned long when, unsigned char offset, unsigned char state)
{
unsigned long since_last = when - when_last;
unsigned char marker = 0xF8;
int rc;
rc = write (fd, &marker, sizeof (marker));
rc = write_long (fd, since_last);
rc =write (fd, &offset, sizeof (offset));
rc = write (fd, &state, sizeof (state));
when_last = when;
io_state[offset] = state;
}
static glui32 write_memstate(dest_t *dest)
{
glui32 res, pos;
int val;
int runlen;
unsigned char ch;
res = write_long(dest, endmem);
if (res)
return res;
runlen = 0;
glk_stream_set_position(gamefile, gamefile_start+ramstart, seekmode_Start);
for (pos=ramstart; pos<endmem; pos++) {
ch = Mem1(pos);
if (pos < endgamefile) {
val = glk_get_char_stream(gamefile);
if (val == -1) {
fatal_error("The game file ended unexpectedly while saving.");
}
ch ^= (unsigned char)val;
}
if (ch == 0) {
runlen++;
}
else {
/* Write any run we've got. */
while (runlen) {
if (runlen >= 0x100)
val = 0x100;
else
val = runlen;
res = write_byte(dest, 0);
if (res)
return res;
res = write_byte(dest, (val-1));
if (res)
return res;
runlen -= val;
}
/* Write the byte we got. */
res = write_byte(dest, ch);
if (res)
return res;
}
}
/* It's possible we've got a run left over, but we don't write it. */
return 0;
}
/* Saves the table along with the offset. */
int rc_sftable (struct functab * table) {
struct functab * t;
int i;
for (t = table; t != NULL; t = t->next) {
for (i = 0; /*i < MAXWS && */t -> name [i] != '\0'; i++) {
write_byte (t -> name [i]);
}
/*for (; i < MAXWS; i++)*/ write_byte ('\0');
write_long (t -> offset);
}
return 0;
}
static void compile_desc_entry(repo_t *repo, const alpm_pkg_meta_t *pkg, struct buffer *buf)
{
write_string(buf, "FILENAME", pkg->filename);
write_string(buf, "NAME", pkg->name);
write_string(buf, "BASE", pkg->base);
write_string(buf, "VERSION", pkg->version);
write_string(buf, "DESC", pkg->desc);
write_list(buf, "GROUPS", pkg->groups);
write_long(buf, "CSIZE", (long)pkg->size);
write_long(buf, "ISIZE", (long)pkg->isize);
if (pkg->md5sum) {
write_string(buf, "MD5SUM", pkg->md5sum);
} else {
char *md5sum = _compute_md5sum(repo->dirfd, pkg->filename);
write_string(buf, "MD5SUM", md5sum);
free(md5sum);
}
if (pkg->sha256sum) {
write_string(buf, "SHA256SUM", pkg->sha256sum);
} else {
char *sha256sum = _compute_sha256sum(repo->dirfd, pkg->filename);
write_string(buf, "SHA256SUM", sha256sum);
free(sha256sum);
}
if (pkg->base64_sig)
write_string(buf, "PGPSIG", pkg->base64_sig);
write_string(buf, "URL", pkg->url);
write_list(buf, "LICENSE", pkg->license);
write_string(buf, "ARCH", pkg->arch);
write_long(buf, "BUILDDATE", pkg->builddate);
write_string(buf, "PACKAGER", pkg->packager);
write_list(buf, "REPLACES", pkg->replaces);
}
/**
* Goes back and writes out the subroutine list
*/
void write_index() {
fseek(dest_file, 3, SEEK_SET);
int bytesRemaining = indexSize - 3;
for (int i = 0; i < subroutinesCount; ++i) {
int entrySize = strlen(subroutinesTable[i].name) + 5;
// Ensure there is enough remaining space
if ((bytesRemaining - entrySize) < 0) {
printf("Index has exceeded allowable size.\n");
token = ERROR;
}
// Write out the name and the file offset
write_bytes((byte *)&subroutinesTable[i].name, strlen(subroutinesTable[i].name) + 1);
write_long(subroutinesTable[i].fileOffset);
}
}
void command_get(t_env *env, char **splitted)
{
int res;
if (!splitted[1])
{
ft_putendl("ERROR: you must specify a file to get");
return ;
}
write_long(env, COMMAND_GET);
write_str(env, splitted[1]);
if ((res = read_long(env)) == -1)
ft_putendl("ERROR: file not found");
else if (res == -2)
ft_putendl("ERROR: permissions denied");
else if (res == -3)
ft_putendl("ERROR: unknown error");
else
do_the_thing(env, splitted);
}
static glui32 write_heapstate_sub(glui32 sumlen, glui32 *sumarray,
dest_t *dest, int portable)
{
glui32 res, lx;
/* If we're storing for the purpose of undo, we don't need to do any
byte-swapping, because the result will only be used by this session. */
if (!portable) {
res = write_buffer(dest, (void *)sumarray, sumlen*sizeof(glui32));
if (res)
return res;
return 0;
}
for (lx=0; lx<sumlen; lx++) {
res = write_long(dest, sumarray[lx]);
if (res)
return res;
}
return 0;
}
static cBuf * pack_vars(cBuf *buf, Obj *obj)
{
Int i;
buf = write_long(buf, obj->vars.size);
buf = write_long(buf, obj->vars.blanks);
for (i = 0; i < obj->vars.size; i++) {
buf = write_long(buf, obj->vars.hashtab[i]);
if (obj->vars.tab[i].name != NOT_AN_IDENT) {
buf = write_ident(buf, obj->vars.tab[i].name);
buf = write_long(buf, obj->vars.tab[i].cclass);
buf = pack_data(buf, &obj->vars.tab[i].val);
} else {
buf = write_long(buf, NOT_AN_IDENT);
}
buf = write_long(buf, obj->vars.tab[i].next);
}
return buf;
}
/* Initialisation du fichier TIFF résultat, avec les paramètres suivants:
- width: la largeur de l'image ;
- height: la hauteur de l'image ;
- row_per_strip: le nombre de lignes de pixels par bande.
*/
struct tiff_file_desc *init_tiff_file (const char *file_name,
uint32_t width,
uint32_t height,
uint32_t row_per_strip)
{
FILE *file = NULL;
struct tiff_file_desc *tfd = calloc(1, sizeof(struct tiff_file_desc));
uint32_t line_size;
if (tfd == NULL)
return NULL;
/* Allocate & check write_buf */
tfd->row_size = width * 3;
tfd->write_buf = malloc(tfd->row_size);
if (tfd->write_buf == NULL)
return NULL;
/* Allocate & check strip_offsets */
tfd->nb_strips = height / row_per_strip;
if (height % row_per_strip)
tfd->nb_strips++;
tfd->strip_offsets = malloc(tfd->nb_strips * sizeof(uint32_t));
if (tfd->strip_offsets == NULL)
return NULL;
/* Allocate & check strip_bytes */
tfd->strip_bytes = malloc(tfd->nb_strips * sizeof(uint32_t));
if (tfd->strip_bytes == NULL)
return NULL;
file = fopen(file_name, "wb");
if (file == NULL)
return NULL;
tfd->file = file;
tfd->is_le = true;
tfd->width = width;
tfd->height = height;
tfd->rows_per_strip = row_per_strip;
/* Software comment definition */
const char *comment = COMMENT;
const uint32_t comment_size = strlen(comment) + 1;
/* Header construction */
const uint32_t ifd_offset = 8 + comment_size;
const uint16_t entry_count = 13;
/* Endianness + TIFF identification */
write_short(tfd, LITTLE_ENDIAN);
write_short(tfd, 42);
/* IFD offset */
write_long(tfd, ifd_offset);
/* Software comment */
fwrite(comment, 1, comment_size, file);
uint32_t next = ifd_offset + 2 + 12 * entry_count + 4;
/* IFD data */
write_short(tfd, entry_count);
/* Image Width */
write_short(tfd, IMAGE_WIDTH);
write_short(tfd, LONG);
write_long(tfd, 1);
write_long(tfd, tfd->width);
/* Image Length */
write_short(tfd, IMAGE_LENGTH);
write_short(tfd, LONG);
write_long(tfd, 1);
write_long(tfd, tfd->height);
/* BitsPerSample */
write_short(tfd, BITS_PER_SAMPLE);
write_short(tfd, SHORT);
write_long(tfd, 3);
write_long(tfd, next);
next += 3 * 2;
/* Compression */
write_short(tfd, COMPRESSION);
write_short(tfd, SHORT);
write_long(tfd, 1);
write_long(tfd, 1);
/* PhotometricInterpretation */
write_short(tfd, PHOTOMETRIC);
write_short(tfd, SHORT);
write_long(tfd, 1);
write_long(tfd, 2);
/* StripOffsets */
write_short(tfd, STRIP_OFFSETS);
write_short(tfd, LONG);
write_long(tfd, tfd->nb_strips);
const uint32_t strips_pos = next + 16;
uint32_t line_offset = strips_pos;
/* One row handling */
if (tfd->nb_strips > 1) {
line_offset += 8 * tfd->nb_strips;
write_long(tfd, strips_pos);
}
else {
write_long(tfd, line_offset);
tfd->strip_offsets[0] = line_offset;
}
/* SamplesPerPixel */
write_short(tfd, SAMPLES_PER_PIXEL);
write_short(tfd, SHORT);
write_long(tfd, 1);
write_long(tfd, 3);
/* RowsPerStrip */
write_short(tfd, ROWS_PER_STRIP);
write_short(tfd, LONG);
write_long(tfd, 1);
write_long(tfd, tfd->rows_per_strip);
/* StripByteCounts */
write_short(tfd, STRIP_BYTE_COUNTS);
write_short(tfd, LONG);
write_long(tfd, tfd->nb_strips);
/* Last line's height */
uint32_t line_height = tfd->height % tfd->rows_per_strip;
if (tfd->height > 0 && line_height == 0)
line_height = tfd->rows_per_strip;
/* One row handling */
if (tfd->nb_strips > 1) {
line_size = tfd->rows_per_strip * tfd->width * 3;
write_long(tfd, strips_pos + 4 * tfd->nb_strips);
}
else {
line_size = line_height * tfd->width * 3;
write_long(tfd, line_size);
tfd->strip_bytes[0] = line_size;
}
/* XResolution */
write_short(tfd, X_RESOLUTION);
write_short(tfd, RATIONAL);
write_long(tfd, 1);
write_long(tfd, next);
next += 2 * 4;
/* YResolution */
write_short(tfd, Y_RESOLUTION);
write_short(tfd, RATIONAL);
write_long(tfd, 1);
write_long(tfd, next);
next += 2 * 4;
/* ResolutionUnit */
write_short(tfd, RESOLUTION_UNIT);
write_short(tfd, SHORT);
write_long(tfd, 1);
write_long(tfd, 2);
/* Software */
write_short(tfd, SOFTWARE);
write_short(tfd, ASCII);
write_long(tfd, comment_size);
write_long(tfd, 8);
/* No other IFD */
write_long(tfd, 0);
/* BitsPerSample data */
write_short(tfd, 8);
write_short(tfd, 8);
write_short(tfd, 8);
/* XResolution data */
write_long(tfd, 100);
write_long(tfd, 1);
/* YResolution data */
write_long(tfd, 100);
write_long(tfd, 1);
/* Initialize internal writing data */
tfd->current_line = 0;
tfd->line_size = line_size;
/* Initialize the first MCU position */
tfd->next_pos_mcu = 0;
/* If there are multiple strips */
if (tfd->nb_strips > 1) {
/* Write all StripOffsets */
for (uint32_t i = 0; i < tfd->nb_strips; i++){
write_long(tfd, line_offset);
tfd->strip_offsets[i] = line_offset;
line_offset += line_size;
}
/* StripByteCounts data */
for (uint32_t i = 0; i < tfd->nb_strips - 1; i++) {
write_long(tfd, line_size);
tfd->strip_bytes[i] = line_size;
}
/* Last line's size */
line_size = line_height * tfd->width*3;
tfd->strip_bytes[tfd->nb_strips-1] = line_size;
write_long(tfd, line_size);
}
return tfd;
}
bool Quetzal::save(Common::WriteStream *svf, Processor *proc, const Common::String &desc) {
Processor &p = *proc;
uint ifzslen = 0, cmemlen = 0, stkslen = 0, descLen = 0;
uint pc;
zword i, j, n;
zword nvars, nargs, nstk;
zbyte var;
long cmempos, stkspos;
int c;
// Set a temporary memory stream for writing out the data. This is needed, since we need to
// do some seeking within it at the end to fill out totals before properly writing it all out
Common::MemoryWriteStreamDynamic saveData(DisposeAfterUse::YES);
_out = &saveData;
// Write `IFZS' header.
write_chnk(ID_FORM, 0);
write_long(ID_IFZS);
// Write `IFhd' chunk
pc = p.getPC();
write_chnk(ID_IFhd, 13);
write_word(p.h_release);
for (i = H_SERIAL; i<H_SERIAL + 6; ++i)
write_byte(p[i]);
write_word(p.h_checksum);
write_long(pc << 8); // Includes pad
// Write 'ANNO' chunk
descLen = desc.size() + 1;
write_chnk(ID_ANNO, descLen);
saveData.write(desc.c_str(), desc.size());
write_byte(0);
if ((desc.size() % 2) == 0) {
write_byte(0);
++descLen;
}
// Write `CMem' chunk.
cmempos = saveData.pos();
write_chnk(ID_CMem, 0);
_storyFile->seek(0);
// j holds current run length.
for (i = 0, j = 0, cmemlen = 0; i < p.h_dynamic_size; ++i) {
c = _storyFile->readByte();
c ^= p[i];
if (c == 0) {
// It's a run of equal bytes
++j;
} else {
// Write out any run there may be.
if (j > 0) {
for (; j > 0x100; j -= 0x100) {
write_run(0xFF);
cmemlen += 2;
}
write_run(j - 1);
cmemlen += 2;
j = 0;
}
// Any runs are now written. Write this (nonzero) byte
write_byte((zbyte)c);
++cmemlen;
}
}
// Reached end of dynamic memory. We ignore any unwritten run there may be at this point.
if (cmemlen & 1)
// Chunk length must be even.
write_byte(0);
// Write `Stks' chunk. You are not expected to understand this. ;)
stkspos = saveData.pos();
write_chnk(ID_Stks, 0);
// We construct a list of frame indices, most recent first, in `frames'.
// These indices are the offsets into the `stack' array of the word before
// the first word pushed in each frame.
frames[0] = p._sp - p._stack; // The frame we'd get by doing a call now.
for (i = p._fp - p._stack + 4, n = 0; i < STACK_SIZE + 4; i = p._stack[i - 3] + 5)
frames[++n] = i;
// All versions other than V6 can use evaluation stack outside a function
// context. We write a faked stack frame (most fields zero) to cater for this.
if (p.h_version != V6) {
for (i = 0; i < 6; ++i)
write_byte(0);
nstk = STACK_SIZE - frames[n];
write_word(nstk);
for (j = STACK_SIZE - 1; j >= frames[n]; --j)
write_word(p._stack[j]);
stkslen = 8 + 2 * nstk;
}
// Write out the rest of the stack frames.
for (i = n; i > 0; --i) {
zword *pf = p._stack + frames[i] - 4; // Points to call frame
nvars = (pf[0] & 0x0F00) >> 8;
nargs = pf[0] & 0x00FF;
nstk = frames[i] - frames[i - 1] - nvars - 4;
pc = ((uint)pf[3] << 9) | pf[2];
// Check type of call
switch (pf[0] & 0xF000) {
case 0x0000:
// Function
var = p[pc];
pc = ((pc + 1) << 8) | nvars;
break;
case 0x1000:
// Procedure
var = 0;
pc = (pc << 8) | 0x10 | nvars; // Set procedure flag
break;
default:
p.runtimeError(ERR_SAVE_IN_INTER);
return 0;
}
if (nargs != 0)
nargs = (1 << nargs) - 1; // Make args into bitmap
// Write the main part of the frame...
write_long(pc);
write_byte(var);
write_byte(nargs);
write_word(nstk);
// Write the variables and eval stack
for (j = 0, --pf; j<nvars + nstk; ++j, --pf)
write_word(*pf);
// Calculate length written thus far
stkslen += 8 + 2 * (nvars + nstk);
}
// Fill in variable chunk lengths
ifzslen = 4 * 8 + 4 + 14 + cmemlen + stkslen + descLen;
if (cmemlen & 1)
++ifzslen;
saveData.seek(4);
saveData.writeUint32BE(ifzslen);
saveData.seek(cmempos + 4);
saveData.writeUint32BE(cmemlen);
saveData.seek(stkspos + 4);
saveData.writeUint32BE(stkslen);
// Write the save data out
svf->write(saveData.getData(), saveData.size());
// After all that, still nothing went wrong!
return true;
}
/* Constructs and queues a request packet describing the http query pointed
* to by 'start'.
*/
int make_request_packet(Server *serv, int fd, int num_chars)
{
struct sockaddr_in client_name, local_name;
int client_namelen, local_namelen;
int free_start, free_end;
int packet_length;
char *request;
int len;
client_namelen = sizeof(struct sockaddr_in);
if (getpeername(fd, (struct sockaddr *) &client_name, &client_namelen) < 0)
{
syslog(LOG_INFO, "make_request_packet: failed to get peer "
"name: %m\n");
return 0;
}
local_namelen = sizeof(struct sockaddr_in);
if (getsockname(fd, (struct sockaddr *) &local_name, &local_namelen) < 0)
{
syslog(LOG_INFO, "make_request_packet: failed to get sock name: %m\n");
return 0;
}
change_state(serv, fd, fs_requested_backend);
/* locate the free end of the buffer (possibly appending to previous
* control packets) */
append_data(serv, serv->control_fd, &free_start, &free_end, fs_output);
/* reserve the first 4 bytes of the packet for the size field */
packet_length = PAK_COM_OFF;
/* add command field to packet */
serv->writebuf.buffer[free_start + packet_length++] = PAK_REQUEST;
/* add unique ID field to packet */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
(getpid() & 0xffff) | (fd << 16), 1);
/* add client IP field to packet */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
client_name.sin_addr.s_addr, 0);
/* add local IP field to packet */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
local_name.sin_addr.s_addr, 0);
/* add local port field to packet */
write_short(&serv->writebuf.buffer[free_start], &packet_length,
serv->port, 1);
/* write the http headers */
request = &serv->writebuf.buffer[serv->writebuf.pos[fd]];
while (request[0] == '\r' || request[0] == '\n')
request++;
for (len = 0; len < num_chars && !isspace(request[len]); len++)
;
if (len < num_chars)
{
write_string(&serv->writebuf.buffer[free_start], &packet_length,
"method");
write_string_n(&serv->writebuf.buffer[free_start], &packet_length,
request, len);
num_chars -= len;
request += len;
for (len = 0; len < num_chars && isspace(request[len]); len++)
;
if (len < num_chars)
{
num_chars -= len;
request += len;
for (len = 0; request[len] && !isspace(request[len]); len++)
;
write_string(&serv->writebuf.buffer[free_start], &packet_length,
"uri");
write_string_n(&serv->writebuf.buffer[free_start], &packet_length,
request, len);
num_chars -= len;
request += len;
for (len = 0; len < num_chars && isspace(request[len]); len++)
;
if (len < num_chars)
{
num_chars -= len;
request += len;
for (len = 0; request[len] && !isspace(request[len]); len++)
;
write_string(&serv->writebuf.buffer[free_start],
&packet_length, "version");
write_string_n(&serv->writebuf.buffer[free_start],
&packet_length, request, len);
/* each line should end with \r\n. Be a bit lenient, and
* allow just \r or \n, too. End of request is indicated
* by two such lines in a row */
if (request[len] == '\r')
len++;
if (request[len] == '\n')
len++;
num_chars -= len;
request += len;
/* find "field: value\r\n" on successive lines, adding them
* to the buffer as field\0value\0 */
while (num_chars > 0 && request[0] != '\r' &&
request[0] != '\n')
{
for (len = 0; len < num_chars && request[len] != ':' &&
request[len] != '\r' && request[len] != '\n'; len++)
;
if (len < num_chars && request[len] == ':')
{
write_string_n(&serv->writebuf.buffer[free_start],
&packet_length, request, len);
for (len++; len < num_chars && isspace(request[len]);
len++)
;
num_chars -= len;
request += len;
for (len = 0; len < num_chars && request[len] != '\r' &&
request[len] != '\n'; len++)
;
write_string_n(&serv->writebuf.buffer[free_start],
&packet_length, request, len);
}
if (request[len] == '\r')
len++;
if (request[len] == '\n')
len++;
num_chars -= len;
request += len;
}
}
}
}
/* set first 4 bytes of packet to the total packet length */
write_long(&serv->writebuf.buffer[free_start], NULL,
packet_length, 1);
/* add the packet to the output buffer properly */
if (free_end - free_start < packet_length)
fatal(serv, "request packet overflowed the buffer\n");
add_data(serv, serv->control_fd, NULL, free_start, packet_length,
fs_output);
return 1;
}
int make_backend_error_packet(Server *serv, int fd, u32 ip, u16 nbo_port)
{
struct sockaddr_in local_name;
struct sockaddr_in remote_name;
int local_namelen;
int remote_namelen;
int packet_length;
int free_start, free_end;
local_namelen = sizeof(struct sockaddr_in);
if (getsockname(fd, (struct sockaddr *) &local_name, &local_namelen) < 0)
{
syslog(LOG_INFO, "make_backend_error_packet: failed to get sock "
"name: %m\n");
return 0;
}
/* locate the free end of the buffer (possibly appending to previous
* control packets) */
append_data(serv, serv->control_fd, &free_start, &free_end, fs_output);
packet_length = PAK_COM_OFF;
/* write control code */
serv->writebuf.buffer[free_start + packet_length++] = PAK_BE_ERROR;
/* write unique id */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
(getpid() & 0xffff) | (fd << 16), 1);
/* add local IP field to packet */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
local_name.sin_addr.s_addr, 0);
/* add local port field to packet */
write_short(&serv->writebuf.buffer[free_start], &packet_length,
serv->port, 1);
if (serv->fd_partner[fd] == -1)
{
/* the connection failed straight away, so we've still got the ip
* and port (already in network byte order) to use */
write_long(&serv->writebuf.buffer[free_start], &packet_length, ip, 0);
write_short(&serv->writebuf.buffer[free_start], &packet_length,
nbo_port, 0);
}
else
{
/* else the partner (which is the failed backend fd) has the ip and
* port stored in serv->fd_connection_* */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
serv->fd_connection_ip[serv->fd_partner[fd]], 0);
write_short(&serv->writebuf.buffer[free_start], &packet_length,
serv->fd_connection_port[serv->fd_partner[fd]], 1);
}
/* add client IP field to packet */
remote_namelen = sizeof(struct sockaddr_in);
if (getpeername(fd, (struct sockaddr *) &remote_name,
&remote_namelen) == -1)
{
syslog(LOG_INFO, "make_backend_error_packet: failed to getpeer "
"name: %m\n");
return 0;
}
write_long(&serv->writebuf.buffer[free_start], &packet_length,
remote_name.sin_addr.s_addr, 0);
/* write length */
write_long(&serv->writebuf.buffer[free_start], NULL, packet_length, 1);
/* add the packet to the output buffer properly */
if (free_end - free_start < packet_length)
fatal(serv, "unable to fit backend_error packet in static buffer\n");
add_data(serv, serv->control_fd, NULL, free_start, packet_length,
fs_output);
return 1;
}
static void lstore(void)
{
const u32 *aaddr = (u32 *)cell2pointer(POP());
const u32 longval = POP();
write_long(aaddr, longval);
}
