void set_up_ipv4_socket(const struct options *opt)
{
struct sockaddr_in serv_addr;
int ret, one = 1;
if (opt->tproto == PROTOCOL_TCP) {
journal("Setting up IPv4 socket over TCP...\n");
sockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
} else {
journal("Setting up IPv4 socket over UDP...\n");
sockfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
}
if (sockfd < 0) {
journal("Unable to create IPv4 socket: %s.\n", strerror(errno));
cleanup(EXIT_IO, true);
}
ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)(&one), sizeof(one));
if (ret < 0) {
journal("Unable to set the socket to allow address reuse: %s.\n", strerror(errno));
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(opt->port);
ret = bind(sockfd, (const struct sockaddr *)(&serv_addr), sizeof(struct sockaddr_in));
if (ret < 0) {
journal("Unable to bind to IPv4 socket: %s.\n", strerror(errno));
cleanup(EXIT_IO, true);
}
}
void udp_accept_connection(void)
{
struct sockaddr_in cli_addr;
socklen_t cli_len;
char *buffer;
size_t length;
int ret;
journal("Listening for connection...\n");
ret = recvfrom(sockfd, NULL, 0, 0, (struct sockaddr *)(&cli_addr), &cli_len);
if (unlikely(ret)) {
int errsave = errno;
ERR_TRACE();
journal("Unable to read from socket: %s.\n", strerror(errsave));
CHECK_SOCKET_ERROR(errsave);
}
cli_len = sizeof(cli_addr);
ret = get_quote_of_the_day(&buffer, &length);
if (unlikely(ret)) {
return;
}
ret = sendto(sockfd, buffer, length, 0, (struct sockaddr *)(&cli_addr), cli_len);
if (unlikely(ret < 0)) {
ERR_TRACE();
journal("Unable to write to UDP socket: %s.\n", strerror(errno));
return;
}
}
int main(int argc, char **argv)
{
if (argc <= 1)
{
std::cerr << "usage: " << argv[0] << " <file.joedb>\n";
return 1;
}
else
{
joedb::File file(argv[1], joedb::File::mode_t::read_existing);
if (!file.is_good())
{
std::cerr << "error: could not open file: " << argv[1] << '\n';
return 1;
}
joedb::Journal_File journal(file);
joedb::Dump_Listener dump_listener(std::cout);
journal.replay_log(dump_listener);
std::cout << "---> ";
static const char * status_string[] =
{
"no_error",
"bad_file",
"unsupported_version",
"bad_format",
"crash_check"
};
std::cout << status_string[int(journal.get_state())] << '\n';
}
return 0;
}
void
journaln(int out, long n)
{
char buf[32];
sprint(buf, sizeof (long) > 4 ? "%ld" : "%d", n);
journal(out, buf);
}
void
outstart(Hmesg type)
{
journal(1, hname[type]);
outmsg[0] = type;
outp = outmsg+3;
}
Akonadi::Item getErrorItem(Kolab::FolderType folderType, const QString &remoteId)
{
//TODO set title, text and icon
Akonadi::Item item;
item.setRemoteId(remoteId);
switch (folderType) {
case Kolab::EventType: {
KCalCore::Event::Ptr event(new KCalCore::Event);
//FIXME Use message creation date time
event->setDtStart(KDateTime::currentUtcDateTime());
event->setSummary(i18n("Corrupt Event"));
event->setDescription(i18n("Event could not be read. Delete this event to remove it from the server."));
item.setMimeType(KCalCore::Event::eventMimeType());
item.setPayload(event);
}
break;
case Kolab::TaskType: {
KCalCore::Todo::Ptr task(new KCalCore::Todo);
//FIXME Use message creation date time
task->setDtStart(KDateTime::currentUtcDateTime());
task->setSummary(i18n("Corrupt Task"));
task->setDescription(i18n("Task could not be read. Delete this task to remove it from the server."));
item.setMimeType(KCalCore::Todo::todoMimeType());
item.setPayload(task);
}
break;
case Kolab::JournalType: {
KCalCore::Journal::Ptr journal(new KCalCore::Journal);
//FIXME Use message creation date time
journal->setDtStart(KDateTime::currentUtcDateTime());
journal->setSummary(i18n("Corrupt journal"));
journal->setDescription(i18n("Journal could not be read. Delete this journal to remove it from the server."));
item.setMimeType(KCalCore::Journal::journalMimeType());
item.setPayload(journal);
}
break;
case Kolab::ContactType: {
KContacts::Addressee addressee;
addressee.setName(i18n("Corrupt Contact"));
addressee.setNote(i18n("Contact could not be read. Delete this contact to remove it from the server."));
item.setMimeType(KContacts::Addressee::mimeType());
item.setPayload(addressee);
}
break;
case Kolab::NoteType: {
Akonadi::NoteUtils::NoteMessageWrapper note;
note.setTitle(i18n("Corrupt Note"));
note.setText(i18n("Note could not be read. Delete this note to remove it from the server."));
item.setPayload(Akonadi::NoteUtils::noteMimeType());
item.setPayload(note.message());
}
break;
case Kolab::MailType:
//We don't convert mails, so that should never fail.
default:
qCWarning(KOLABRESOURCE_LOG) << "unhandled folder type: " << folderType;
}
return item;
}
void
journalv(int out, vlong v)
{
char buf[32];
snprint(buf, sizeof buf, "%lld", v);
journal(out, buf);
}
void
journaln(int out, long n)
{
char buf[32];
snprint(buf, sizeof buf, "%ld", n);
journal(out, buf);
}
CJournal::Ptr CJournal::create_from_file ( const std::string & name,
const boost::filesystem::path & file_path )
{
CJournal::Ptr journal( new CJournal(name) );
journal->load_journal_file(file_path);
return journal;
}
void tcp_accept_connection(void)
{
struct sockaddr_in cli_addr;
socklen_t cli_len;
int consockfd;
char *buffer;
size_t length;
int ret;
journal("Listening for connection...\n");
listen(sockfd, TCP_CONNECTION_BACKLOG);
cli_len = sizeof(cli_addr);
consockfd = accept(sockfd, (struct sockaddr *)(&cli_addr), &cli_len);
if (consockfd < 0) {
int errsave = errno;
journal("Unable to accept connection: %s.\n", strerror(errsave));
CHECK_SOCKET_ERROR(errsave);
return;
}
ret = get_quote_of_the_day(&buffer, &length);
if (unlikely(ret)) {
return;
}
ret = write(consockfd, buffer, length);
if (unlikely(ret < 0)) {
ERR_TRACE();
journal("Unable to wrtie to TCP connection socket: %s.\n", strerror(errno));
return;
}
ret = close(consockfd);
if (ret) {
journal("Unable to close connection: %s.\n", strerror(errno));
return;
}
}
void close_socket(void)
{
int ret;
if (sockfd < 0) {
return;
}
ret = close(sockfd);
if (ret) {
journal("Unable to close socket file descriptor %d: %s.\n",
sockfd, strerror(errno));
}
}
void
outS(String *s)
{
char *c;
int i;
c = Strtoc(s);
i = strlen(c);
outcopy(i, c);
if(i > 99)
c[99] = 0;
journaln(1, i);
journal(1, c);
free(c);
}
void set_up_ipv6_socket(const struct options *opt)
{
struct sockaddr_in6 serv_addr;
int ret, one = 1;
if (opt->tproto == PROTOCOL_TCP) {
journal("Setting up IPv%s6 socket over TCP...\n",
((opt->iproto == PROTOCOL_BOTH) ? "4/" : ""));
sockfd = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
} else {
journal("Setting up IPv%s6 socket over UDP...\n",
((opt->iproto == PROTOCOL_BOTH) ? "4/" : ""));
sockfd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);
}
if (sockfd < 0) {
journal("Unable to create IPv6 socket: %s.\n", strerror(errno));
cleanup(EXIT_IO, true);
}
if (opt->iproto == PROTOCOL_IPv6) {
ret = setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY, (void *)(&one), sizeof(one));
if (ret < 0) {
journal("Unable to set IPv4 compatibility option: %s.\n", strerror(errno));
cleanup(EXIT_IO, true);
}
}
ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)(&one), sizeof(one));
if (ret < 0) {
journal("Unable to set the socket to allow address reuse: %s.\n", strerror(errno));
}
serv_addr.sin6_family = AF_INET6;
serv_addr.sin6_addr = in6addr_any;
serv_addr.sin6_port = htons(opt->port);
serv_addr.sin6_flowinfo = 0;
serv_addr.sin6_scope_id = 0;
ret = bind(sockfd, (const struct sockaddr *)(&serv_addr), sizeof(struct sockaddr_in6));
if (ret < 0) {
journal("Unable to bind to socket: %s.\n", strerror(errno));
cleanup(EXIT_IO, true);
}
}
int
inmesg(Tmesg type)
{
Rune buf[1025];
char cbuf[64];
int i, m;
short s;
long l, l1;
vlong v;
File *f;
Posn p0, p1, p;
Range r;
String *str;
char *c, *wdir;
Rune *rp;
Plumbmsg *pm;
if(type > TMAX)
panic("inmesg");
journal(0, tname[type]);
inp = indata;
switch(type){
case -1:
panic("rcv error");
default:
fprint(2, "unknown type %d\n", type);
panic("rcv unknown");
case Tversion:
tversion = inshort();
journaln(0, tversion);
break;
case Tstartcmdfile:
v = invlong(); /* for 64-bit pointers */
journaln(0, v);
Strdupl(&genstr, samname);
cmd = newfile();
cmd->unread = 0;
outTsv(Hbindname, cmd->tag, v);
outTs(Hcurrent, cmd->tag);
logsetname(cmd, &genstr);
cmd->rasp = listalloc('P');
cmd->mod = 0;
if(cmdstr.n){
loginsert(cmd, 0L, cmdstr.s, cmdstr.n);
Strdelete(&cmdstr, 0L, (Posn)cmdstr.n);
}
fileupdate(cmd, FALSE, TRUE);
outT0(Hunlock);
break;
case Tcheck:
/* go through whichfile to check the tag */
outTs(Hcheck, whichfile(inshort())->tag);
break;
case Trequest:
f = whichfile(inshort());
p0 = inlong();
p1 = p0+inshort();
journaln(0, p0);
journaln(0, p1-p0);
if(f->unread)
panic("Trequest: unread");
if(p1>f->b.nc)
p1 = f->b.nc;
if(p0>f->b.nc) /* can happen e.g. scrolling during command */
p0 = f->b.nc;
if(p0 == p1){
i = 0;
r.p1 = r.p2 = p0;
}else{
r = rdata(f->rasp, p0, p1-p0);
i = r.p2-r.p1;
bufread(&f->b, r.p1, buf, i);
}
buf[i]=0;
outTslS(Hdata, f->tag, r.p1, tmprstr(buf, i+1));
break;
case Torigin:
s = inshort();
l = inlong();
l1 = inlong();
journaln(0, l1);
lookorigin(whichfile(s), l, l1);
break;
case Tstartfile:
termlocked++;
f = whichfile(inshort());
if(!f->rasp) /* this might be a duplicate message */
f->rasp = listalloc('P');
current(f);
outTsv(Hbindname, f->tag, invlong()); /* for 64-bit pointers */
outTs(Hcurrent, f->tag);
journaln(0, f->tag);
if(f->unread)
load(f);
else{
if(f->b.nc>0){
rgrow(f->rasp, 0L, f->b.nc);
outTsll(Hgrow, f->tag, 0L, f->b.nc);
}
outTs(Hcheck0, f->tag);
moveto(f, f->dot.r);
}
break;
case Tworkfile:
i = inshort();
f = whichfile(i);
current(f);
f->dot.r.p1 = inlong();
f->dot.r.p2 = inlong();
f->tdot = f->dot.r;
journaln(0, i);
journaln(0, f->dot.r.p1);
journaln(0, f->dot.r.p2);
break;
case Ttype:
f = whichfile(inshort());
p0 = inlong();
journaln(0, p0);
journal(0, (char*)inp);
str = tmpcstr((char*)inp);
i = str->n;
loginsert(f, p0, str->s, str->n);
if(fileupdate(f, FALSE, FALSE))
seq++;
if(f==cmd && p0==f->b.nc-i && i>0 && str->s[i-1]=='\n'){
freetmpstr(str);
termlocked++;
termcommand();
}else
freetmpstr(str);
f->dot.r.p1 = f->dot.r.p2 = p0+i; /* terminal knows this already */
f->tdot = f->dot.r;
break;
case Tcut:
f = whichfile(inshort());
p0 = inlong();
p1 = inlong();
journaln(0, p0);
journaln(0, p1);
logdelete(f, p0, p1);
if(fileupdate(f, FALSE, FALSE))
seq++;
f->dot.r.p1 = f->dot.r.p2 = p0;
f->tdot = f->dot.r; /* terminal knows the value of dot already */
break;
case Tpaste:
f = whichfile(inshort());
p0 = inlong();
journaln(0, p0);
for(l=0; l<snarfbuf.nc; l+=m){
m = snarfbuf.nc-l;
if(m>BLOCKSIZE)
m = BLOCKSIZE;
bufread(&snarfbuf, l, genbuf, m);
loginsert(f, p0, tmprstr(genbuf, m)->s, m);
}
if(fileupdate(f, FALSE, TRUE))
seq++;
f->dot.r.p1 = p0;
f->dot.r.p2 = p0+snarfbuf.nc;
f->tdot.p1 = -1; /* force telldot to tell (arguably a BUG) */
telldot(f);
outTs(Hunlockfile, f->tag);
break;
case Tsnarf:
i = inshort();
p0 = inlong();
p1 = inlong();
snarf(whichfile(i), p0, p1, &snarfbuf, 0);
break;
case Tstartnewfile:
v = invlong();
Strdupl(&genstr, empty);
f = newfile();
f->rasp = listalloc('P');
outTsv(Hbindname, f->tag, v);
logsetname(f, &genstr);
outTs(Hcurrent, f->tag);
current(f);
load(f);
break;
case Twrite:
termlocked++;
i = inshort();
journaln(0, i);
f = whichfile(i);
addr.r.p1 = 0;
addr.r.p2 = f->b.nc;
if(f->name.s[0] == 0)
error(Enoname);
Strduplstr(&genstr, &f->name);
writef(f);
break;
case Tclose:
termlocked++;
i = inshort();
journaln(0, i);
f = whichfile(i);
current(f);
trytoclose(f);
/* if trytoclose fails, will error out */
delete(f);
break;
case Tlook:
f = whichfile(inshort());
termlocked++;
p0 = inlong();
p1 = inlong();
journaln(0, p0);
journaln(0, p1);
setgenstr(f, p0, p1);
for(l = 0; l<genstr.n; l++){
i = genstr.s[l];
if(utfrune(".*+?(|)\\[]^$", i)){
str = tmpcstr("\\");
Strinsert(&genstr, str, l++);
freetmpstr(str);
}
}
Straddc(&genstr, '\0');
nextmatch(f, &genstr, p1, 1);
moveto(f, sel.p[0]);
break;
case Tsearch:
termlocked++;
if(curfile == 0)
error(Enofile);
if(lastpat.s[0] == 0)
panic("Tsearch");
nextmatch(curfile, &lastpat, curfile->dot.r.p2, 1);
moveto(curfile, sel.p[0]);
break;
case Tsend:
termlocked++;
inshort(); /* ignored */
p0 = inlong();
p1 = inlong();
setgenstr(cmd, p0, p1);
bufreset(&snarfbuf);
bufinsert(&snarfbuf, (Posn)0, genstr.s, genstr.n);
outTl(Hsnarflen, genstr.n);
if(genstr.s[genstr.n-1] != '\n')
Straddc(&genstr, '\n');
loginsert(cmd, cmd->b.nc, genstr.s, genstr.n);
fileupdate(cmd, FALSE, TRUE);
cmd->dot.r.p1 = cmd->dot.r.p2 = cmd->b.nc;
telldot(cmd);
termcommand();
break;
case Tdclick:
f = whichfile(inshort());
p1 = inlong();
doubleclick(f, p1);
f->tdot.p1 = f->tdot.p2 = p1;
telldot(f);
outTs(Hunlockfile, f->tag);
break;
case Tstartsnarf:
if (snarfbuf.nc <= 0) { /* nothing to export */
outTs(Hsetsnarf, 0);
break;
}
c = 0;
i = 0;
m = snarfbuf.nc;
if(m > SNARFSIZE) {
m = SNARFSIZE;
dprint("?warning: snarf buffer truncated\n");
}
rp = malloc(m*sizeof(Rune));
if(rp){
bufread(&snarfbuf, 0, rp, m);
c = Strtoc(tmprstr(rp, m));
free(rp);
i = strlen(c);
}
outTs(Hsetsnarf, i);
if(c){
Write(1, c, i);
free(c);
} else
dprint("snarf buffer too long\n");
break;
case Tsetsnarf:
m = inshort();
if(m > SNARFSIZE)
error(Etoolong);
c = malloc(m+1);
if(c){
for(i=0; i<m; i++)
c[i] = rcvchar();
c[m] = 0;
str = tmpcstr(c);
free(c);
bufreset(&snarfbuf);
bufinsert(&snarfbuf, (Posn)0, str->s, str->n);
freetmpstr(str);
outT0(Hunlock);
}
break;
case Tack:
waitack = 0;
break;
case Tplumb:
f = whichfile(inshort());
p0 = inlong();
p1 = inlong();
pm = emalloc(sizeof(Plumbmsg));
pm->src = strdup("sam");
pm->dst = 0;
/* construct current directory */
c = Strtoc(&f->name);
if(c[0] == '/')
pm->wdir = c;
else{
wdir = emalloc(1024);
getwd(wdir, 1024);
pm->wdir = emalloc(1024);
snprint(pm->wdir, 1024, "%s/%s", wdir, c);
cleanname(pm->wdir);
free(wdir);
free(c);
}
c = strrchr(pm->wdir, '/');
if(c)
*c = '\0';
pm->type = strdup("text");
if(p1 > p0)
pm->attr = nil;
else{
p = p0;
while(p0>0 && (i=filereadc(f, p0 - 1))!=' ' && i!='\t' && i!='\n')
p0--;
while(p1<f->b.nc && (i=filereadc(f, p1))!=' ' && i!='\t' && i!='\n')
p1++;
sprint(cbuf, "click=%ld", p-p0);
pm->attr = plumbunpackattr(cbuf);
}
if(p0==p1 || p1-p0>=BLOCKSIZE){
plumbfree(pm);
break;
}
setgenstr(f, p0, p1);
pm->data = Strtoc(&genstr);
pm->ndata = strlen(pm->data);
c = plumbpack(pm, &i);
if(c != 0){
outTs(Hplumb, i);
Write(1, c, i);
free(c);
}
plumbfree(pm);
break;
case Texit:
exits(0);
}
return TRUE;
}
static void WRITETOJOURNAL(const AlignedBuilder& bb) {
journal(bb);
}
int
inmesg(Tmesg type)
{
Rune buf[1025];
int i, m;
short s;
long l, l1;
File *f;
Posn p0, p1;
Range r;
String *str;
char *c;
Rune *rp;
if(type > TMAX)
panic("inmesg");
journal(0, tname[type]);
inp = indata;
switch(type) {
case -1:
panic("rcv error");
default:
fprint(2, "unknown type %d\n", type);
panic("rcv unknown");
case Tversion:
tversion = inshort();
journaln(0, tversion);
break;
case Tstartcmdfile:
l = invlong(); /* for 64-bit pointers */
journaln(0, l);
Strdupl(&genstr, samname);
cmd = newfile();
outTsv(Hbindname, cmd->tag, l);
outTs(Hcurrent, cmd->tag);
Fsetname(cmd, &genstr);
cmd->rasp = emalloc(sizeof(List));
cmd->state = Clean;
if(cmdstr.n) {
Finsert(cmd, &cmdstr, 0L);
Strdelete(&cmdstr, 0L, (Posn)cmdstr.n);
}
Fupdate(cmd, FALSE, TRUE);
outT0(Hunlock);
break;
case Tcheck:
/* go through whichfile to check the tag */
outTs(Hcheck, whichfile(inshort())->tag);
break;
case Trequest:
f = whichfile(inshort());
p0 = inlong();
p1 = p0+inshort();
journaln(0, p0);
journaln(0, p1-p0);
if(f->state == Unread)
panic("Trequest: unread");
if(p1>f->nrunes)
p1 = f->nrunes;
if(p0>f->nrunes) /* can happen e.g. scrolling during command */
p0 = f->nrunes;
if(p0 == p1) {
i = 0;
r.p1 = r.p2 = p0;
} else {
r = rdata(f->rasp, p0, p1-p0);
i = r.p2-r.p1;
if(Fchars(f, buf, r.p1, r.p2)!=i)
panic("Trequest 2");
}
buf[i]=0;
outTslS(Hdata, f->tag, r.p1, tmprstr(buf, i+1));
break;
case Torigin:
s = inshort();
l = inlong();
l1 = inlong();
journaln(0, l1);
lookorigin(whichfile(s), l, l1);
break;
case Tstartfile:
termlocked++;
f = whichfile(inshort());
if(!f->rasp) /* this might be a duplicate message */
f->rasp = emalloc(sizeof(List));
current(f);
outTsv(Hbindname, f->tag, invlong()); /* for 64-bit pointers */
outTs(Hcurrent, f->tag);
journaln(0, f->tag);
if(f->state == Unread)
load(f);
else {
if(f->nrunes>0) {
rgrow(f->rasp, 0L, f->nrunes);
outTsll(Hgrow, f->tag, 0L, f->nrunes);
}
outTs(Hcheck0, f->tag);
moveto(f, f->dot.r);
}
break;
case Tworkfile:
i = inshort();
f = whichfile(i);
current(f);
f->dot.r.p1 = inlong();
f->dot.r.p2 = inlong();
f->tdot = f->dot.r;
journaln(0, i);
journaln(0, f->dot.r.p1);
journaln(0, f->dot.r.p2);
break;
case Ttype:
f = whichfile(inshort());
p0 = inlong();
journaln(0, p0);
journal(0, (char*)inp);
str = tmpcstr((char*)inp);
i = str->n;
Finsert(f, str, p0);
if(Fupdate(f, FALSE, FALSE))
modnum++;
if(f==cmd && p0==f->nrunes-i && i>0 && str->s[i-1]=='\n') {
freetmpstr(str);
termlocked++;
termcommand();
} else
freetmpstr(str);
f->dot.r.p1 = f->dot.r.p2 = p0+i; /* terminal knows this already */
f->tdot = f->dot.r;
break;
case Tcut:
f = whichfile(inshort());
p0 = inlong();
p1 = inlong();
journaln(0, p0);
journaln(0, p1);
Fdelete(f, p0, p1);
if(Fupdate(f, FALSE, FALSE))
modnum++;
f->dot.r.p1 = f->dot.r.p2 = p0;
f->tdot = f->dot.r; /* terminal knows the value of dot already */
break;
case Tpaste:
f = whichfile(inshort());
p0 = inlong();
journaln(0, p0);
for(l=0; l<snarfbuf->nrunes; l+=m) {
m = snarfbuf->nrunes-l;
if(m>BLOCKSIZE)
m = BLOCKSIZE;
Bread(snarfbuf, genbuf, m, l);
Finsert(f, tmprstr(genbuf, m), p0);
}
if(Fupdate(f, FALSE, TRUE))
modnum++;
f->dot.r.p1 = p0;
f->dot.r.p2 = p0+snarfbuf->nrunes;
f->tdot.p1 = -1; /* force telldot to tell (arguably a BUG) */
telldot(f);
outTs(Hunlockfile, f->tag);
break;
case Tsnarf:
i = inshort();
p0 = inlong();
p1 = inlong();
snarf(whichfile(i), p0, p1, snarfbuf, 0);
break;
case Tstartnewfile:
l = invlong();
Strdupl(&genstr, empty);
f = newfile();
f->rasp = emalloc(sizeof(List));
outTsv(Hbindname, f->tag, l);
Fsetname(f, &genstr);
outTs(Hcurrent, f->tag);
current(f);
load(f);
break;
case Twrite:
termlocked++;
i = inshort();
journaln(0, i);
f = whichfile(i);
addr.r.p1 = 0;
addr.r.p2 = f->nrunes;
if(f->name.s[0] == 0)
error(Enoname);
Strduplstr(&genstr, &f->name);
writef(f);
break;
case Tclose:
termlocked++;
i = inshort();
journaln(0, i);
f = whichfile(i);
current(f);
trytoclose(f);
/* if trytoclose fails, will error out */
delete(f);
break;
case Tlook:
f = whichfile(inshort());
termlocked++;
p0 = inlong();
p1 = inlong();
journaln(0, p0);
journaln(0, p1);
setgenstr(f, p0, p1);
for(l = 0; l<genstr.n; l++) {
i = genstr.s[l];
if(utfrune(".*+?(|)\\[]^$", i))
Strinsert(&genstr, tmpcstr("\\"), l++);
}
Straddc(&genstr, '\0');
nextmatch(f, &genstr, p1, 1);
moveto(f, sel.p[0]);
break;
case Tsearch:
termlocked++;
if(curfile == 0)
error(Enofile);
if(lastpat.s[0] == 0)
panic("Tsearch");
nextmatch(curfile, &lastpat, curfile->dot.r.p2, 1);
moveto(curfile, sel.p[0]);
break;
case Tsend:
termlocked++;
inshort(); /* ignored */
p0 = inlong();
p1 = inlong();
setgenstr(cmd, p0, p1);
Bdelete(snarfbuf, (Posn)0, snarfbuf->nrunes);
Binsert(snarfbuf, &genstr, (Posn)0);
outTl(Hsnarflen, genstr.n);
if(genstr.s[genstr.n-1] != '\n')
Straddc(&genstr, '\n');
Finsert(cmd, &genstr, cmd->nrunes);
Fupdate(cmd, FALSE, TRUE);
cmd->dot.r.p1 = cmd->dot.r.p2 = cmd->nrunes;
telldot(cmd);
termcommand();
break;
case Tdclick:
f = whichfile(inshort());
p1 = inlong();
doubleclick(f, p1);
f->tdot.p1 = f->tdot.p2 = p1;
telldot(f);
outTs(Hunlockfile, f->tag);
break;
case Tstartsnarf:
if (snarfbuf->nrunes <= 0) { /* nothing to export */
outTs(Hsetsnarf, 0);
break;
}
c = 0;
i = 0;
m = snarfbuf->nrunes;
if(m > 32000) { /* tmprstr stores len in a short */
m = 32000;
dprint("?warning: snarf buffer truncated\n");
}
rp = malloc(m*sizeof(Rune));
if(rp) {
Bread(snarfbuf, rp, m, 0);
c = Strtoc(tmprstr(rp, m));
free(rp);
i = strlen(c);
}
outTs(Hsetsnarf, i);
if(c) {
Write(1, c, i);
free(c);
} else
dprint("snarf buffer too long\n");
break;
case Tsetsnarf:
m = inshort();
if(m > SNARFSIZE)
error(Etoolong);
c = malloc(m+1);
if(c) {
for(i=0; i<m; i++)
c[i] = rcvchar();
c[m] = 0;
str = tmpcstr(c);
free(c);
Bdelete(snarfbuf, (Posn)0, snarfbuf->nrunes);
Binsert(snarfbuf, str, (Posn)0);
freetmpstr(str);
outT0(Hunlock);
}
break;
case Tack:
waitack = 0;
break;
case Texit:
exits(0);
}
return TRUE;
}
int
dsa_control (Attr_Sequence as, struct DSError *error, DN dn)
{
char * str;
DN dn2;
Entry theentry;
extern Entry database_root;
SFD attempt_restart();
if ( ! manager(dn) ) {
error->dse_type = DSE_SECURITYERROR;
error->ERR_SECURITY.DSE_sc_problem = DSE_SC_ACCESSRIGHTS;
return (DS_ERROR_REMOTE);
}
str = (char *) as->attr_value->avseq_av.av_struct;
#ifndef NO_STATS
LLOG (log_stat,LLOG_NOTICE,("DSA control: %s",str));
#endif
switch (*str) {
case 'd': /* -dump <directory> */
str = SkipSpace (++str);
/*
directory_dump (str, database_root);
*/
return (DS_OK);
case 't': /* -tailor <string> */
str = SkipSpace (++str);
if (dsa_tai_string (str) == OK) {
isodexport (NULLCP);
return (DS_OK);
}
break;
case 'a': /* -abort */
LLOG (log_dsap,LLOG_FATAL,("*** abort signal ***"));
dsa_abort(-1);
exit(0);
case 'b': /* -restart */
LLOG (log_dsap,LLOG_FATAL,("*** restart signal ***"));
attempt_restart (NOTOK);
exit(0); /* should not be reached */
case 'r': /* -refresh <entry> */
str = SkipSpace (++str);
if (lexequ (str,"root") == 0)
dn2= NULLDN;
else if ((dn2 = str2dn (str)) == NULLDN)
break;
if (refresh_from_disk (dn2) == OK)
return (DS_OK);
break;
case 'f': /* -resync <entry> */
str = SkipSpace (++str);
if (lexequ (str,"root") == 0)
dn2= NULLDN;
else if ((dn2 = str2dn (str)) == NULLDN)
break;
if ((theentry = local_find_entry (dn2,FALSE)) != NULLENTRY)
#ifdef TURBO_DISK
{
Entry akid = (Entry) avl_getone(theentry->e_children);
if (turbo_writeall (akid) == OK)
return (DS_OK);
}
#else
{
Entry akid = (Entry) avl_getone(theentry->e_children);
if (journal (akid) == OK)
return (DS_OK);
}
#endif
break;
case 'l': /* -lock <entry> */
str = SkipSpace (++str);
if (lexequ (str,"root") == 0)
dn2 = NULLDN;
else if ((dn2 = str2dn (str)) == NULLDN)
break;
if ((theentry = local_find_entry (dn2,FALSE)) != NULLENTRY) {
theentry->e_lock = TRUE;
return (DS_OK);
}
break;
case 'u': /* -unlock <entry> */
str = SkipSpace (++str);
if (lexequ (str,"root") == 0)
dn2 = NULLDN;
else if ((dn2 = str2dn (str)) == NULLDN)
break;
if ((theentry = local_find_entry (dn2,FALSE)) != NULLENTRY) {
theentry->e_lock = FALSE;
return (DS_OK);
}
break;
case 's': /* -slave */
/*
* When we go async return of OK will mean that a getedb
* operation has been scheduled, NOT that it has succeeded.
*/
str = SkipSpace (++str);
if (*str == NULL) {
slave_update();
return DS_OK;
}
if (lexequ (str, "shadow") == 0) {
shadow_update();
return DS_OK;
}
if (lexequ (str, "root") == 0)
dn2 = NULLDN;
else if ((dn2 = str2dn (str)) == NULLDN)
break;
if (update_aux (dn2, dn2 == NULLDN) == OK)
return DS_OK;
break;
default:
break;
}
error->dse_type = DSE_SERVICEERROR;
error->ERR_SERVICE.DSE_sv_problem = DSE_SV_UNWILLINGTOPERFORM;
return (DS_ERROR_REMOTE);
}
int
new_dsa_control (Attr_Sequence as, struct DSError *error, DN dn)
{
struct dsa_control * item ;
char * tmp_ptr ;
DN dn2;
Entry theentry;
extern Entry database_root;
SFD attempt_restart();
/* Return some silly error to distinguish it from the other dsa_control */
if ( ! manager(dn) ) {
error->dse_type = DSE_SECURITYERROR ;
error->ERR_SECURITY.DSE_sc_problem = DSE_SC_PROTECTIONREQUIRED ;
return (DS_ERROR_REMOTE) ;
}
item = (struct dsa_control *) as->attr_value->avseq_av.av_struct ;
switch (item->dsa_control_option) {
case (CONTROL_CHANGETAILOR) : { /* -tailor <string> */
tmp_ptr = qb2str(item->un.changeTailor) ;
if (dsa_tai_string (tmp_ptr) == OK) {
isodexport (NULLCP);
return (DS_OK);
}
break;
}
case(CONTROL_STOPDSA): { /* -abort */
LLOG(log_dsap,LLOG_FATAL,("*** abort signal ***")) ;
stop_listeners() ;
exit(0) ;
}
case (CONTROL_REFRESH): { /* -refresh <entry> */
if (item->un.refresh->offset == DN_PRESENT)
if (refresh_from_disk (item->un.refresh->un.selectedDN) == OK)
return (DS_OK);
break;
}
case(CONTROL_RESYNCH): { /* -resync <entry> */
if (item->un.resynch->offset == DN_PRESENT)
dn2 = item->un.resynch->un.selectedDN ;
else
break ;
if ((theentry = local_find_entry (dn2, FALSE)) != NULLENTRY)
#ifdef TURBO_DISK
{
Entry akid = (Entry) avl_getone(theentry->e_children);
if (turbo_writeall (akid) == OK)
return (DS_OK);
}
#else
{
Entry akid = (Entry) avl_getone(theentry->e_children);
if (journal (akid) == OK)
return (DS_OK);
}
#endif
break;
}
case (CONTROL_LOCKDSA): { /* -lock <entry> */
if (item->un.resynch->offset == DN_PRESENT)
dn2 = item->un.resynch->un.selectedDN ;
else
break ;
if ((theentry = local_find_entry (dn2,FALSE)) != NULLENTRY) {
theentry->e_lock = TRUE;
return (DS_OK);
}
break;
}
case (CONTROL_UNLOCK): { /* -unlock <entry> */
if (item->un.resynch->offset == DN_PRESENT)
dn2 = item->un.resynch->un.selectedDN ;
else
break ;
if ((theentry = local_find_entry (dn2,FALSE)) != NULLENTRY) {
theentry->e_lock = FALSE;
return (DS_OK);
}
break;
}
case (CONTROL_SETLOGLEVEL): { /* Set the Logging Level */
tmp_ptr = qb2str(item->un.setLogLevel) ;
/* What kind of stuff is needed here?!! */
return (DS_OK);
break;
}
case (CONTROL_UPDATESLAVEEDBS): { /* -slave */
/*
* When we go async return of OK will mean that a getedb
* operation has been scheduled, NOT that it has succeeded.
*/
tmp_ptr = qb2str(item->un.updateSlaveEDBs) ;
if (lexequ (tmp_ptr, "all") == 0) {
slave_update();
return DS_OK;
}
if (lexequ (tmp_ptr, "shadow") == 0) {
shadow_update();
return DS_OK;
}
if (lexequ (tmp_ptr, "root") == 0) {
dn2 = NULLDN;
} else {
if ((dn2 = str2dn (tmp_ptr)) == NULLDN)
break;
}
if (update_aux (dn2, dn2 == NULLDN) == OK)
return DS_OK;
break;
}
default:
break;
}
error->dse_type = DSE_SERVICEERROR;
error->ERR_SERVICE.DSE_sv_problem = DSE_SV_UNWILLINGTOPERFORM;
return (DS_ERROR_REMOTE);
}
void handle_menu_choice(eMenu item_hit) {
std::string dialogToShow;
sf::Event dummyEvent = {sf::Event::KeyPressed};
short i, choice;
switch(item_hit) {
case eMenu::NONE: break;
case eMenu::FILE_OPEN:
do_load();
break;
case eMenu::FILE_SAVE:
do_save(0);
break;
case eMenu::FILE_SAVE_AS:
do_save(1);
break;
case eMenu::FILE_NEW:
if(overall_mode != MODE_STARTUP) {
std::string choice = cChoiceDlog("restart-game",{"okay","cancel"}).show();
if(choice == "cancel")
return;
for(i = 0; i < 6; i++)
univ.party[i].main_status = eMainStatus::ABSENT;
party_in_memory = false;
reload_startup();
overall_mode = MODE_STARTUP;
draw_startup(0);
}
start_new_game();
draw_startup(0);
menu_activate();
break;
case eMenu::FILE_ABORT:
if(overall_mode != MODE_STARTUP) {
std::string choice = cChoiceDlog("abort-game",{"okay","cancel"}).show();
if (choice=="cancel") return;
reload_startup();
overall_mode = MODE_STARTUP;
}
party_in_memory = false;
draw_startup(0);
menu_activate();
break;
case eMenu::PREFS:
pick_preferences();
break;
case eMenu::QUIT:
if(overall_mode == MODE_STARTUP) {
if(party_in_memory) {
std::string choice = cChoiceDlog("quit-confirm-save", {"save","quit","cancel"}).show();
if(choice == "cancel") break;
if(choice == "save") {
fs::path file = nav_put_party();
if(!file.empty()) break;
save_party(file, univ);
}
}
All_Done = true;
break;
}
if(overall_mode > MODE_TOWN) {
std::string choice = cChoiceDlog("quit-confirm-nosave",{"quit","cancel"}).show();
if(choice == "cancel")
return;
}
else {
std::string choice = cChoiceDlog("quit-confirm-save",{"quit","save","cancel"}).show();
if(choice == "cancel")
break;
if(choice == "save") {
if(univ.file.empty()) {
univ.file = nav_put_party();
if(univ.file.empty()) break;
}
save_party(univ.file, univ);
}
}
All_Done = true;
break;
case eMenu::OPTIONS_PC_GRAPHIC:
choice = char_select_pc(1,"New graphic for who?");
if(choice < 6)
pick_pc_graphic(choice,1,nullptr);
draw_terrain();
break;
case eMenu::OPTIONS_DELETE_PC:
if(!prime_time()) {
ASB("Finish what you're doing first.");
print_buf();
}
else {
choice = char_select_pc(1,"Delete who?");
if(choice < 6) {
std::string confirm = cChoiceDlog("delete-pc-confirm",{"yes","no"}).show();
if(confirm == "yes")
kill_pc(univ.party[choice],eMainStatus::ABSENT);
}
draw_terrain();
}
break;
case eMenu::OPTIONS_RENAME_PC:
choice = char_select_pc(1,"Rename who?");
if(choice < 6)
pick_pc_name(choice,nullptr);
put_pc_screen();
put_item_screen(stat_window);
break;
case eMenu::OPTIONS_NEW_PC:
if(!(is_town())) {
add_string_to_buf("Add PC: Town mode only.");
print_buf();
break;
}
for(i = 0; i < 6; i++)
if(univ.party[i].main_status == eMainStatus::ABSENT)
i = 20;
if(i == 6) {
ASB("Add PC: You already have 6 PCs.");
print_buf();
break;
}
if(univ.town->has_tavern) {
give_help(56,0);
create_pc(6,nullptr);
} else {
add_string_to_buf("Add PC: You cannot add new characters in this town. Try in the town you started in.", 2);
}
print_buf();
put_pc_screen();
put_item_screen(stat_window);
break;
case eMenu::OPTIONS_JOURNAL:
journal();
break;
case eMenu::OPTIONS_TALK_NOTES:
if(overall_mode == MODE_TALKING) {
ASB("Talking notes: Can't read while talking.");
print_buf();
return;
}
talk_notes();
break;
case eMenu::OPTIONS_ENCOUNTER_NOTES:
adventure_notes();
break;
case eMenu::OPTIONS_STATS:
if(overall_mode != MODE_STARTUP)
print_party_stats();
break;
case eMenu::HELP_OUT:
dialogToShow = "help-outdoor";
break;
case eMenu::HELP_TOWN:
dialogToShow = "help-town";
break;
case eMenu::HELP_COMBAT:
dialogToShow = "help-combat";
break;
case eMenu::HELP_BARRIER:
dialogToShow = "help-fields";
break;
case eMenu::HELP_HINTS:
dialogToShow = "help-hints";
break;
case eMenu::HELP_SPELLS:
dialogToShow = "help-magic";
break;
case eMenu::ABOUT:
dialogToShow = "about-boe";
break;
case eMenu::LIBRARY_MAGE:
display_spells(eSkill::MAGE_SPELLS,100,0);
break;
case eMenu::LIBRARY_PRIEST:
display_spells(eSkill::PRIEST_SPELLS,100,0);
break;
case eMenu::LIBRARY_SKILLS:
display_skills(eSkill::INVALID,0);
break;
case eMenu::LIBRARY_ALCHEMY:
// TODO: Create a dedicated dialog for alchemy info
display_alchemy();
break;
case eMenu::LIBRARY_TIPS:
tip_of_day();
break;
case eMenu::LIBRARY_INTRO:
dialogToShow = "welcome";
break;
case eMenu::ACTIONS_ALCHEMY:
dummyEvent.key.code = sf::Keyboard::A;
dummyEvent.key.shift = true;
handle_keystroke(dummyEvent);
break;
case eMenu::ACTIONS_WAIT:
dummyEvent.key.code = sf::Keyboard::W;
handle_keystroke(dummyEvent);
break;
case eMenu::ACTIONS_AUTOMAP:
if(!prime_time()) {
ASB("Finish what you're doing first.");
print_buf();
}
else {
give_help(62,0);
display_map();
}
make_cursor_sword();
break;
case eMenu::HELP_TOC:
if(fs::is_directory(progDir/"doc"))
launchURL("file://" + (progDir/"doc/game/Contents.html").string());
else launchURL("https://blades.calref.net/doc/game/Contents.html");
break;
case eMenu::ABOUT_MAGE:
case eMenu::ABOUT_PRIEST:
give_help(209,0);
break;
case eMenu::ABOUT_MONSTERS:
give_help(212,0);
break;
}
if(!dialogToShow.empty()) {
cChoiceDlog dlog(dialogToShow);
dlog.show();
}
}
Handoff
OverlayImpl::onHandoff (std::unique_ptr <beast::asio::ssl_bundle>&& ssl_bundle,
beast::http::message&& request,
endpoint_type remote_endpoint)
{
auto const id = next_id_++;
beast::WrappedSink sink (deprecatedLogs()["Peer"], makePrefix(id));
beast::Journal journal (sink);
Handoff handoff;
if (processRequest(request, handoff))
return handoff;
if (! isPeerUpgrade(request))
return handoff;
handoff.moved = true;
if (journal.trace) journal.trace <<
"Peer connection upgrade from " << remote_endpoint;
error_code ec;
auto const local_endpoint (ssl_bundle->socket.local_endpoint(ec));
if (ec)
{
if (journal.trace) journal.trace <<
remote_endpoint << " failed: " << ec.message();
return handoff;
}
auto consumer = m_resourceManager.newInboundEndpoint(
beast::IPAddressConversion::from_asio(remote_endpoint));
if (consumer.disconnect())
return handoff;
auto const slot = m_peerFinder->new_inbound_slot (
beast::IPAddressConversion::from_asio(local_endpoint),
beast::IPAddressConversion::from_asio(remote_endpoint));
if (slot == nullptr)
{
// self-connect, close
handoff.moved = false;
return handoff;
}
// TODO Validate HTTP request
{
auto const types = beast::rfc2616::split_commas(
request.headers["Connect-As"]);
if (std::find_if(types.begin(), types.end(),
[](std::string const& s)
{
return beast::ci_equal(s, "peer");
}) == types.end())
{
handoff.moved = false;
handoff.response = makeRedirectResponse(slot, request,
remote_endpoint.address());
handoff.keep_alive = request.keep_alive();
return handoff;
}
}
handoff.moved = true;
bool success = true;
protocol::TMHello hello;
std::tie(hello, success) = parseHello (request, journal);
if(! success)
return handoff;
uint256 sharedValue;
std::tie(sharedValue, success) = makeSharedValue(
ssl_bundle->stream.native_handle(), journal);
if(! success)
return handoff;
RippleAddress publicKey;
std::tie(publicKey, success) = verifyHello (hello,
sharedValue, journal, getApp());
if(! success)
return handoff;
std::string name;
bool const cluster = getApp().getUNL().nodeInCluster(
publicKey, name);
auto const result = m_peerFinder->activate (slot,
publicKey.toPublicKey(), cluster);
if (result != PeerFinder::Result::success)
{
if (journal.trace) journal.trace <<
"Peer " << remote_endpoint << " redirected, slots full";
handoff.moved = false;
handoff.response = makeRedirectResponse(slot, request,
remote_endpoint.address());
handoff.keep_alive = request.keep_alive();
return handoff;
}
auto const peer = std::make_shared<PeerImp>(id,
remote_endpoint, slot, std::move(request), hello, publicKey,
consumer, std::move(ssl_bundle), *this);
{
// As we are not on the strand, run() must be called
// while holding the lock, otherwise new I/O can be
// queued after a call to stop().
std::lock_guard <decltype(mutex_)> lock (mutex_);
add(peer);
peer->run();
}
handoff.moved = true;
return handoff;
}
/** write the buffer we have built to the journal and fsync it.
outside of lock as that could be slow.
*/
static void WRITETOJOURNAL(AlignedBuilder& ab) {
journal(ab);
}
static void parse_short_options(
const char *argument, const char *next_arg, int *index, struct argument_flags *flags)
{
size_t i;
#if DEBUG
journal("Parsing options in \"-%s\":\n", argument);
#endif /* DEBUG */
for (i = 0; argument[i]; i++) {
#if DEBUG
journal(" Parsing flag \"-%c\".\n", argument[i]);
journal(" flags = {\n");
journal(" ProgramName: %s\n", flags->program_name);
journal(" ConfFile: %s\n", flags->conf_file);
journal(" QuotesFile: %s\n", flags->quotes_file);
journal(" PidFile: %s\n", flags->pid_file);
journal(" JournalFile: %s\n", flags->journal_file);
journal(" Daemonize: %s\n", BOOLSTR2(flags->daemonize));
journal(" Protocol: %s\n", \
name_option_protocol(flags->tproto, flags->iproto));
journal(" }\n\n");
#endif /* DEBUG */
switch (argument[i]) {
case 'f':
flags->daemonize = false;
break;
case 'c':
if (!next_arg) {
fprintf(stderr, "You must specify a configuration file.\n");
cleanup(EXIT_ARGUMENTS, true);
}
(*index)++;
flags->conf_file = next_arg;
break;
case 'N':
flags->conf_file = NULL;
case 'P':
if (!next_arg) {
fprintf(stderr, "You must specify a pid file.\n");
cleanup(EXIT_ARGUMENTS, true);
}
(*index)++;
flags->pid_file = next_arg;
break;
case 's':
if (!next_arg) {
fprintf(stderr, "You must specify a quotes file.\n");
cleanup(EXIT_ARGUMENTS, true);
}
(*index)++;
flags->quotes_file = next_arg;
break;
case 'j':
if (!next_arg) {
fprintf(stderr, "You must specify a journal file.\n");
cleanup(EXIT_ARGUMENTS, true);
}
(*index)++;
flags->journal_file = next_arg;
break;
case '4':
if (flags->iproto == PROTOCOL_IPv6) {
fprintf(stderr, "Conflicting options passed: -4 and -6.\n");
cleanup(EXIT_ARGUMENTS, true);
}
flags->iproto = PROTOCOL_IPv4;
break;
case '6':
if (flags->iproto == PROTOCOL_IPv4) {
fprintf(stderr, "Conflicting options passed: -4 and -6.\n");
cleanup(EXIT_ARGUMENTS, true);
}
flags->iproto = PROTOCOL_IPv6;
break;
case 't':
if (flags->tproto == PROTOCOL_UDP) {
fprintf(stderr, "Conflicting options passed: -t and -u.\n");
cleanup(EXIT_ARGUMENTS, true);
}
flags->tproto = PROTOCOL_TCP;
break;
case 'u':
if (flags->tproto == PROTOCOL_TCP) {
fprintf(stderr, "Conflicting options passed: -t and -u.\n");
cleanup(EXIT_ARGUMENTS, true);
}
flags->tproto = PROTOCOL_UDP;
break;
case 'q':
close_journal();
break;
default:
fprintf(stderr, "Unknown short option: -%c.\n", argument[i]);
usage_and_exit(flags->program_name);
}
}
}
dsa_init () {
Attr_Sequence as, get_cacheEDB();
AttributeType manager;
DN str2dn();
struct edb_info * dsainfo;
AV_Sequence avs;
Entry newentry;
Entry my_entry;
int real_unravel_attribute ();
int real_check_schema ();
char loadstate = TRUE;
struct DSError error;
Entry akid;
check_dsa_known_oids ();
unrav_fn = (IFP) real_unravel_attribute;
schema_fn = (IFP) real_check_schema;
restart_fn = (IFP) attempt_restart;
if (( manager = AttrT_new (MANAGER_OID)) == NULLAttrT)
fatal (-1,"Manager - unknown attribute - check oid tables");
LLOG (log_dsap,LLOG_NOTICE,("dsa name %s",mydsaname));
if ((mydsadn = str2dn (mydsaname)) == NULLDN) {
fatal (-2,"Invalid dsa name");
}
if ((my_entry = load_dsa_cache_entry (mydsadn)) == NULLENTRY) {
if (parse_status != 0)
fatal (-3,"Can't load EDB subtree holding my DSA entry");
if (database_root != NULLENTRY)
fatal (-4,"Found EDB - but my DSA entry not in it!");
fatal (-4,"can't locate my DSA entry in local database!");
} else if (my_entry->e_data == E_TYPE_CACHE_FROM_MASTER)
shadow_myentry ();
if (get_entry_passwd (my_entry->e_attributes) == NULLCP)
/* This is not a fatal error, but some remote operations may fail */
LLOG(log_dsap,LLOG_EXCEPTIONS,("Can't find my own PASSWORD"));
if (dsa_real_attr) {
if (as_cmp (my_entry->e_attributes,dsa_real_attr) != 0) {
LLOG (log_dsap,LLOG_EXCEPTIONS,
("DSA.real entry inconsistent with EDB -- problem should fix itself later!"));
as_free (my_entry->e_attributes);
my_entry->e_attributes = as_cpy (dsa_real_attr);
if (unravel_attribute (my_entry,&error) != OK)
fatal (-82,"schema error in DSA entry");
}
} else
dsa_real_attr = as_cpy (my_entry->e_attributes);
if (my_entry->e_dsainfo != NULLDSA) {
/* get manager attribute */
if ((as = entry_find_type(my_entry,manager)) == NULLATTR )
fatal (-5,"Manager attribute missing in my own entry");
AttrT_free (manager);
super_user = avs_cpy ((AV_Sequence)as->attr_value);
if (quipu_ctx_supported(my_entry) < 5) {
LLOG(log_dsap,LLOG_EXCEPTIONS,(
"Adding QUIPU and/or Internet DSP to application context!!!"));
set_context (my_entry);
}
my_entry->e_dsainfo->dsa_version =
TidyString (strdup (quipuversion));
if (as = entry_find_type (my_entry,at_version))
if ( strcmp (
(char *) as->attr_value->avseq_av.av_struct,
my_entry->e_dsainfo->dsa_version) != 0) {
if (as->attr_value->avseq_av.av_struct)
free (as->attr_value->avseq_av.av_struct);
as->attr_value->avseq_av.av_struct =
(caddr_t) strdup (my_entry->e_dsainfo->dsa_version);
if (as = as_find_type (dsa_real_attr,at_version)) {
if (as->attr_value->avseq_av.av_struct)
free (as->attr_value->avseq_av.av_struct);
as->attr_value->avseq_av.av_struct =
(caddr_t) strdup (my_entry->e_dsainfo->dsa_version);
}
if (parse_status == 0)
if (my_entry->e_data == E_DATA_MASTER) {
if (my_entry->e_parent != NULLENTRY)
my_entry->e_parent->e_edbversion = new_version();
LLOG (log_dsap,LLOG_NOTICE,("Updating version number"));
#ifdef TURBO_DISK
if (turbo_write(my_entry) != OK)
fatal (-33,"self rewrite failed - check database");
#else
akid = (Entry) avl_getone(my_entry->e_parent->e_children);
if (journal (akid) != OK)
fatal (-33,"self rewrite failed - check database");
#endif
} else {
write_dsa_entry(my_entry);
}
}
} else
fatal (-6,"No edbinfo attribute in my own entry");
if (parse_status != 0)
loadstate = FALSE;
for (avs = my_entry->e_dsainfo->dsa_attr ; avs != NULLAV; avs=avs->avseq_next) {
if (avs->avseq_av.av_struct == NULL)
continue;
dsainfo = (struct edb_info *) avs->avseq_av.av_struct;
if ((newentry = make_path (dsainfo->edb_name)) == NULLENTRY)
continue;
(void) subtree_load (newentry,dsainfo->edb_name);
if (parse_status != 0)
loadstate = FALSE;
}
if (loadstate == FALSE)
fatal (-7,"DSA Halted");
if ((akid = (Entry) avl_getone(database_root->e_children))
!= NULLENTRY )
database_root->e_data = akid->e_data;
/* Load cached EDB files - if any */
if ((as = get_cacheEDB()) != NULLATTR) {
(void) time (&timenow);
for (avs = as -> attr_value; avs != NULLAV; avs = avs -> avseq_next) {
if ((newentry = make_path ((DN)avs->avseq_av.av_struct)) == NULLENTRY)
continue;
newentry = subtree_load (newentry,(DN)avs->avseq_av.av_struct);
/* Should timestamp using version number ! */
if (newentry)
newentry->e_age = timenow;
}
}
#ifndef TURBO_DISK
free_phylinebuf(); /* Large buffer used in loading text database */
#endif
return (OK);
}
void parse_args(struct options *const opt, const int argc, const char *const argv[])
{
struct argument_flags flags;
int i;
/* Set override flags */
flags.program_name = basename((char *)argv[0]);
flags.conf_file = DEFAULT_CONFIG_FILE;
flags.quotes_file = NULL;
flags.pid_file = NULL;
flags.journal_file = NULL;
flags.tproto = PROTOCOL_TNONE;
flags.iproto = PROTOCOL_INONE;
flags.daemonize = BOOLEAN_UNSET;
flags.strict = true;
/* Set default options, defined in options.h */
opt->port = DEFAULT_PORT;
opt->tproto = DEFAULT_TRANSPORT_PROTOCOL;
opt->iproto = DEFAULT_INTERNET_PROTOCOL;
opt->quotes_file = DEFAULT_QUOTES_FILE;
opt->linediv = DEFAULT_LINE_DIVIDER;
opt->pid_file = default_pidfile();
opt->require_pidfile = DEFAULT_REQUIRE_PIDFILE;
opt->daemonize = DEFAULT_DAEMONIZE;
opt->drop_privileges = DEFAULT_DROP_PRIVILEGES;
opt->is_daily = DEFAULT_IS_DAILY;
opt->pad_quotes = DEFAULT_PAD_QUOTES;
opt->allow_big = DEFAULT_ALLOW_BIG;
opt->chdir_root = DEFAULT_CHDIR_ROOT;
/* Parse arguments */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "--")) {
break;
} else if (!strncmp(argv[i], "--", 2)) {
parse_long_option(argc, argv, &i, &flags);
} else if (argv[i][0] == '-') {
const char *next_arg = (i + 1 == argc) ? NULL : argv[i + 1];
parse_short_options(argv[i] + 1, next_arg, &i, &flags);
} else {
printf("Unrecognized option: %s.\n", argv[i]);
usage_and_exit(flags.program_name);
}
}
/* Override config file options */
opt->strict = flags.strict;
if (flags.conf_file) {
if (flags.conf_file[0] != '/') {
opt->chdir_root = false;
}
parse_config(flags.conf_file, opt);
}
if (flags.pid_file) {
opt->pid_file = strcmp(flags.pid_file, "none") ? flags.pid_file : NULL;
}
if (flags.quotes_file) {
opt->quotes_file = flags.quotes_file;
}
if (flags.journal_file && !strcmp(flags.journal_file, "-")) {
opt->journal_file = flags.journal_file;
} else {
opt->journal_file = NULL;
}
if (flags.iproto != PROTOCOL_INONE) {
opt->iproto = flags.iproto;
}
if (flags.tproto != PROTOCOL_TNONE) {
opt->tproto = flags.tproto;
}
if (flags.daemonize != BOOLEAN_UNSET) {
opt->daemonize = flags.daemonize;
}
#if DEBUG
journal("\nContents of struct 'opt':\n");
journal("opt = {\n");
journal(" QuotesFile: %s\n", BOOLSTR(opt->quotes_file));
journal(" PidFile: %s\n", opt->pid_file);
journal(" Port: %u\n", opt->port);
journal(" QuoteDivider: %s\n", name_option_quote_divider(opt->linediv));
journal(" Protocol: %s\n", name_option_protocol(opt->tproto, opt->iproto));
journal(" Daemonize: %s\n", BOOLSTR(opt->daemonize));
journal(" RequirePidfile: %s\n", BOOLSTR(opt->require_pidfile));
journal(" DropPrivileges: %s\n", BOOLSTR(opt->drop_privileges));
journal(" DailyQuotes: %s\n", BOOLSTR(opt->is_daily));
journal(" AllowBigQuotes: %s\n", BOOLSTR(opt->allow_big));
journal(" ChdirRoot: %s\n", BOOLSTR(opt->chdir_root));
journal("}\n\n");
#endif /* DEBUG */
}
int main(int argc, char** argv)
{
DynareParams params(argc, argv);
if (params.help) {
params.printHelp();
return 0;
}
if (params.version) {
printf("Dynare++ v. %s. Copyright (C) 2004-2011, Ondra Kamenik\n",
DYNVERSION);
printf("Dynare++ comes with ABSOLUTELY NO WARRANTY and is distributed under\n");
printf("GPL: modules integ, tl, kord, sylv, src, extern and documentation\n");
printf("LGPL: modules parser, utils\n");
printf(" for GPL see http://www.gnu.org/licenses/gpl.html\n");
printf(" for LGPL see http://www.gnu.org/licenses/lgpl.html\n");
return 0;
}
THREAD_GROUP::max_parallel_threads = params.num_threads;
try {
// make journal name and journal
std::string jname(params.basename);
jname += ".jnl";
Journal journal(jname.c_str());
// make dynare object
Dynare dynare(params.modname, params.order, params.ss_tol, journal);
// make list of shocks for which we will do IRFs
vector<int> irf_list_ind;
if (params.do_irfs_all)
for (int i = 0; i < dynare.nexog(); i++)
irf_list_ind.push_back(i);
else
irf_list_ind = ((const DynareNameList&)dynare.getExogNames()).selectIndices(params.irf_list);
// write matlab files
FILE* mfd;
std::string mfile1(params.basename);
mfile1 += "_f.m";
if (NULL == (mfd=fopen(mfile1.c_str(), "w"))) {
fprintf(stderr, "Couldn't open %s for writing.\n", mfile1.c_str());
exit(1);
}
ogdyn::MatlabSSWriter writer0(dynare.getModel(), params.basename.c_str());
writer0.write_der0(mfd);
fclose(mfd);
std::string mfile2(params.basename);
mfile2 += "_ff.m";
if (NULL == (mfd=fopen(mfile2.c_str(), "w"))) {
fprintf(stderr, "Couldn't open %s for writing.\n", mfile2.c_str());
exit(1);
}
ogdyn::MatlabSSWriter writer1(dynare.getModel(), params.basename.c_str());
writer1.write_der1(mfd);
fclose(mfd);
// open mat file
std::string matfile(params.basename);
matfile += ".mat";
mat_t* matfd = Mat_Create(matfile.c_str(), NULL);
if (matfd == NULL) {
fprintf(stderr, "Couldn't open %s for writing.\n", matfile.c_str());
exit(1);
}
// write info about the model (dimensions and variables)
dynare.writeMat(matfd, params.prefix);
// write the dump file corresponding to the input
dynare.writeDump(params.basename);
system_random_generator.initSeed(params.seed);
tls.init(dynare.order(),
dynare.nstat()+2*dynare.npred()+3*dynare.nboth()+
2*dynare.nforw()+dynare.nexog());
Approximation app(dynare, journal, params.num_steps, params.do_centralize, params.qz_criterium);
try {
app.walkStochSteady();
} catch (const KordException& e) {
// tell about the exception and continue
printf("Caught (not yet fatal) Kord exception: ");
e.print();
JournalRecord rec(journal);
rec << "Solution routine not finished (" << e.get_message()
<< "), see what happens" << endrec;
}
std::string ss_matrix_name(params.prefix);
ss_matrix_name += "_steady_states";
ConstTwoDMatrix(app.getSS()).writeMat(matfd, ss_matrix_name.c_str());
// check the approximation
if (params.check_along_path || params.check_along_shocks
|| params.check_on_ellipse) {
GlobalChecker gcheck(app, THREAD_GROUP::max_parallel_threads, journal);
if (params.check_along_shocks)
gcheck.checkAlongShocksAndSave(matfd, params.prefix,
params.getCheckShockPoints(),
params.getCheckShockScale(),
params.check_evals);
if (params.check_on_ellipse)
gcheck.checkOnEllipseAndSave(matfd, params.prefix,
params.getCheckEllipsePoints(),
params.getCheckEllipseScale(),
params.check_evals);
if (params.check_along_path)
gcheck.checkAlongSimulationAndSave(matfd, params.prefix,
params.getCheckPathPoints(),
params.check_evals);
}
// write the folded decision rule to the Mat-4 file
app.getFoldDecisionRule().writeMat(matfd, params.prefix);
// simulate conditional
if (params.num_condper > 0 && params.num_condsim > 0) {
SimResultsDynamicStats rescond(dynare.numeq(), params.num_condper, 0);
ConstVector det_ss(app.getSS(),0);
rescond.simulate(params.num_condsim, app.getFoldDecisionRule(), det_ss, dynare.getVcov(), journal);
rescond.writeMat(matfd, params.prefix);
}
// simulate unconditional
//const DecisionRule& dr = app.getUnfoldDecisionRule();
const DecisionRule& dr = app.getFoldDecisionRule();
if (params.num_per > 0 && params.num_sim > 0) {
SimResultsStats res(dynare.numeq(), params.num_per, params.num_burn);
res.simulate(params.num_sim, dr, dynare.getSteady(), dynare.getVcov(), journal);
res.writeMat(matfd, params.prefix);
// impulse response functions
if (! irf_list_ind.empty()) {
IRFResults irf(dynare, dr, res, irf_list_ind, journal);
irf.writeMat(matfd, params.prefix);
}
}
// simulate with real-time statistics
if (params.num_rtper > 0 && params.num_rtsim > 0) {
RTSimResultsStats rtres(dynare.numeq(), params.num_rtper, params.num_burn);
rtres.simulate(params.num_rtsim, dr, dynare.getSteady(), dynare.getVcov(), journal);
rtres.writeMat(matfd, params.prefix);
}
Mat_Close(matfd);
} catch (const KordException& e) {
printf("Caugth Kord exception: ");
e.print();
return e.code();
} catch (const TLException& e) {
printf("Caugth TL exception: ");
e.print();
return 255;
} catch (SylvException& e) {
printf("Caught Sylv exception: ");
e.printMessage();
return 255;
} catch (const DynareException& e) {
printf("Caught Dynare exception: %s\n", e.message());
return 255;
} catch (const ogu::Exception& e) {
printf("Caught ogu::Exception: ");
e.print();
return 255;
} catch (const ogp::ParserException& e) {
printf("Caught parser exception: %s\n", e.message());
return 255;
}
return 0;
}
static void WRITETOJOURNAL(const BufBuilder& bb) {
journal(bb);
}
