void UserManagementAPI::handleUserResetPasswordPost(HttpRequest &request, HttpResponse &response)
{
    QByteArray rawData = request.getRawData();
    QJsonParseError error;
    QJsonDocument data = QJsonDocument::fromJson(rawData, &error);

    if (error.error != QJsonParseError::NoError)
    {
        respondJsonParseError(response, error);
        return;
    }

    QJsonObject dataObject = data.object();

    //not checking if user is activated or not here might be ok.
    //because this api call has to be sent from the ui, as it needs recaptcha
    //and the ui checks if user is activated

    if (dataObject.contains("email") && dataObject.contains("password")
            && dataObject.contains("g_recaptcha_response"))
    {

        QString email = dataObject["email"].toString();
        QByteArray password = dataObject["password"].toString().toLatin1();
        QString g_recaptcha_response = dataObject["g_recaptcha_response"].toString();

        if (!ReCAPTCHAVerifier::getSingleton().verify(g_recaptcha_response, request.getFromIPAddress()))
        {
            respond(response, StatusCode::reCAPTCHAFailed, "reCAPTCHA check failed!");
            return;
        }

        if (dataObject.contains("reset_code"))
        {
            QByteArray reset_code = dataObject["reset_code"].toString().toLatin1();
            QString errorMessage;
            if (!m_userManager.resetPassword(email, password, reset_code, false, errorMessage))
            {
                respond(response, StatusCode::PasswordResetFailed, "Password reset failed: " % errorMessage);
            }
        }
        else if(dataObject.contains("old_password"))
        {
            QByteArray old_password = dataObject["old_password"].toString().toLatin1();
            QString errorMessage;

            if (!m_userManager.resetPassword(email, password, old_password, true, errorMessage))
            {
                respond(response, StatusCode::PasswordResetFailed, "Password reset failed: " % errorMessage);
            }
        }
        else
        {
            respondParameterMissing(response);
        }

        respondSuccess(response);
    }
    else
    {
        respondParameterMissing(response);
    }
}

