int
rdwrcheck(Req *r, Fsstate *fss)
{
if(fss->ps == nil){
retstring(r, fss, "error no current protocol");
return -1;
}
if(fss->phase == Notstarted){
retstring(r, fss, "protocol not started");
return -1;
}
if(fss->phase == Broken){
snprint(fss->rpc.buf, Maxrpc, "error %s", fss->err);
retstring(r, fss, fss->rpc.buf);
return -1;
}
if(fss->phase == Established){
if(fss->haveai)
retstring(r, fss, "done haveai");
else
retstring(r, fss, "done");
return -1;
}
return 0;
}
static int
HandleOP(AcquireCreds)
{
char *name, *password;
int32_t gsm_error, flags, handle = 0;
krb5_principal principal = NULL;
krb5_get_init_creds_opt *opt = NULL;
krb5_error_code ret;
retstring(c, name);
retstring(c, password);
ret32(c, flags);
logmessage(c, __FILE__, __LINE__, 0,
"username: %s password: %s", name, password);
ret = krb5_parse_name(context, name, &principal);
if (ret) {
gsm_error = convert_krb5_to_gsm(ret);
goto out;
}
ret = krb5_get_init_creds_opt_alloc (context, &opt);
if (ret)
krb5_err(context, 1, ret, "krb5_get_init_creds_opt_alloc");
krb5_get_init_creds_opt_set_pa_password(context, opt, password, NULL);
gsm_error = acquire_cred(c, principal, opt, &handle);
out:
logmessage(c, __FILE__, __LINE__, 0,
"AcquireCreds handle: %d return code: %d", handle, gsm_error);
if (opt)
krb5_get_init_creds_opt_free (context, opt);
if (principal)
krb5_free_principal(context, principal);
free(name);
free(password);
put32(c, gsm_error);
put32(c, handle);
return 0;
}
static int32_t
get_moniker(struct client *client,
char **moniker)
{
put32(client, eGetMoniker);
retstring(client, *moniker);
return GSMERR_OK;
}
static int
get_targetname(struct client *client,
char **target)
{
put32(client, eGetTargetName);
retstring(client, *target);
return GSMERR_OK;
}
static int32_t
get_version_capa(struct client *client,
int32_t *version, int32_t *capa,
char **version_str)
{
put32(client, eGetVersionAndCapabilities);
ret32(client, *version);
ret32(client, *capa);
retstring(client, *version_str);
return GSMERR_OK;
}
int main(int argc, char ** argv)
{
QHash<QString,WhitLocation> hash;
QCoreApplication app(argc,argv);
QFile input("listall");
QFile index("whitindex.cal");
QFile output("whitdefinitions.cal");
input.open(QFile::ReadOnly);
index.open(QFile::WriteOnly);
output.open(QFile::WriteOnly);
QTextStream is(&input);
QTextStream ins(&index);
QString line;
while(!is.atEnd())
{
line = is.readLine();
QProcess process;
QStringList args;
args.push_back(line);
process.start("./words", args);
process.waitForStarted();
process.write("\n\n\n\n\n");
process.waitForFinished();
QByteArray ret = process.readAllStandardOutput();
QString retstring(ret);
app.processEvents();
ins << line << endl;
ins << QString::number(output.pos()) << endl;
QByteArray outd = retstring.toUtf8();
ins << outd.length() << endl;
WhitLocation wl;
wl.pos = output.pos();
wl.len = outd.length();
line=line.remove("\n");
hash[line]=wl;
output.write(outd);
output.flush();
}
QFile output2("whitindexhash.cal");
output2.open(QFile::WriteOnly);
QDataStream qds(&output2);
qds << hash;
}
static void
retrpc(Req *r, int ret, Fsstate *fss)
{
switch(ret){
default:
snprint(fss->rpc.buf, Maxrpc, "internal error %d", ret);
retstring(r, fss, fss->rpc.buf);
return;
case RpcErrstr:
snprint(fss->rpc.buf, Maxrpc, "error %r");
retstring(r, fss, fss->rpc.buf);
return;
case RpcFailure:
snprint(fss->rpc.buf, Maxrpc, "error %s", fss->err);
retstring(r, fss, fss->rpc.buf);
return;
case RpcNeedkey:
if(needkeyqueue(r, fss) < 0){
snprint(fss->rpc.buf, Maxrpc, "needkey %s", fss->keyinfo);
retstring(r, fss, fss->rpc.buf);
}
return;
case RpcOk:
retstring(r, fss, "ok");
return;
case RpcToosmall:
snprint(fss->rpc.buf, Maxrpc, "toosmall %d", fss->rpc.nwant);
retstring(r, fss, fss->rpc.buf);
return;
case RpcPhase:
snprint(fss->rpc.buf, Maxrpc, "phase %r");
retstring(r, fss, fss->rpc.buf);
return;
case RpcConfirm:
confirmqueue(r, fss);
return;
}
}
void
rpcread(Req *r)
{
Attr *attr;
char *p;
int ophase, ret;
uint8_t *e;
uint count;
Fsstate *fss;
Proto *proto;
if(r->ifcall.count < 64){
respond(r, "rpc read too small");
return;
}
fss = r->fid->aux;
if(!fss->pending){
respond(r, "no rpc pending");
return;
}
switch(fss->rpc.iverb){
default:
case Vunknown:
retstring(r, fss, "error unknown verb");
break;
case Vstart:
if(fss->phase != Notstarted){
flog("%d: implicit close due to second start; old attr '%A'", fss->seqnum, fss->attr);
if(fss->proto && fss->ps)
(*fss->proto->close)(fss);
fss->ps = nil;
fss->proto = nil;
_freeattr(fss->attr);
fss->attr = nil;
fss->phase = Notstarted;
}
attr = _parseattr(fss->rpc.arg);
if((p = _strfindattr(attr, "proto")) == nil){
retstring(r, fss, "error did not specify proto");
_freeattr(attr);
break;
}
if((proto = findproto(p)) == nil){
snprint(fss->rpc.buf, Maxrpc, "error unknown protocol %q", p);
retstring(r, fss, fss->rpc.buf);
_freeattr(attr);
break;
}
fss->attr = attr;
fss->proto = proto;
fss->seqnum = ++seqnum;
ret = (*proto->init)(proto, fss);
rpcstartlog(attr, fss, ret);
if(ret != RpcOk){
_freeattr(fss->attr);
fss->attr = nil;
fss->phase = Notstarted;
}
retrpc(r, ret, fss);
break;
case Vread:
if(fss->rpc.arg && fss->rpc.arg[0]){
retstring(r, fss, "error read needs no parameters");
break;
}
if(rdwrcheck(r, fss) < 0)
break;
count = r->ifcall.count - 3;
ophase = fss->phase;
ret = fss->proto->read(fss, (uint8_t*)r->ofcall.data+3,
&count);
rpcrdwrlog(fss, "read", count, ophase, ret);
if(ret == RpcOk){
memmove(r->ofcall.data, "ok ", 3);
if(count == 0)
r->ofcall.count = 2;
else
r->ofcall.count = 3+count;
fss->pending = 0;
respond(r, nil);
}else
retrpc(r, ret, fss);
break;
case Vwrite:
if(rdwrcheck(r, fss) < 0)
break;
ophase = fss->phase;
ret = fss->proto->write(fss, fss->rpc.arg, fss->rpc.narg);
rpcrdwrlog(fss, "write", fss->rpc.narg, ophase, ret);
retrpc(r, ret, fss);
break;
case Vauthinfo:
if(fss->phase != Established){
retstring(r, fss, "error authentication unfinished");
break;
}
if(!fss->haveai){
retstring(r, fss, "error no authinfo available");
break;
}
memmove(r->ofcall.data, "ok ", 3);
fss->ai.cap = mkcap(r->fid->uid, fss->ai.suid);
e = convAI2M(&fss->ai, (uint8_t*)r->ofcall.data+3,
r->ifcall.count-3);
free(fss->ai.cap);
fss->ai.cap = nil;
if(e == nil){
retstring(r, fss, "error read too small");
break;
}
r->ofcall.count = e - (uint8_t*)r->ofcall.data;
fss->pending = 0;
respond(r, nil);
break;
case Vattr:
snprint(fss->rpc.buf, Maxrpc, "ok %A", fss->attr);
retstring(r, fss, fss->rpc.buf);
break;
}
}
