void print_state() {
int i;
putblank(n + 1);
putchar('|');
putblank(2 * n + 1);
putchar('|');
putblank(2 * n + 1);
puts("|");
for (i = n - 1; i >= 0; -- i) {
putchar(' ');
putblock(i, 0);
putchar(' ');
putblock(i, 1);
putchar(' ');
putblock(i, 2);
puts("");
}
puts("");
}
/*
*递归回溯放置block
*参数x,y为二维坐标，
*/
void putblock(int x, int y, int e_x, int e_y)
{
int i,j;
if(count == 0){ //第一块方块放置在区域中心区
i = j = (N >> 1) + (N%2);
//for(i=j=1; i <= (N>>1) + (0x00000001 & N); i++, j++)
if(checklegal(i, j)){
box[i][j] = 1;
count++;
putblock(i, j, i, j);
box[i][j] = 0;
count --;
}
}
void catfile(char *o, size_t size, char *path, char *b, size_t bsize,
size_t * rsize)
{
struct jffs2_raw_dirent *dd;
struct jffs2_raw_inode *ri;
uint32_t ino;
dd = resolvepath(o, size, 1, path, &ino);
if (ino == 0)
errmsg_die("%s: No such file or directory", path);
if (dd == NULL || dd->type != DT_REG)
errmsg_die("%s: Not a regular file", path);
ri = find_raw_inode(o, size, ino);
putblock(b, bsize, rsize, ri);
write(1, b, *rsize);
}
int c_flush(C_FILE * fptr)
{
int it;
if (!(fptr->c_flag & WRITE)) {
fprintf(stderr, "no write access");
return EOF;
}
fptr->c_seccnt += blksiz / seclth;
/* caution: blockno() might evaluate its argument twice */
if (putblock(blockno(fptr->c_blk), fptr->c_base, -1) == EOF)
return EOF;
fptr->c_blk++;
if (fptr->c_blk == (use16bitptrs ? 8 : 16)) {
fptr->c_dirp->blkcnt = (char) 0x80;
savedir();
/* create new extent */
if ((it = creext(fptr->c_ext)) == 0) {
fprintf(stderr, "can't create new extent, current: %d\n", fptr->c_ext);
return EOF;
}
fptr->c_dirp = dirbuf + it;
fptr->c_ext = it;
fptr->c_blk = 0;
fptr->c_seccnt = 0;
fptr->c_extno++;
fptr->c_dirp->extno = fptr->c_extno;
}
fptr->c_buf = fptr->c_base;
fptr->c_cnt = blksiz;
if ((it = alloc()) == '\0') {
fprintf(stderr, "disk full\n");
return EOF;
}
if (use16bitptrs) {
fptr->c_dirp->pointers[2 * fptr->c_blk] = it & 0xff;
fptr->c_dirp->pointers[2 * fptr->c_blk + 1] = (it >> 8) & 0xff;
} else
void chunk::putblock(int x, int y, int z, block iblock){
putblock((ubyte)x, (ubyte)y, (ubyte)z, iblock);
}
struct jffs2_raw_dirent *resolvepath0(char *o, size_t size, uint32_t ino,
const char *p, uint32_t * inos, int recc)
{
struct jffs2_raw_dirent *dir = NULL;
int d = 1;
uint32_t tino;
char *next;
char *path, *pp;
char symbuf[1024];
size_t symsize;
if (recc > 16) {
/* probably symlink loop */
*inos = 0;
return NULL;
}
pp = path = strdup(p);
if (*path == '/') {
path++;
ino = 1;
}
if (ino > 1) {
dir = resolveinode(o, size, ino);
ino = DIRENT_INO(dir);
}
next = path - 1;
while (ino && next != NULL && next[1] != 0 && d) {
path = next + 1;
next = strchr(path, '/');
if (next != NULL)
*next = 0;
if (*path == '.' && path[1] == 0)
continue;
if (*path == '.' && path[1] == '.' && path[2] == 0) {
if (DIRENT_PINO(dir) == 1) {
ino = 1;
dir = NULL;
} else {
dir = resolveinode(o, size, DIRENT_PINO(dir));
ino = DIRENT_INO(dir);
}
continue;
}
dir = resolvename(o, size, ino, path, (uint8_t) strlen(path));
if (DIRENT_INO(dir) == 0 ||
(next != NULL &&
!(dir->type == DT_DIR || dir->type == DT_LNK))) {
free(pp);
*inos = 0;
return NULL;
}
if (dir->type == DT_LNK) {
struct jffs2_raw_inode *ri;
ri = find_raw_inode(o, size, DIRENT_INO(dir));
putblock(symbuf, sizeof(symbuf), &symsize, ri);
symbuf[symsize] = 0;
tino = ino;
ino = 0;
dir = resolvepath0(o, size, tino, symbuf, &ino, ++recc);
if (dir != NULL && next != NULL &&
!(dir->type == DT_DIR || dir->type == DT_LNK)) {
free(pp);
*inos = 0;
return NULL;
}
}
if (dir != NULL)
ino = DIRENT_INO(dir);
}
free(pp);
*inos = ino;
return dir;
}
void printdir(char *o, size_t size, struct dir *d, const char *path, int recurse,
int want_ctime)
{
char m;
char *filetime;
time_t age;
struct jffs2_raw_inode *ri;
jint32_t mode;
if (!path)
return;
if (strlen(path) == 1 && *path == '/')
path++;
while (d != NULL) {
switch (d->type) {
case DT_REG:
m = ' ';
break;
case DT_FIFO:
m = '|';
break;
case DT_CHR:
m = ' ';
break;
case DT_BLK:
m = ' ';
break;
case DT_DIR:
m = '/';
break;
case DT_LNK:
m = ' ';
break;
case DT_SOCK:
m = '=';
break;
default:
m = '?';
}
ri = find_raw_inode(o, size, d->ino);
if (!ri) {
warnmsg("bug: raw_inode missing!");
d = d->next;
continue;
}
filetime = ctime((const time_t *) &(ri->ctime));
age = time(NULL) - je32_to_cpu(ri->ctime);
mode.v32 = ri->mode.m;
printf("%s %-4d %-8d %-8d ", mode_string(je32_to_cpu(mode)),
1, je16_to_cpu(ri->uid), je16_to_cpu(ri->gid));
if ( d->type==DT_BLK || d->type==DT_CHR ) {
dev_t rdev;
size_t devsize;
putblock((char*)&rdev, sizeof(rdev), &devsize, ri);
printf("%4d, %3d ", major(rdev), minor(rdev));
} else {
printf("%9ld ", (long)je32_to_cpu(ri->dsize));
}
d->name[d->nsize]='\0';
if (want_ctime) {
if (age < 3600L * 24 * 365 / 2 && age > -15 * 60)
/* hh:mm if less than 6 months old */
printf("%6.6s %5.5s ", filetime + 4, filetime + 11);
else
printf("%6.6s %4.4s ", filetime + 4, filetime + 20);
}
printf("%s/%s%c", path, d->name, m);
if (d->type == DT_LNK) {
char symbuf[1024];
size_t symsize;
putblock(symbuf, sizeof(symbuf), &symsize, ri);
symbuf[symsize] = 0;
printf(" -> %s", symbuf);
}
printf("\n");
if (d->type == DT_DIR && recurse) {
char *tmp;
tmp = xmalloc(BUFSIZ);
sprintf(tmp, "%s/%s", path, d->name);
lsdir(o, size, tmp, recurse, want_ctime); /* Go recursive */
free(tmp);
}
d = d->next;
}
}
static int
checkhash(char *name, struct hashinfo *hinfo)
{
uint32_t i, inbad, badstart, badsize, reportbad;
uint32_t badhashes, badchunks, lastbadchunk;
uint64_t badhashdata;
struct hashregion *reg;
int hashlen, chunkno;
unsigned char hash[HASH_MAXSIZE];
unsigned char *(*hashfunc)(const unsigned char *, unsigned long,
unsigned char *);
char *hashstr;
readbuf_t *rbuf;
size_t size;
#ifdef TIMEIT
u_int64_t sstamp, estamp;
#endif
if (startreader(name, hinfo))
return -1;
chunkno = lastbadchunk = -1;
badhashes = badchunks = inbad = reportbad = 0;
badhashdata = 0;
badstart = badsize = ~0;
switch (hinfo->hashtype) {
case HASH_TYPE_MD5:
default:
hashlen = 16;
hashfunc = MD5;
hashstr = "MD5";
break;
case HASH_TYPE_SHA1:
hashlen = 20;
hashfunc = SHA1;
hashstr = "SHA1";
break;
}
fprintf(stderr, "Checking disk contents using %s digest\n", hashstr);
for (i = 0, reg = hinfo->regions; i < hinfo->nregions; i++, reg++) {
if (chunkno != reg->chunkno) {
nchunks++;
chunkno = reg->chunkno;
}
size = sectobytes(reg->region.size);
rbuf = getblock(reg);
#ifdef TIMEIT
sstamp = rdtsc();
#endif
(void)(*hashfunc)(rbuf->data, size, hash);
#ifdef TIMEIT
estamp = rdtsc();
hcycles += (estamp - sstamp);
#endif
putblock(rbuf);
ndatabytes += size;
if (detail > 2) {
printf("[%u-%u]:\n", reg->region.start,
reg->region.start + reg->region.size - 1);
printf(" sig %s\n", spewhash(reg->hash));
printf(" disk %s\n", spewhash(hash));
}
if (memcmp(reg->hash, hash, hashlen) == 0) {
/*
* Hash is good.
* If we were in a bad stretch, be sure to dump info
*/
if (inbad)
reportbad = 1;
} else {
/*
* Hash is bad.
* If not already in a bad stretch, start one.
* If in a bad stretch, lengthen it if contig.
* Otherwise, dump the info.
*/
badhashes++;
if (chunkno != lastbadchunk) {
badchunks++;
lastbadchunk = chunkno;
}
badhashdata += size;
if (!inbad) {
inbad = 1;
badstart = reg->region.start;
badsize = reg->region.size;
} else {
if (badstart + badsize == reg->region.start)
badsize += reg->region.size;
else
reportbad = 1;
}
}
#ifdef TIMEIT
sstamp = rdtsc();
ccycles += (sstamp - estamp);
#endif
/*
* Report on a bad stretch
*/
if (reportbad) {
if (detail)
fprintf(stderr, "%s: bad hash [%u-%u]\n",
name, badstart, badstart + badsize - 1);
reportbad = inbad = 0;
}
}
/*
* Finished on a sour note, report the final bad stretch.
*/
if (inbad && detail)
fprintf(stderr, "%s: bad hash [%u-%u]\n",
name, badstart, badstart + badsize - 1);
stopreader();
nhregions = hinfo->nregions;
printf("%s: %lu chunks, %lu hashregions, %qu data bytes\n",
name, nchunks, nhregions, ndatabytes);
if (badhashes)
printf("%s: %u regions (%d chunks) had bad hashes, "
"%qu bytes affected\n",
name, badhashes, badchunks, badhashdata);
dump_readbufs();
#ifdef TIMEIT
printf("%qu bytes: read cycles: %qu, hash cycles: %qu, cmp cycles: %qu\n",
ndatabytes, rcycles, hcycles, ccycles);
#endif
return 0;
}
LLIOPipe::EStatus LLHTTPPipe::process_impl(
const LLChannelDescriptors& channels,
buffer_ptr_t& buffer,
bool& eos,
LLSD& context,
LLPumpIO* pump)
{
PUMP_DEBUG;
lldebugs << "LLSDHTTPServer::process_impl" << llendl;
// Once we have all the data, We need to read the sd on
// the the in channel, and respond on the out channel
if(!eos) return STATUS_BREAK;
if(!pump || !buffer) return STATUS_PRECONDITION_NOT_MET;
PUMP_DEBUG;
if (mState == STATE_INVOKE)
{
PUMP_DEBUG;
mState = STATE_DELAYED;
// assume deferred unless mResponse does otherwise
mResponse = Response::create(this);
// *TODO: Babbage: Parameterize parser?
// *TODO: We should look at content-type and do the right
// thing. Phoenix 2007-12-31
LLBufferStream istr(channels, buffer.get());
static LLTimer timer;
timer.reset();
std::string verb = context[CONTEXT_REQUEST][CONTEXT_VERB];
if(verb == HTTP_VERB_GET)
{
LLPerfBlock getblock("http_get");
mNode.get(LLHTTPNode::ResponsePtr(mResponse), context);
}
else if(verb == HTTP_VERB_PUT)
{
LLPerfBlock putblock("http_put");
LLSD input;
LLSDSerialize::fromXML(input, istr);
mNode.put(LLHTTPNode::ResponsePtr(mResponse), context, input);
}
else if(verb == HTTP_VERB_POST)
{
LLPerfBlock postblock("http_post");
LLSD input;
LLSDSerialize::fromXML(input, istr);
mNode.post(LLHTTPNode::ResponsePtr(mResponse), context, input);
}
else if(verb == HTTP_VERB_DELETE)
{
LLPerfBlock delblock("http_delete");
mNode.del(LLHTTPNode::ResponsePtr(mResponse), context);
}
else if(verb == HTTP_VERB_OPTIONS)
{
mNode.options(LLHTTPNode::ResponsePtr(mResponse), context);
}
else
{
mResponse->methodNotAllowed();
}
F32 delta = timer.getElapsedTimeF32();
if (sTimingCallback)
{
LLHTTPNode::Description desc;
mNode.describe(desc);
LLSD info = desc.getInfo();
std::string timing_name = info["description"];
timing_name += " ";
timing_name += verb;
sTimingCallback(timing_name.c_str(), delta, sTimingCallbackData);
}
// Log all HTTP transactions.
// TODO: Add a way to log these to their own file instead of indra.log
// It is just too spammy to be in indra.log.
lldebugs << verb << " " << context[CONTEXT_REQUEST]["path"].asString()
<< " " << mStatusCode << " " << mStatusMessage << " " << delta
<< "s" << llendl;
// Log Internal Server Errors
//if(mStatusCode == 500)
//{
// llwarns << "LLHTTPPipe::process_impl:500:Internal Server Error"
// << llendl;
//}
}
PUMP_DEBUG;
switch (mState)
{
case STATE_DELAYED:
lockChain(pump);
mState = STATE_LOCKED;
return STATUS_BREAK;
case STATE_LOCKED:
// should never ever happen!
return STATUS_ERROR;
case STATE_GOOD_RESULT:
{
LLSD headers = mHeaders;
headers["Content-Type"] = "application/llsd+xml";
context[CONTEXT_RESPONSE][CONTEXT_HEADERS] = headers;
LLBufferStream ostr(channels, buffer.get());
LLSDSerialize::toXML(mGoodResult, ostr);
return STATUS_DONE;
}
case STATE_STATUS_RESULT:
{
LLSD headers = mHeaders;
headers["Content-Type"] = "text/plain";
context[CONTEXT_RESPONSE][CONTEXT_HEADERS] = headers;
context[CONTEXT_RESPONSE]["statusCode"] = mStatusCode;
context[CONTEXT_RESPONSE]["statusMessage"] = mStatusMessage;
LLBufferStream ostr(channels, buffer.get());
ostr << mStatusMessage << std::ends;
return STATUS_DONE;
}
default:
llwarns << "LLHTTPPipe::process_impl: unexpected state "
<< mState << llendl;
return STATUS_BREAK;
}
// PUMP_DEBUG; // unreachable
}