void follow_master(void) {
   object *objs;
   int i;
   int nMasterHere;

   nMasterHere = 0;
   objs = query_environment()->query_inventory();
   for (i = 0; i < sizeof(objs); i++) {
      if (objs[i] == master) {
         nMasterHere = 1;
      }
   }

   if (nMasterHere == 0) {
      if (!master) {
         remove_call_out(nFollow);
         respond("say It seems " + master_name +
            " no longer has a need for me.");
         die();
         destruct_object(this_object());
         return;
      }
      if (query_environment() != master->query_environment()) {
         switch (random(10)) {
            case 0:
               query_environment()->tell_room(nil, my_name + " leaves.");
               break;
            case 1:
               query_environment()->tell_room(nil, my_name +
                  " tries to follow his master.");
               break;
            case 2:
               query_environment()->tell_room(nil,
                  my_name + " follows his master.");
               break;
            case 3:
               query_environment()->tell_room(nil, my_name +
                  " disappears in a cloud of smoke.");
               break;
            case 4:
               query_environment()->tell_room(nil,
                  my_name + " suddenly vanishes.");
               break;
            case 5:
               query_environment()->tell_room(nil,
                  my_name + " fades out of view.");
               break;
            case 6:
               query_environment()->tell_room(nil, my_name +
                  " runs off after his master.");
               break;
            case 7:
               query_environment()->tell_room(nil, my_name +
                  " suddenly notices that his master has left, and runs off.");
               break;
            case 8:
               query_environment()->tell_room(nil, my_name +
                  " fades into the shadows, and is gone.");
               break;
            case 9:
               query_environment()->tell_room(nil, my_name +
                  " snaps his fingers, and is gone.");
               break;
         }

         move(master->query_environment()->base_name());
         switch (random(10)) {
            case 0:
               query_environment()->tell_room(nil, my_name +
                  " follows the light of his life.");
               break;
            case 1:
               query_environment()->tell_room(nil, my_name +
                  " follows in his masters footsteps.");
               break;
            case 2:
               query_environment()->tell_room(nil, my_name +
                  " appears next to his master in a cloud of smoke.");
               break;
            case 3:
               query_environment()->tell_room(nil, my_name + " enters.");
               break;
            case 4:
               query_environment()->tell_room(nil, my_name + " appears.");
               break;
            case 5:
               query_environment()->tell_room(nil, my_name +
                  " arrives shortly after his master.");
               break;
            case 6:
               query_environment()->tell_room(nil, my_name +
                  " comes running, tying to keep up with his master.");
               break;
            case 7:
               query_environment()->tell_room(nil, "A humble page enters.");
               break;
            case 8:
               query_environment()->tell_room(nil,
                  "A humble person wearing a robe enters.");
               break;
//.........这里部分代码省略.........

void TabletServer::mainScreen(QTcpSocket *socket, const QStringList &path, const QStringMap &query)
{
    Document * doc = mw->currentDocument();
    if(!doc)
    {
        generic404(socket,path,query);
        return;
    }

    QStringList pathCopy = path;
    pathCopy.takeFirst(); // should be "tablet", but could be anything - /tablet/ is canonized for use in the tablet cache manifest for sfari
    QString control = pathCopy.isEmpty() ? "" : pathCopy.takeFirst().toLower();
    //bool flag = pathCopy.isEmpty() ? 0 : pathCopy.takeFirst().toInt();

    //qDebug() << "TabletServer::mainScreen(): control: "<<control;

    HttpUser *user = HttpUserUtil::instance()->currentUser();

    if(control != "login")
    {
        if(!user)
        {
            QString from = QUrl::toPercentEncoding(toPathString(path,query).toAscii()).replace(" ", "+");
            redirect(socket, "/tablet/login?from=" + from);
            return;
        }

        // I've decided to allow guests "view-only" access

// 		else
// 		if(user->level() == HttpUser::Guest)
// 		{
// 			Http_Send_Ok(socket) << "<html><head><title>Not Allowed</title></head><body><h1>Not Allowed</h1>Sorry, you're not allowed to access this site. (<a href='/tablet/login'>Login again</a>)</body></html";
// 			return;
// 		}
    }

    if(control.isEmpty())
    {

        SimpleTemplate tmpl("data/http/tablet.tmpl");
        tmpl.param("user_name", user->user());
        tmpl.param("user_level", (int)user->level());
        tmpl.param("is_admin", user->level() == HttpUser::Admin);
        tmpl.param("is_user",  user->level() == HttpUser::User);
        tmpl.param("is_guest", user->level() == HttpUser::Guest);

// 		tmpl.param("list",outputGroupList);
//
// 		OutputControl * outputControl = mw->outputControl(liveId);
// 		tmpl.param("black_toggled", outputControl->isBlackToggled());
// 		tmpl.param("clear_toggled", outputControl->isClearToggled());
//
// 		SlideGroupViewControl *viewControl = mw->viewControl(liveId);
// 		tmpl.param("qslide_toggled", viewControl->isQuickSlideToggled());
//
// 		if(doc->filename().isEmpty())
// 			tmpl.param("docfile",tr("New File"));
// 		else
// 			tmpl.param("docfile",QFileInfo(doc->filename()).baseName());

        // 	Http_Send_Ok(socket) <<
        // 		"Content-Type: text/html\n\n" <<
        // 		tmpl.toString();

        QHttpResponseHeader header(QString("HTTP/1.0 200 OK"));
        header.setValue("Content-Type", "text/html");

        respond(socket, header);

        QTextStream output(socket);
        output.setAutoDetectUnicode(true);
        output << tmpl.toString();
    }
    else if(control == "login")
    {
        loginPage(socket, path, query, "/tablet/login");
    }
    else if(control == "list")
    {
        QString filter = query["filter"]; // Can be empty

        // Don't allow non-admins to search because it would interfere with the main UI
        if(!filter.isEmpty() &&
                user->level() < HttpUser::Admin)
        {
            Http_Send_500txt(socket, "Not Authorized");
            return;
        }

        QString mode   = query["mode"]; // Either "db" or "file"

        bool pollingFlag  = query["poll"] == "true";
        QString clientMD5 = query["md5"]; // the md5 of the list contents to use to check for changes if pollingFlag == true

        // Compile list of results matching mode (from db or from current sched) and the filter, and return as json string

        // TODO add button to search online

        //qDebug() << "TabletServer::mainScreen(): list: mode: "<<mode<<", filter: "<<filter;
//.........这里部分代码省略.........

void Client::componentComplete()
{
    server = Server::server(m_connectionName);
    connect(server, SIGNAL(respond(QVariantMap)), this, SIGNAL(respond(QVariantMap)));
}

static void
fsopen(Req *r)
{
	int t;
	uvlong path;
	Aux *a;
	Fid *fid;
	Whist *wh;

	fid = r->fid;
	path = fid->qid.path;
	t = qidtype(fid->qid.path);
	if((r->ifcall.mode != OREAD && t != Fnew && t != Fmap)
	|| (r->ifcall.mode&ORCLOSE)){
		respond(r, "permission denied");
		return;
	}

	a = fid->aux;
	switch(t){
	case Droot:
		currentmap(0);
		rlock(&maplock);
		a->map = map;
		incref(map);
		runlock(&maplock);
		respond(r, nil);
		break;
		
	case D1st:
		if((wh = gethistory(qidnum(path))) == nil){
			respond(r, "file does not exist");
			return;
		}
		closewhist(a->w);
		a->w = wh;
		a->n = a->w->ndoc-1;
		r->ofcall.qid.vers = wh->doc[a->n].time;
		r->fid->qid = r->ofcall.qid;
		respond(r, nil);
		break;
		
	case D2nd:
		respond(r, nil);
		break;

	case Fnew:
		a->s = s_copy("");
		respond(r, nil);
		break;

	case Fmap:
	case F1st:
	case F2nd:
		respond(r, nil);
		break;

	default:
		respond(r, "programmer error");
		break;
	}
}

void
ctlwrite(Req *r)
{
	int i;
	Cmdbuf *cb;
	vlong start, end;

	r->ofcall.count = r->ifcall.count;
	cb = parsecmd(r->ifcall.data, r->ifcall.count);
	if(cb->nf < 1){
		respond(r, "empty control message");
		free(cb);
		return;
	}

	if(strcmp(cb->f[0], "part") == 0){
		if(cb->nf != 4){
			respondcmderror(r, cb, "part takes 3 args");
			free(cb);
			return;
		}
		start = strtoll(cb->f[2], 0, 0);
		end = strtoll(cb->f[3], 0, 0);
		if(addpart(cb->f[1], start, end) < 0){
			respondcmderror(r, cb, "%r");
			free(cb);
			return;
		}
	}
	else if(strcmp(cb->f[0], "delpart") == 0){
		if(cb->nf != 2){
			respondcmderror(r, cb, "delpart takes 1 arg");
			free(cb);
			return;
		}
		if(delpart(cb->f[1]) < 0){
			respondcmderror(r, cb, "%r");
			free(cb);
			return;
		}
	}
	else if(strcmp(cb->f[0], "inquiry") == 0){
		if(cb->nf != 2){
			respondcmderror(r, cb, "inquiry takes 1 arg");
			free(cb);
			return;
		}
		free(inquiry);
		inquiry = estrdup9p(cb->f[1]);
	}
	else if(strcmp(cb->f[0], "geometry") == 0){
		if(cb->nf != 6){
			respondcmderror(r, cb, "geometry takes 5 args");
			free(cb);
			return;
		}
		nsect = strtoll(cb->f[1], 0, 0);
		sectsize = strtoll(cb->f[2], 0, 0);
		c = strtoll(cb->f[3], 0, 0);
		h = strtoll(cb->f[4], 0, 0);
		s = strtoll(cb->f[5], 0, 0);
		if(tab[0].inuse && strcmp(tab[0].name, "data") == 0 && tab[0].vers == 0){
			tab[0].offset = 0;
			tab[0].length = nsect;
		}
		for(i=0; i<nelem(tab); i++){
			if(tab[i].inuse && tab[i].offset+tab[i].length > nsect){
				tab[i].inuse = 0;
				free(tab[i].name);
				tab[i].name = 0;
			}
		}
	}
	else{
		respondcmderror(r, cb, "unknown control message");
		free(cb);
		return;
	}

	free(cb);
	respond(r, nil);
}

	void respondError(int code, const QString &status, const QString &errorString)
	{
		respond(code, status, errorString.toUtf8() + '\n');
	}

// no operation; only responds
void noop(char **params, short *abor, int fd,
	struct state *cstate, struct config *configuration) {
	respond(fd, 2, 2, 0, "OK.");
}

int ConnectionHandler::doCommand(QCString buf)
{
    if((uid_t)peerUid() != getuid())
    {
        kdWarning(1205) << "Peer uid not equal to me\n";
        kdWarning(1205) << "Peer: " << peerUid() << " Me: " << getuid() << endl;
        return -1;
    }

    QCString key, command, pass, name, user, value, env_check;
    Data_entry data;

    Lexer *l = new Lexer(buf);
    int tok = l->lex();
    switch(tok)
    {
        case Lexer::Tok_pass: // "PASS password:string timeout:int\n"
            tok = l->lex();
            if(tok != Lexer::Tok_str)
                goto parse_error;
            m_Pass.fill('x');
            m_Pass = l->lval();
            tok = l->lex();
            if(tok != Lexer::Tok_num)
                goto parse_error;
            m_Timeout = l->lval().toInt();
            if(l->lex() != '\n')
                goto parse_error;
            if(m_Pass.isNull())
                m_Pass = "";
            kdDebug(1205) << "Password set!\n";
            respond(Res_OK);
            break;

        case Lexer::Tok_host: // "HOST host:string\n"
            tok = l->lex();
            if(tok != Lexer::Tok_str)
                goto parse_error;
            m_Host = l->lval();
            if(l->lex() != '\n')
                goto parse_error;
            kdDebug(1205) << "Host set to " << m_Host << endl;
            respond(Res_OK);
            break;

        case Lexer::Tok_prio: // "PRIO priority:int\n"
            tok = l->lex();
            if(tok != Lexer::Tok_num)
                goto parse_error;
            m_Priority = l->lval().toInt();
            if(l->lex() != '\n')
                goto parse_error;
            kdDebug(1205) << "priority set to " << m_Priority << endl;
            respond(Res_OK);
            break;

        case Lexer::Tok_sched: // "SCHD scheduler:int\n"
            tok = l->lex();
            if(tok != Lexer::Tok_num)
                goto parse_error;
            m_Scheduler = l->lval().toInt();
            if(l->lex() != '\n')
                goto parse_error;
            kdDebug(1205) << "Scheduler set to " << m_Scheduler << endl;
            respond(Res_OK);
            break;

        case Lexer::Tok_exec: // "EXEC command:string user:string [options:string (env:string)*]\n"
        {
            QCString options;
            KStringList env;
            tok = l->lex();
            if(tok != Lexer::Tok_str)
                goto parse_error;
            command = l->lval();
            tok = l->lex();
            if(tok != Lexer::Tok_str)
                goto parse_error;
            user = l->lval();
            tok = l->lex();
            if(tok != '\n')
            {
                if(tok != Lexer::Tok_str)
                    goto parse_error;
                options = l->lval();
                tok = l->lex();
                while(tok != '\n')
                {
                    if(tok != Lexer::Tok_str)
                        goto parse_error;
                    QCString env_str = l->lval();
                    env.append(env_str);
                    if(strncmp(env_str, "DESKTOP_STARTUP_ID=", strlen("DESKTOP_STARTUP_ID=")) != 0)
                        env_check += "*" + env_str;
                    tok = l->lex();
                }
            }

            QCString auth_user;
            if((m_Scheduler != SuProcess::SchedNormal) || (m_Priority > 50))
//.........这里部分代码省略.........

// system info
void syst(char **params, short *abor, int fd,
	struct state *cstate, struct config *configuration) {
	respond(fd, 2, 1, 5, "UNIX Type: L8");
}

// should give information about unusual commands supported by the server
void feat(char **params, short *abor, int fd,
	struct state *cstate, struct config *configuration) {
	respond(fd, 2, 1, 1, "Sorry.");
	write(fd, "NONE", 4);
	respond(fd, 2, 1, 1, "end");
}

// disconnects from the server
void quit(char **params, short *abor, int fd,
	struct state *cstate, struct config *configuration) {
	pthread_detach(cstate->data_thread);
	respond(fd, 2, 2, 1, "Closing connection.");
	*abor = 1;
}

static
Xfid*
fsysread(Xfid *x, Fid *f)
{
	Fcall t;
	uchar *b;
	int i, id, n, o, e, j, k, *ids, nids;
	Dirtab *d, dt;
	Column *c;
	uint clock, len;
	char buf[16];

	if(f->qid.type & QTDIR){
		if(FILE(f->qid) == Qacme){	/* empty dir */
			t.data = nil;
			t.count = 0;
			respond(x, &t, nil);
			return x;
		}
		o = x->fcall.offset;
		e = x->fcall.offset+x->fcall.count;
		clock = getclock();
		b = emalloc(messagesize);
		id = WIN(f->qid);
		n = 0;
		if(id > 0)
			d = dirtabw;
		else
			d = dirtab;
		d++;	/* first entry is '.' */
		for(i=0; d->name!=nil && i<e; i+=len){
			len = dostat(WIN(x->f->qid), d, b+n, x->fcall.count-n, clock);
			if(len <= BIT16SZ)
				break;
			if(i >= o)
				n += len;
			d++;
		}
		if(id == 0){
			qlock(&row.lk);
			nids = 0;
			ids = nil;
			for(j=0; j<row.ncol; j++){
				c = row.col[j];
				for(k=0; k<c->nw; k++){
					ids = realloc(ids, (nids+1)*sizeof(int));
					ids[nids++] = c->w[k]->id;
				}
			}
			qunlock(&row.lk);
			qsort(ids, nids, sizeof ids[0], idcmp);
			j = 0;
			dt.name = buf;
			for(; j<nids && i<e; i+=len){
				k = ids[j];
				sprint(dt.name, "%d", k);
				dt.qid = QID(k, Qdir);
				dt.type = QTDIR;
				dt.perm = DMDIR|0700;
				len = dostat(k, &dt, b+n, x->fcall.count-n, clock);
				if(len == 0)
					break;
				if(i >= o)
					n += len;
				j++;
			}
			free(ids);
		}
		t.data = (char*)b;
		t.count = n;
		respond(x, &t, nil);
		free(b);
		return x;
	}
	sendp(x->c, (void*)xfidread);
	return nil;
}

static
Xfid*
fsyswalk(Xfid *x, Fid *f)
{
	Fcall t;
	int c, i, j, id;
	Qid q;
	uchar type;
	ulong path;
	Fid *nf;
	Dirtab *d, *dir;
	Window *w;
	char *err;

	nf = nil;
	w = nil;
	if(f->open)
		return respond(x, &t, "walk of open file");
	if(x->fcall.fid != x->fcall.newfid){
		nf = newfid(x->fcall.newfid);
		if(nf->busy)
			return respond(x, &t, "newfid already in use");
		nf->busy = TRUE;
		nf->open = FALSE;
		nf->mntdir = f->mntdir;
		if(f->mntdir)
			f->mntdir->ref++;
		nf->dir = f->dir;
		nf->qid = f->qid;
		nf->w = f->w;
		nf->nrpart = 0;	/* not open, so must be zero */
		if(nf->w)
			incref(&nf->w->ref);
		f = nf;	/* walk f */
	}

	t.nwqid = 0;
	err = nil;
	dir = nil;
	id = WIN(f->qid);
	q = f->qid;

	if(x->fcall.nwname > 0){
		for(i=0; i<x->fcall.nwname; i++){
			if((q.type & QTDIR) == 0){
				err = Enotdir;
				break;
			}

			if(strcmp(x->fcall.wname[i], "..") == 0){
				type = QTDIR;
				path = Qdir;
				id = 0;
				if(w){
					winclose(w);
					w = nil;
				}
    Accept:
				if(i == MAXWELEM){
					err = "name too long";
					break;
				}
				q.type = type;
				q.vers = 0;
				q.path = QID(id, path);
				t.wqid[t.nwqid++] = q;
				continue;
			}

			/* is it a numeric name? */
			for(j=0; (c=x->fcall.wname[i][j]); j++)
				if(c<'0' || '9'<c)
					goto Regular;
			/* yes: it's a directory */
			if(w)	/* name has form 27/23; get out before losing w */
				break;
			id = atoi(x->fcall.wname[i]);
			qlock(&row.lk);
			w = lookid(id, FALSE);
			if(w == nil){
				qunlock(&row.lk);
				break;
			}
			incref(&w->ref);	/* we'll drop reference at end if there's an error */
			path = Qdir;
			type = QTDIR;
			qunlock(&row.lk);
			dir = dirtabw;
			goto Accept;
	
    Regular:
			if(strcmp(x->fcall.wname[i], "new") == 0){
				if(w)
					error("w set in walk to new");
				sendp(cnewwindow, nil);	/* signal newwindowthread */
				w = recvp(cnewwindow);	/* receive new window */
				incref(&w->ref);
				type = QTDIR;
				path = QID(w->id, Qdir);
				id = w->id;
//.........这里部分代码省略.........

string Kernel::respond(const string &input, const string &id, Responder *r, bool srai, const string &prefix) {
	return respond(input, id, r, 1, srai, prefix);
}

/* This parser is rather liberal in what it accepts:
   The IMAP standard mandates seperate character sets for tags, commands,
   unquoted strings.  Since they all must be seperated by spaces, this
   parser allows all non-whitespace characters for each of the above. */
static int parse_line(void)
{
#define RESPOND(T,S) do{ respond(T,S); return 0; }while(0)
  unsigned i;
  unsigned len;
  const char* ptr;
  str* arg;
  
  /* Parse out the command tag */
  str_truncate(&tag, 0);
  for (i = 0, ptr = line.s; i < line.len && isspace(*ptr); ++i, ++ptr) ;
  for (; i < line.len && !isspace(*ptr); ++i, ++ptr)
    str_catc(&tag, line.s[i]);
  if (!tag.len) RESPOND(NOTAG, "BAD Syntax error");
  if (i >= line.len) RESPOND(0, "BAD Syntax error");

  /* Parse out the command itself */
  str_truncate(&cmd, 0);
  for (; i < line.len && isspace(*ptr); ++i, ++ptr) ;
  for (; i < line.len && !isspace(*ptr); ++i, ++ptr)
    str_catc(&cmd, line.s[i]);
  if (!cmd.len) RESPOND(0, "BAD Syntax error");

  /* Parse out the command-line args */
  for (line_argc = 0; line_argc < MAX_ARGC; ++line_argc) {
    arg = &line_args[line_argc];
    str_truncate(arg, 0);
    for (; i < line.len && isspace(*ptr); ++i, ++ptr) ;
    if (i >= line.len) break;

    switch (*ptr) {
    case LBRACE:
      /* Handle a string literal */
      ++i, ++ptr;
      if (!isdigit(*ptr)) RESPOND(0, "BAD Syntax error: missing integer");
      for (len = 0; i < line.len && *ptr != RBRACE; ++i, ++ptr) {
	if (!isdigit(*ptr))
	  RESPOND(0, "BAD Syntax error: invalid integer");
	len = len * 10 + *ptr - '0';
      }
      ++i, ++ptr;
      if (*ptr != 0) RESPOND(0, "BAD Syntax error: missing LF after integer");
      str_ready(arg, len);
      respond(CONT, "OK");
      if (len > 0)
	ibuf_read(&inbuf, arg->s, len);
      arg->s[arg->len = len] = 0;
      ibuf_getstr_crlf(&inbuf, &line);
      i = 0;
      ptr = line.s;
      break;

    case QUOTE:
      /* Handle a quoted string */
      for (++i, ++ptr; i < line.len && *ptr != QUOTE; ++i, ++ptr) {
	if (*ptr == ESCAPE) {
	  if (++i >= line.len) break;
	  ++ptr;
	}
	str_catc(arg, *ptr);
      }
      if (i >= line.len || *ptr != QUOTE)
	RESPOND(0, "BAD Syntax error: unterminated quoted string");
      ++i, ++ptr;
      break;

    default:
      /* Normal case is very simple */
      for (; i < line.len && !isspace(*ptr); ++i, ++ptr)
	str_catc(arg, *ptr);
    }
  }
  for (; i < line.len && isspace(*ptr); ++i, ++ptr) ;
  if (i < line.len) RESPOND(0, "BAD Too many command arguments");
  return 1;
}

RequestHandler::RequestHandler(string m,QTcpSocket* client,DatabaseController &db){
     msg =m;
     respond(client,db);
}

void cmd_noop(void)
{
  respond(0, "OK NOOP completed");
}

int
rdwrpart(Req *r)
{
	int q, nonzero;
	Part *p;
	vlong offset;
	long count, tot, n, o;
	uchar *blk, *dat;
	void *(*move)(void*, void*, ulong);

	q = r->fid->qid.path-Qpart;
	if(q < 0 || q > nelem(tab) || !tab[q].inuse || tab[q].vers != r->fid->qid.vers){
		respond(r, "unknown partition");
		return -1;
	}

	p = &tab[q];
	offset = r->ifcall.offset;
	count = r->ifcall.count;
	if(offset < 0){
		respond(r, "negative offset");
		return -1;
	}
	if(count < 0){
		respond(r, "negative count");
		return -1;
	}
	if(offset > p->length*sectsize){
		respond(r, "offset past end of partition");
		return -1;
	}
	if(offset+count > p->length*sectsize)
		count = p->length*sectsize - offset;
	offset += p->offset*sectsize;

	if(r->ifcall.type == Tread)
		move = memmove;
	else
		move = evommem;

	tot = 0;
	nonzero = 1;
	if(r->ifcall.type == Tread)
		dat = (uchar*)r->ofcall.data;
	else{
		dat = (uchar*)r->ifcall.data;
		nonzero = isnonzero(dat, r->ifcall.count);
	}
	o = offset & (BLKSZ-1);

	/* left fringe block */
	if(o && count){
		blk = getblock(offset, r->ifcall.type==Twrite && nonzero);
		n = BLKSZ - o;
		if(n > count)
			n = count;
		if(r->ifcall.type != Twrite || blk != zero)
			(*move)(dat, blk+o, n);
		if(r->ifcall.type == Twrite)
			dirty(offset, blk);
		tot += n;
	}
	/* full and right fringe blocks */
	while(tot < count){
		blk = getblock(offset+tot, r->ifcall.type==Twrite && nonzero);
		n = BLKSZ;
		if(n > count-tot)
			n = count-tot;
		if(r->ifcall.type != Twrite || blk != zero)
			(*move)(dat+tot, blk, n);
		if(r->ifcall.type == Twrite)
			dirty(offset+tot, blk);
		tot += n;
	}
	r->ofcall.count = tot;
	respond(r, nil);
	return 0;
}

void cmd_logout(void)
{
  respond(NOTAG, "Logging out");
  respond(0, "OK LOGOUT completed");
  exit(0);
}