QString hostId()
{
static QString id;
unsigned char guid[100] = "", md[SHA_DIGEST_LENGTH];
if (!id.isEmpty())
return id;
#if defined(Q_OS_WIN32)
#define REG_CRYPTO "SOFTWARE\\Microsoft\\Cryptography"
#define REG_GUID "MachineGuid"
ULONG dwGuid = sizeof guid;
HKEY hKey;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, REG_CRYPTO, 0,
KEY_WOW64_64KEY|KEY_READ, &hKey) != ERROR_SUCCESS) {
XCA_WARN("Registry Key: '" REG_CRYPTO "' not found");
} else {
if (RegQueryValueEx(hKey, REG_GUID, NULL, NULL,
guid, &dwGuid) != ERROR_SUCCESS) {
XCA_WARN("Registry Key: '" REG_CRYPTO "\\" REG_GUID
"' not found");
}
}
RegCloseKey(hKey);
#elif defined(Q_OS_MAC)
io_registry_entry_t ioRegistryRoot = IORegistryEntryFromPath(
kIOMasterPortDefault, "IOService:/");
CFStringRef uuidCf = (CFStringRef)IORegistryEntryCreateCFProperty(
ioRegistryRoot, CFSTR(kIOPlatformUUIDKey),
kCFAllocatorDefault, 0);
snprintf((char*)guid, sizeof guid, "%s", CCHAR(
QString::fromUtf16(CFStringGetCharactersPtr(uuidCf))
));
IOObjectRelease(ioRegistryRoot);
CFRelease(uuidCf);
#else
QString mach_id;
QStringList dirs; dirs <<
"/etc" << "/var/lib/dbus" << "/var/db/dbus";
foreach(QString dir, dirs) {
QFile file(dir + "/machine-id");
if (file.open(QIODevice::ReadOnly)) {
QTextStream in(&file);
mach_id = in.readLine().trimmed();
file.close();
}
qDebug() << "ID:" << mach_id;
if (!mach_id.isEmpty()) {
snprintf((char*)guid, sizeof guid, "%s", CCHAR(mach_id));
break;
}
}
static void handle_option(QString opt)
{
QStringList sl = opt.split('=');
if (sl.count() != 2) {
printf("No '=' found in: '%s'\n", CCHAR(opt));
return;
}
if (!sl[0].compare("database")) {
database = set_db(CCHAR(sl[1]));
}
}
int compgetc(Obj p){
int c;
Obj cp = CDR(p), r;
switch (SUBSUBPORT(p)){
case COMP_T:
case COMP_ECHO:
c = readchar( CAR(cp));
writechar( CDR(cp), c);
break;
case COMP_2WAY:
c = readchar( CAR(cp));
break;
case COMP_CONCAT:
c = readchar( CAR(cp));
if( c == EOF ){
/* go to next component */
CDR(p) = CDR(cp);
if( NULLP(CDR(p))){
CAR(p) = IC_NIL;
c = EOF;
}else{
c = compgetc(p);
}
}
break;
case COMP_SYNO:
r = Fgetc( getvalue(cp));
if( r == IC_EOF )
return EOF;
if( !ICHARP(r) )
return JLERROR("#<internal:compgetc>", r, "synonym-port returned a non-char");
c = CCHAR(r);
break;
case COMP_FUNC:
r = funcall_0("#<internal:compgetc>", CVECTOR(cp)[0]);
if( r == IC_EOF )
return EOF;
if( !ICHARP(r) )
return JLERROR("#<internal:compgetc>", r, "function-port returned a non-char");
c = CCHAR(r);
break;
default:
c = EOF;
break;
}
return c;
}
QString pki_evp::sha512passwd(QString pass, QString salt)
{
EVP_MD_CTX mdctx;
QString str;
int n;
int j;
unsigned char m[EVP_MAX_MD_SIZE];
if (salt.length() <5)
abort();
str = salt.left(5);
pass = str + pass;
EVP_DigestInit(&mdctx, EVP_sha512());
EVP_DigestUpdate(&mdctx, CCHAR(pass), pass.size());
EVP_DigestFinal(&mdctx, m, (unsigned*)&n);
for (j=0; j<n; j++) {
char zs[4];
sprintf(zs, "%02X",m[j]);
str += zs;
}
return str;
}
void
new_monster(THING *tp, int type, const coord *cp)
{
struct monster *mp;
int lev_add;
if ((lev_add = level - AMULETLEVEL) < 0)
lev_add = 0;
attach(mlist, tp);
tp->t_type = type;
tp->t_disguise = type;
tp->t_pos = *cp;
move(cp->y, cp->x);
tp->t_oldch = CCHAR( inch() );
tp->t_room = roomin(cp);
moat(cp->y, cp->x) = tp;
mp = &monsters[tp->t_type-'A'];
tp->t_stats.s_lvl = mp->m_stats.s_lvl + lev_add;
tp->t_stats.s_maxhp = tp->t_stats.s_hpt = roll(tp->t_stats.s_lvl, 8);
tp->t_stats.s_arm = mp->m_stats.s_arm - lev_add;
strcpy(tp->t_stats.s_dmg,mp->m_stats.s_dmg);
tp->t_stats.s_str = mp->m_stats.s_str;
tp->t_stats.s_exp = mp->m_stats.s_exp + lev_add * 10 + exp_add(tp);
tp->t_flags = mp->m_flags;
if (level > 29)
tp->t_flags |= ISHASTE;
tp->t_turn = TRUE;
tp->t_pack = NULL;
if (ISWEARING(R_AGGR))
runto(cp);
if (type == 'X')
tp->t_disguise = rnd_thing();
}
void pki_base::my_error(const QString error) const
{
if (!error.isEmpty()) {
fprintf(stderr, "%s\n", CCHAR(tr("Error: ") + error));
throw errorEx(error, class_name);
}
}
x509name NewX509::getX509name(int _throw)
{
x509name x;
int j, row, nid;
try {
for (j = 0; j<EXPLICIT_NAME_CNT; j++) {
nid = name_nid[j];
x.addEntryByNid(nid, name_ptr[j]->text());
}
row = extDNlist->rowCount();
for (j=0; j<row; j++) {
QStringList l = extDNlist->getRow(j);
nid = OBJ_txt2nid(CCHAR(l[0]));
x.addEntryByNid(nid, l[1]);
}
} catch (errorEx &err) {
if (!err.isEmpty()) {
if (_throw)
throw err;
else
QMessageBox::warning(this, XCA_TITLE, err.getString());
}
}
return x;
}
void MainWindow::dump_database()
{
QString dirname = QFileDialog::getExistingDirectory(this, tr(XCA_TITLE),
getPath());
if (dirname.isEmpty())
return;
QDir d(dirname);
if ( ! d.exists() && !d.mkdir(dirname)) {
errorEx err("Could not create '" + dirname + "'");
MainWindow::Error(err);
return;
}
printf("Dumping to %s\n", CCHAR(dirname));
try {
keys->dump(dirname);
certs->dump(dirname);
temps->dump(dirname);
crls->dump(dirname);
reqs->dump(dirname);
}
catch (errorEx &err) {
MainWindow::Error(err);
}
}
/*
* whgtchk:
* See if the hero can carry his pack
*/
void
wghtchk(void)
{
reg int dropchk, err = TRUE;
reg int ch;
inwhgt = TRUE;
if (pstats.s_pack > pstats.s_carry) {
ch = CCHAR( mvwinch(stdscr, hero.y, hero.x) );
if((ch != FLOOR && ch != PASSAGE)) {
extinguish(wghtchk);
fuse(wghtchk,(void *)TRUE,1,AFTER);
inwhgt = FALSE;
return;
}
extinguish(wghtchk);
msg("Your pack is too heavy for you.");
do {
dropchk = drop(NULL);
if(dropchk == 0) {
mpos = 0;
msg("You must drop something.");
}
if(dropchk == TRUE)
err = FALSE;
} while(err);
}
inwhgt = FALSE;
}
bool _ign_openssl_error(const QString txt, const char *file, int line)
{
// ignore openssl errors
QString errtxt;
#if PRINT_IGNORED_ANYWAY
if (!txt.isEmpty() && ERR_peek_error())
fprintf(stderr, "%s\n", CCHAR(txt));
#endif
while (int i = ERR_get_error() ) {
errtxt = ERR_error_string(i, NULL);
#if PRINT_IGNORED_ANYWAY
fprintf(stderr, CCHAR(QString("IGNORED (%1:%2) : %3\n").
arg(file).arg(line).arg(errtxt)));
#endif
}
return !errtxt.isEmpty();
}
static void QString2lb(QListWidget *lb, QString x)
{
QStringList li = x.split(", ");
QList<QListWidgetItem *> items;
for (int i=0; i<li.size(); i++) {
QString lname = OBJ_sn2ln(CCHAR(li[i]));
items = lb->findItems(lname, Qt::MatchExactly);
if (items.size() > 0)
lb->setItemSelected(items[0], 1);
}
}
static QString lb2QString(QListWidget *lb)
{
QStringList sl;
for (int i=0; i<lb->count(); i++) {
QListWidgetItem *item = lb->item(i);
if (lb->isItemSelected(item)) {
sl << QString(OBJ_ln2sn(CCHAR(item->text())));
}
}
return sl.join(", ");
}
void MainWindow::setOptions()
{
Options *opt = new Options(this);
opt->setStringOpt(string_opt);
opt->setupPkcs11Provider(pkcs11path);
if (!opt->exec()) {
delete opt;
enableTokenMenu(pkcs11::loaded());
return;
}
QString alg = opt->hashAlgo->currentHashName();
db mydb(dbfile);
mydb.set((const unsigned char *)CCHAR(alg), alg.length()+1, 1,
setting, "default_hash");
hashBox::setDefault(alg);
mandatory_dn = opt->getDnString();
mydb.set((const unsigned char *)CCHAR(mandatory_dn),
mandatory_dn.length()+1, 1, setting, "mandatory_dn");
if (opt->getStringOpt() != string_opt) {
string_opt = opt->getStringOpt();
ASN1_STRING_set_default_mask_asc((char *)CCHAR(string_opt));
mydb.set((const unsigned char *)CCHAR(string_opt),
string_opt.length()+1, 1, setting,"string_opt");
}
QString newpath = opt->getPkcs11Provider();
if (newpath != pkcs11path) {
pkcs11path = newpath;
mydb.set((const unsigned char *) CCHAR(pkcs11path),
pkcs11path.length()+1, 1,setting, "pkcs11path");
}
enableTokenMenu(pkcs11::loaded());
delete opt;
}
void MainWindow::import_dbdump()
{
extern int read_dump(const char *, db_base **, char *, int);
char buf[50];
db_base *dbl[] = { keys, reqs, certs, temps, crls };
if (!keys)
return;
QString pass;
QString file = QFileDialog::getOpenFileName(this, tr(XCA_TITLE), homedir,
tr("Database dump ( *.dump );;All files ( * )"));
if (file.isEmpty())
return;
pass_info p(tr("Import password"),
tr("Please enter the password of the old database"), this);
if (passRead(buf, 50, 0, &p) <0)
return;
pass = buf;
try {
read_dump(CCHAR(file), dbl, buf, 50);
if (pki_evp::md5passwd(CCHAR(pass)) != buf) {
int ret = QMessageBox::warning(this, tr(XCA_TITLE),
tr("Password verification error. Ignore keys ?"),
tr("Import anyway"), tr("Cancel"));
if (ret)
return;
}
pki_evp::setOldPasswd(CCHAR(pass));
read_dump(CCHAR(file), dbl, NULL, 0);
pki_evp::eraseOldPasswd();
} catch (errorEx &err) {
Error(err);
}
}
int
fallpos(coord pos, coord *newpos) /*ARGSUSED*/
{
int y, x, cnt;
coord places[9];
cnt = 0;
/* look for all the places that qualify */
for (y = pos.y - 1; y <= pos.y + 1; y++)
{
for (x = pos.x - 1; x <= pos.x + 1; x++)
{
switch(CCHAR(mvwinch(stdscr,y,x)))
{
case GOLD:
case POTION:
case SCROLL:
case FOOD:
case WEAPON:
case ARMOR:
case RING:
case STICK:
case FLOOR:
case PASSAGE:
case ARTIFACT:
places[cnt].y = y;
places[cnt].x = x;
cnt++;
}
}
}
/* now, pick one of the places, if there are any */
if (cnt > 0)
{
int which = rnd(cnt);
newpos->y = places[which].y;
newpos->x = places[which].x;
debug("Dropping object at %d, %d", newpos->y, newpos->x);
}
return(cnt);
}
void _openssl_error(const QString txt, const char *file, int line)
{
QString error;
while (int i = ERR_get_error() ) {
error += QString(ERR_error_string(i, NULL)) + "\n";
fputs(CCHAR(QString("OpenSSL error (%1:%2) : %3\n").
arg(file).arg(line).arg(ERR_error_string(i, NULL))),
stderr);
}
if (!error.isEmpty()) {
if (!txt.isEmpty())
error = txt + "\n" + error + "\n" +
QString("(%1:%2)").arg(file).arg(line);
throw errorEx(error);
}
}
void pki_multi::fromPEM_BIO(BIO *bio, QString name)
{
QString text;
pki_base *item = NULL;
char buf[BUFLEN];
int len, startpos;
for (;;) {
try {
int pos = BIO_tell(bio);
len = BIO_read(bio, buf, BUFLEN-1);
buf[len] = '\0';
text = buf;
item = pkiByPEM(text, &startpos);
if (!item) {
if (startpos <= 0)
break;
if (BIO_seek(bio, pos + startpos) == -1)
throw errorEx(tr("Seek failed"));
continue;
}
pos += startpos;
if (BIO_seek(bio, pos) == -1)
throw errorEx(tr("Seek failed"));
item->fromPEM_BIO(bio, name);
if (pos == BIO_tell(bio)) {
/* No progress, do it manually */
if (BIO_seek(bio, pos + 1))
throw errorEx(tr("Seek failed"));
printf("Could not load: %s\n",
CCHAR(item->getClassName()));
delete item;
continue;
}
openssl_error();
multi.append(item);
} catch (errorEx &err) {
MainWindow::Error(err);
if (item)
delete item;
item = NULL;
}
}
if (multi.size() == 0)
throw errorEx(tr("No known PEM encoded items found"));
}
fuse
wghtchk(fuse_arg *arg)
{
int dropchk, err = TRUE;
char ch;
NOOP(arg);
inwhgt = TRUE;
if (pstats.s_pack > pstats.s_carry)
{
ch = CCHAR( mvwinch(stdscr, hero.y, hero.x) );
if ((ch != FLOOR && ch != PASSAGE))
{
extinguish_fuse(FUSE_WGHTCHK);
light_fuse(FUSE_WGHTCHK, (void *)TRUE, 1, AFTER);
inwhgt = FALSE;
return;
}
extinguish_fuse(FUSE_WGHTCHK);
msg("Your pack is too heavy for you.");
do
{
dropchk = drop(NULL);
if (dropchk == FALSE)
{
mpos = 0;
msg("You must drop something.");
}
if (dropchk == TRUE)
err = FALSE;
}
while (err);
}
inwhgt = FALSE;
}
/*
* set_oldch:
* Set the oldch character for the monster
*/
void
set_oldch(THING *tp, const coord *cp)
{
int sch;
if (ce(tp->t_pos, *cp))
return;
sch = tp->t_oldch;
tp->t_oldch = CCHAR( mvinch(cp->y,cp->x) );
if (!on(player, ISBLIND))
{
if ((sch == FLOOR || tp->t_oldch == FLOOR) &&
(tp->t_room->r_flags & ISDARK))
tp->t_oldch = ' ';
else if (dist_cp(cp, &hero) <= LAMPDIST && see_floor)
tp->t_oldch = chat(cp->y, cp->x);
}
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_char( obj_t o, obj_t op ) {
int c = CCHAR( o );
void *ostream = PORT_STREAM( op );
if( (c > 0) && (c < 128) && char_name[ c ][ 0 ] ) {
unsigned char *name = char_name[ c ];
PUTC( op, '#' );
PUTC( op, '\\' );
bgl_write( op, name, strlen( name ) );
} else {
PUTC( op, '#' );
PUTC( op, 'a' );
PRINTF1( op, 4, "%03d", (unsigned char)(c) );
}
return op;
}
/*---------------------------------------------------------------------*/
BGL_EXPORTED_DEF
long
obj_to_cobj( obj_t obj ) {
if( INTEGERP( obj ) )
return (long)CINT( obj );
if( BOOLEANP( obj ) )
return (long)((long)CBOOL( obj ));
if( STRINGP( obj ) )
return (long)BSTRING_TO_STRING( obj );
if( CHARP( obj ) )
return (long)((long)CCHAR( obj ));
if( FOREIGNP( obj ) )
return (long)FOREIGN_TO_COBJ( obj );
if( REALP( obj ) )
return (long)the_failure( string_to_bstring( "obj->cobj" ),
string_to_bstring( "Can't cast a real to foreign" ),
obj);
else
return (long)the_failure( string_to_bstring( "obj->cobj" ),
string_to_bstring( "Illegal object type" ),
obj);
}
void NewX509::setupExtDNwidget(const QString &s, QLineEdit *l)
{
setupLineEditByNid(OBJ_txt2nid(CCHAR(s)), l);
}
int read_dump(const char *filename, db_base **dbs, char *md5, int md5_len)
{
char *p;
int ret = -1, retlen = 0;
int kv=0;
bool md5sum = false;
pki_base *pki = NULL;
db_base *db;
QFile file;
QString line;
file.setFileName(filename);
if (! file.open(QIODevice::ReadOnly)) {
throw errorEx(filename, strerror(errno));
return -1;
}
for (;;) {
line = readLine(&file);
//printf("Line: '%s'\n", CCHAR(line));
if (line.isNull()) {
ret = 0;
break;
}
//printf("FIRST char = '%c'\n", CCHAR(line)[0]);
if (line[0] == ' ') {
if (database >= 0 && database < 5)
db = dbs[database];
else
db = NULL;
kv ^= 1;
p = read_data(CCHAR(line.trimmed()), &retlen);
if (db && !md5) {
if (kv) {
pki = db->newPKI();
if (!pki) {
break;
}
pki->setIntName(p);
} else {
try {
pki->oldFromData((unsigned char*)p, retlen);
db->insert(pki);
} catch (errorEx &err) {
printf("Error catched for '%s'\n", CCHAR(pki->getIntName()));
}
}
} else if (md5) {
if (database == 5) {
p = read_data(CCHAR(line.trimmed()), &retlen);
if (kv)
md5sum = (!strcmp(p, "pwhash")) ? true : false;
if (!kv && md5sum) {
strncpy(md5, p, md5_len);
ret = 0;
break;
}
}
}
free(p);
} else {
if (kv) {
printf("Binary value expected\n");
break;
}
handle_option(line);
}
}
file.close();
if (ret <0) {
throw errorEx(filename, strerror(errno));
return -1;
}
return 0;
}
QString asn1ToQString(const ASN1_STRING *str, bool quote)
{
QString qs;
unsigned short *bmp;
int i;
if (!str)
return qs;
switch (str->type) {
case V_ASN1_BMPSTRING:
bmp = (unsigned short*)str->data;
for (i = 0; i < str->length/2; i++) {
unsigned short s = ntohs(bmp[i]);
qs += QString::fromUtf16(&s, 1);
}
break;
case V_ASN1_UTF8STRING:
qs = QString::fromUtf8((const char*)str->data, str->length);
break;
case V_ASN1_T61STRING:
qs = QString::fromLocal8Bit((const char*)str->data, str->length);
break;
default:
qs = QString::fromLatin1((const char*)str->data, str->length);
}
#if 0
printf("Convert %s (%d %d) string to '%s' len %d:", ASN1_tag2str(str->type), str->type, V_ASN1_UTF8STRING, CCHAR(qs), str->length);
for (int i=0; i< str->length; i++)
printf(" %02x", str->data[i]);
printf("\n");
#endif
if (quote)
qs.replace('\n', "\\n\\");
return qs;
}
void
new_monster(struct linked_list *item, int type, coord *cp, int max_monster)
{
struct thing *tp;
struct monster *mp;
char *ip, *hitp;
int i, min_intel, max_intel;
int num_dice, num_sides = 8, num_extra = 0;
int eff_charisma = pstats.s_charisma;
int eff_intel = pstats.s_intel;
attach(mlist, item);
tp = THINGPTR(item);
tp->t_index = type;
tp->t_wasshot = FALSE;
tp->t_type = monsters[type].m_appear;
tp->t_ctype = C_MONSTER;
tp->t_no_move = 0;
tp->t_doorgoal = -1;
tp->t_pos = *cp;
tp->t_oldpos = *cp;
tp->t_oldch = CCHAR( mvwinch(cw, cp->y, cp->x) );
mvwaddch(mw, cp->y, cp->x, tp->t_type);
mp = &monsters[tp->t_index];
/* Figure out monster's hit points */
hitp = mp->m_stats.s_hpt;
num_dice = atoi(hitp);
if ((hitp = strchr(hitp, 'd')) != NULL)
{
num_sides = atoi(++hitp);
if ((hitp = strchr(hitp, '+')) != NULL)
num_extra = atoi(++hitp);
}
if (max_monster == MAXSTATS)
tp->t_stats.s_hpt = num_dice * num_sides + num_extra;
else
tp->t_stats.s_hpt = roll(num_dice, num_sides) + num_extra;
tp->t_stats.s_lvl = mp->m_stats.s_lvl;
tp->t_stats.s_arm = mp->m_stats.s_arm;
tp->t_stats.s_dmg = mp->m_stats.s_dmg;
tp->t_stats.s_exp = mp->m_stats.s_exp + mp->m_add_exp * tp->t_stats.s_hpt;
tp->t_stats.s_str = mp->m_stats.s_str;
if (max_level > 30)
{
tp->t_stats.s_hpt += roll(4, (max_level - 60) * 2);
tp->t_stats.s_lvl += roll(4, (max_level - 60) / 8);
tp->t_stats.s_arm -= roll(2, (max_level - 60) / 8);
tp->t_stats.s_str += roll(2, (max_level - 60) / 12);
tp->t_stats.s_exp += roll(4, (max_level - 60) * 2) * mp->m_add_exp;
}
/*
* just initailize others values to something reasonable for now
* maybe someday will *really* put these in monster table
*/
tp->t_stats.s_wisdom = 8 + rnd(4);
tp->t_stats.s_dext = 8 + rnd(4);
tp->t_stats.s_const = 8 + rnd(4);
tp->t_stats.s_charisma = 8 + rnd(4);
if (max_level > 45)
tp->t_stats.s_dext += roll(2, (max_level - 50) / 8);
/* Set the initial flags */
for (i = 0; i < 16; i++)
tp->t_flags[i] = 0;
for (i = 0; i < 16; i++)
turn_on(*tp, mp->m_flags[i]);
/* suprising monsters don't always surprise you */
if (!max_monster && on(*tp, CANSURPRISE) && rnd(100) < 20)
turn_off(*tp, CANSURPRISE);
/* If this monster is unique, genocide it */
if (on(*tp, ISUNIQUE))
mp->m_normal = FALSE;
/* gods automatically get special abilities */
if (on(*tp, ISGOD))
{
turn_on(*tp, CANFRIGHTEN);
turn_on(*tp, CANCAST);
turn_on(*tp, CANFLY);
turn_on(*tp, CANBARGAIN);
turn_on(*tp, ISLARGE);
turn_on(*tp, CANTELEPORT);
turn_on(*tp, CANSPEAK);
turn_on(*tp, CANDARKEN);
turn_on(*tp, CANSEE);
turn_on(*tp, CANLIGHT);
turn_on(*tp, BMAGICHIT);
}
tp->t_turn = TRUE;
tp->t_pack = NULL;
/* Figure intelligence */
min_intel = atoi(mp->m_intel);
if ((ip = (char *) strchr(mp->m_intel, '-')) == NULL)
tp->t_stats.s_intel = min_intel;
else
{
max_intel = atoi(++ip);
if (max_monster)
tp->t_stats.s_intel = max_intel;
else
tp->t_stats.s_intel = min_intel + rnd(max_intel - min_intel);
}
tp->t_stats.s_power = (rnd(tp->t_stats.s_lvl / 5) + 1) * tp->t_stats.s_intel;
tp->maxstats = tp->t_stats; /* structure assignment */
/* If the monster can shoot, it may have a weapon */
if (on(*tp, CANSHOOT) && (max_monster || rnd(9) < 6))
{
struct linked_list *thrower_item, *missile_item;
struct object *thrower, *a_missile;
thrower_item = new_item(sizeof *thrower);
thrower = OBJPTR(thrower_item);
carried_weapon(tp, thrower);
missile_item = new_item(sizeof *a_missile);
a_missile = OBJPTR(missile_item);
carried_weapon(tp, a_missile);
/* The monster may use a crossbow, sling, footbow, or an arrow */
/* Take racial preferences into account */
if ((strcmp(mp->m_name, "elf") == 0) ||
(strcmp(mp->m_name, "noldor elf") == 0))
{
thrower->o_which = BOW;
if (rnd(5) == 0)
a_missile->o_which = SILVERARROW;
else
a_missile->o_which = ARROW;
}
else if ((strcmp(mp->m_name, "dwarf") == 0) ||
(strcmp(mp->m_name, "kazad dwarf") == 0))
{
thrower->o_which = CROSSBOW;
a_missile->o_which = BOLT;
}
else if (on(*tp, ISSMALL))
{
switch (rnd(3))
{
case 0:
thrower->o_which = SLING;
a_missile->o_which = BULLET;
break;
default:
thrower->o_which = SLING;
a_missile->o_which = ROCK;
}
}
else if (on(*tp, ISLARGE))
{
switch (rnd(4))
{
case 0:
thrower->o_which = CROSSBOW;
a_missile->o_which = BOLT;
break;
case 1:
thrower->o_which = FOOTBOW;
a_missile->o_which = FBBOLT;
break;
default:
thrower->o_which = BOW;
if (rnd(5) == 0)
a_missile->o_which = FLAMEARROW;
else
a_missile->o_which = ARROW;
break;
}
}
else
{
switch (rnd(6))
{
case 1:
thrower->o_which = SLING;
a_missile->o_which = ROCK;
break;
case 2:
thrower->o_which = CROSSBOW;
a_missile->o_which = BOLT;
break;
case 3:
thrower->o_which = FOOTBOW;
a_missile->o_which = FBBOLT;
break;
case 4:
thrower->o_which = BOW;
a_missile->o_which = ARROW;
break;
default:
thrower->o_which = SLING;
a_missile->o_which = BULLET;
break;
}
}
init_weapon(thrower, thrower->o_which);
init_weapon(a_missile, a_missile->o_which);
attach(tp->t_pack, thrower_item);
attach(tp->t_pack, missile_item);
}
/* monsters that wield weapons */
if (on(*tp, CANWIELD))
{
if (max_monster || rnd(3))
{
struct linked_list *wield_item;
struct object *wielded;
wield_item = new_item(sizeof *wielded);
wielded = OBJPTR(wield_item);
carried_weapon(tp, wielded);
i = rnd(CLAYMORE - CLUB) + rnd(2 * tp->t_stats.s_lvl);
i = min(i, CLAYMORE);
wielded->o_which = i;
init_weapon(wielded, wielded->o_which);
/* Is it too heavy? */
if (itemweight(wielded) > 8 * tp->t_stats.s_str)
discard(wield_item);
else
attach(tp->t_pack, wield_item);
}
}
if (is_wearing(R_AGGR))
chase_it(cp, &player);
else
{
turn_off(*tp, ISRUN);
if (on(*tp, ISFLEE) && (rnd(4) == 0))
turn_off(*tp, ISFLEE);
if (rnd(luck) == 0)
switch (player.t_ctype)
{
case C_MAGICIAN:
case C_ILLUSION:
eff_intel = 2 * pstats.s_intel;
break;
case C_DRUID:
eff_intel = 2 * pstats.s_intel;
case C_RANGER:
eff_charisma = 2 * pstats.s_charisma;
break;
case C_ASSASIN:
case C_THIEF:
case C_NINJA:
eff_charisma = pstats.s_charisma / 2;
break;
}
/* LOWFRIENDLY monsters might be friendly */
i = roll(1,100);
if (i == 0 || (on(*tp, LOWFRIENDLY) && i < eff_charisma) ||
(on(*tp, MEDFRIENDLY) && i < 3 * eff_charisma) ||
(on(*tp, HIGHFRIENDLY) && i < 5 * eff_charisma))
{
turn_on(*tp, ISFRIENDLY);
turn_off(*tp, ISMEAN);
}
i = roll(1,100);
if (i == 0 || (on(*tp, LOWCAST) && i < eff_intel) ||
(on(*tp, MEDCAST) && i < 3 * eff_intel) ||
(on(*tp, HIGHCAST) && i < 5 * eff_intel))
{
turn_on(*tp, CANCAST);
}
if (on(*tp, ISDISGUISE))
{
char mch = 0;
if (tp->t_pack != NULL)
mch = (OBJPTR(tp->t_pack))->o_type;
else
switch (rnd(level > arts[0].ar_level ? 10 : 9))
{
case 0: mch = GOLD; break;
case 1: mch = POTION; break;
case 2: mch = SCROLL; break;
case 3: mch = FOOD; break;
case 4: mch = WEAPON; break;
case 5: mch = ARMOR; break;
case 6: mch = RING; break;
case 7: mch = STICK; break;
case 8: mch = monsters[randmonster(NOWANDER, NOGRAB)].m_appear;
break;
case 9: mch = ARTIFACT; break;
}
tp->t_disguise = mch;
}
}
}
/* <anonymous:1965> */
obj_t BGl_zc3anonymousza31965ze3z83zz__modulez00(obj_t BgL_envz00_1666, obj_t BgL_fz00_1668)
{ AN_OBJECT;
{ /* Llib/module.scm 213 */
{ /* Llib/module.scm 214 */
obj_t BgL_abasez00_1667;
BgL_abasez00_1667 =
PROCEDURE_REF(BgL_envz00_1666,
(int)(((long)0)));
{
obj_t BgL_fz00_896;
BgL_fz00_896 = BgL_fz00_1668;
{
obj_t BgL_fz00_903;obj_t BgL_abasez00_904;
BgL_fz00_903 = BgL_fz00_896;
BgL_abasez00_904 = BgL_abasez00_1667;
if(
STRINGP(BgL_fz00_903))
{ /* Llib/module.scm 203 */
bool_t BgL_testz00_2175;
if(
bigloo_strcmp(BgL_fz00_903, BGl_string2367z00zz__modulez00))
{ /* Llib/module.scm 203 */
BgL_testz00_2175 = ((bool_t)1)
; } else
{ /* Llib/module.scm 203 */
unsigned char BgL_arg1972z00_909;obj_t BgL_arg1973z00_910;
{ /* Llib/module.scm 203 */
obj_t BgL_s2257z00_1669;
BgL_s2257z00_1669 = BgL_fz00_903;
{ /* Llib/module.scm 203 */
long BgL_l2259z00_1671;
BgL_l2259z00_1671 =
STRING_LENGTH(BgL_s2257z00_1669);
if(
BOUND_CHECK(((long)0), BgL_l2259z00_1671))
{ /* Llib/module.scm 203 */
BgL_arg1972z00_909 =
STRING_REF(BgL_s2257z00_1669, ((long)0)); } else
{
obj_t BgL_auxz00_2182;
BgL_auxz00_2182 =
BGl_indexzd2outzd2ofzd2boundszd2errorz00zz__errorz00(BGl_string2330z00zz__modulez00,
BINT(((long)7865)), BGl_string2368z00zz__modulez00,
BINT(((long)0)), BgL_s2257z00_1669);
FAILURE(BgL_auxz00_2182,BFALSE,BFALSE);} } }
BgL_arg1973z00_910 =
BGl_filezd2separatorzd2zz__osz00();
{ /* Llib/module.scm 203 */
unsigned char BgL_char2z00_1445;
{ /* Llib/module.scm 203 */
obj_t BgL_auxz00_2188;
if(
CHARP(BgL_arg1973z00_910))
{ /* Llib/module.scm 203 */
BgL_auxz00_2188 = BgL_arg1973z00_910
; } else
{
obj_t BgL_auxz00_2191;
BgL_auxz00_2191 =
BGl_typezd2errorzd2zz__errorz00(BGl_string2330z00zz__modulez00,
BINT(((long)7897)), BGl_string2369z00zz__modulez00, BGl_string2370z00zz__modulez00, BgL_arg1973z00_910);
FAILURE(BgL_auxz00_2191,BFALSE,BFALSE);}
BgL_char2z00_1445 =
CCHAR(BgL_auxz00_2188); }
BgL_testz00_2175 =
(BgL_arg1972z00_909==BgL_char2z00_1445); } }
if(BgL_testz00_2175)
{ /* Llib/module.scm 203 */
return BgL_fz00_903;} else
{ /* Llib/module.scm 204 */
obj_t BgL_auxz00_2197;
if(
STRINGP(BgL_abasez00_904))
{ /* Llib/module.scm 204 */
BgL_auxz00_2197 = BgL_abasez00_904
; } else
{
obj_t BgL_auxz00_2200;
BgL_auxz00_2200 =
BGl_typezd2errorzd2zz__errorz00(BGl_string2330z00zz__modulez00,
BINT(((long)7928)), BGl_string2369z00zz__modulez00, BGl_string2355z00zz__modulez00, BgL_abasez00_904);
FAILURE(BgL_auxz00_2200,BFALSE,BFALSE);}
return
BGl_makezd2filezd2namez00zz__osz00(BgL_auxz00_2197, BgL_fz00_903);} } else
{ /* Llib/module.scm 202 */
return BgL_fz00_903;} } } } }
}
int
maze_view(int y, int x)
{
int start, goal, delt, ycheck = 0, xcheck = 0, absy, absx;
int row;
/* Get the absolute value of y and x differences */
absy = hero.y - y;
absx = hero.x - x;
if (absy < 0)
absy = -absy;
if (absx < 0)
absx = -absx;
/* Must be within one row or column */
if (absy > 1 && absx > 1)
return(FALSE);
if (absy <= 1) /* Go along row */
{
start = hero.x;
goal = x;
row = TRUE;
ycheck = hero.y;
}
else /* Go along column */
{
start = hero.y;
goal = y;
row = FALSE;
xcheck = hero.x;
}
if (start <= goal)
delt = 1;
else
delt = -1;
while (start != goal)
{
if (row)
xcheck = start;
else
ycheck = start;
switch(CCHAR(winat(ycheck, xcheck)))
{
case '|':
case '-':
case WALL:
case DOOR:
case SECRETDOOR:
return(FALSE);
default:
break;
}
start += delt;
}
return(TRUE);
}
builtin_curves::builtin_curves()
{
int i, num_curves = EC_get_builtin_curves(NULL, 0);
EC_builtin_curve *curves = (EC_builtin_curve*)OPENSSL_malloc(
(int)(sizeof(EC_builtin_curve) *num_curves));
check_oom(curves);
BIGNUM *order = BN_new();
check_oom(order);
EC_get_builtin_curves(curves, num_curves);
for (i=0; i< num_curves; i++) {
size_t j;
int flag = 0, nid = curves[i].nid;
unsigned long type = 0;
for (j=0; j<ARRAY_SIZE(x962_curve_nids); j++) {
if (x962_curve_nids[j] == nid) {
flag = CURVE_X962;
break;
}
}
if (!flag) {
for (j=0; j<ARRAY_SIZE(other_curve_nids); j++) {
if (other_curve_nids[j] == nid) {
flag = CURVE_OTHER;
break;
}
}
}
if (!flag)
continue;
EC_GROUP *group = EC_GROUP_new_by_curve_name(nid);
EC_GROUP_get_order(group, order, NULL);
switch (EC_METHOD_get_field_type(EC_GROUP_method_of(group))) {
case NID_X9_62_prime_field:
type = CKF_EC_F_P;
break;
case NID_X9_62_characteristic_two_field:
type = CKF_EC_F_2M;
break;
default:
continue;
}
#undef PRINT_KNOWN_CURVES
#ifdef PRINT_KNOWN_CURVES
fprintf(stderr, "%50s %27s %20s %s\n",
curves[i].comment, OBJ_nid2sn(nid),
CCHAR(OBJ_obj2QString(OBJ_nid2obj(nid), 1)),
type == CKF_EC_F_P ? "Fp" : "F2m");
#endif
append(builtin_curve(nid, QString(curves[i].comment),
BN_num_bits(order), flag, type));
EC_GROUP_free(group);
}
BN_free(order);
}
/*!
Load a spkac FILE into this request structure.
The file format follows the conventions understood by the 'openssl ca'
command. (see: 'man ca')
*/
int pki_x509req::load_spkac(const QString filename)
{
QFile file;
x509name subject;
EVP_PKEY *pktmp = NULL;
pki_ign_openssl_error();
file.setFileName(filename);
if (!file.open(QIODevice::ReadOnly))
return 1;
while (!file.atEnd()) {
int idx, nid;
QByteArray line = file.readLine();
if (line.size() == 0)
continue;
idx = line.indexOf('=');
if (idx == -1)
goto err;
QString type = line.left(idx).trimmed();
line = line.mid(idx+1).trimmed();
idx = type.lastIndexOf(QRegExp("[:,\\.]"));
if (idx != -1)
type = type.mid(idx+1);
if ((nid = OBJ_txt2nid(CCHAR(type))) == NID_undef) {
if (type != "SPKAC")
goto err;
pki_ign_openssl_error();
spki = NETSCAPE_SPKI_b64_decode(line, line.size());
if (!spki)
goto err;
/*
Now extract the key from the SPKI structure and
check the signature.
*/
pktmp = NETSCAPE_SPKI_get_pubkey(spki);
if (pktmp == NULL)
goto err;
if (NETSCAPE_SPKI_verify(spki, pktmp) != 1)
goto err;
} else {
// gather all values in the x509name subject.
subject.addEntryByNid(nid,
filename2QString(line.constData()));
}
}
if (!pktmp)
goto err;
setSubject(subject);
X509_REQ_set_pubkey(request, pktmp);
EVP_PKEY_free(pktmp);
return 0;
err:
if (pktmp)
EVP_PKEY_free(pktmp);
if (spki) {
NETSCAPE_SPKI_free(spki);
spki = NULL;
}
return 1;
}
void
look(int wakeup)
{
int x, y;
char ch, och;
int oldx, oldy;
int inpass, horizontal, vertical, do_light = FALSE, do_blank = FALSE;
int passcount = 0;
struct room *rp;
int ey, ex;
/* Are we moving vertically or horizontally? */
if (runch == 'h' || runch == 'l')
horizontal = TRUE;
else
horizontal = FALSE;
if (runch == 'j' || runch == 'k')
vertical = TRUE;
else
vertical = FALSE;
getyx(cw, oldy, oldx); /* Save current position */
/*
* Blank out the floor around our last position and check for moving
* out of a corridor in a maze.
*/
if (oldrp != NULL && (oldrp->r_flags & ISDARK) &&
!(oldrp->r_flags & HASFIRE) && off(player, ISBLIND))
do_blank = TRUE;
for (x = player.t_oldpos.x - 1; x <= player.t_oldpos.x + 1; x++)
for (y = player.t_oldpos.y - 1; y <= player.t_oldpos.y + 1;
y++)
{
ch = show(y, x);
if (do_blank && (y != hero.y || x != hero.x) && ch == FLOOR)
mvwaddch(cw, y, x, ' ');
/* Moving out of a corridor? */
if (levtype == MAZELEV &&
(ch != '|' && ch != '-') && /* Not a wall */
((vertical && x != player.t_oldpos.x &&
y == player.t_oldpos.y) ||
(horizontal && y != player.t_oldpos.y &&
x == player.t_oldpos.x)))
do_light = TRUE; /* Just came to a turn */
}
inpass = ((rp = roomin(hero)) == NULL); /* Are we in a passage? */
/* Are we coming out of a wall into a corridor in a maze? */
och = show(player.t_oldpos.y, player.t_oldpos.x);
ch = show(hero.y, hero.x);
if (levtype == MAZELEV && (och == '|' || och == '-' ||
och == SECRETDOOR) && (ch != '|' && ch != '-' && ch != SECRETDOOR))
{
do_light = off(player, ISBLIND); /* Light it up if not blind */
}
/* Look around the player */
ey = hero.y + 1;
ex = hero.x + 1;
for (x = hero.x - 1; x <= ex; x++)
if (x >= 0 && x < COLS)
for (y = hero.y - 1; y <= ey; y++)
{
if (y <= 0 || y >= LINES - 2)
continue;
if (isalpha(mvwinch(mw, y, x)))
{
struct linked_list *it;
struct thing *tp;
if (wakeup)
it = wake_monster(y, x);
else
it = find_mons(y, x);
if (it == NULL)
continue;
tp = THINGPTR(it);
tp->t_oldch = CCHAR( mvinch(y, x) );
if (isatrap(tp->t_oldch))
{
struct trap *trp = trap_at(y, x);
tp->t_oldch = (trp->tr_flags & ISFOUND) ? tp->t_oldch
: trp->tr_show;
}
if (tp->t_oldch == FLOOR &&
(rp->r_flags & ISDARK)
&& !(rp->r_flags & HASFIRE) &&
off(player, ISBLIND))
tp->t_oldch = ' ';
}
/* Secret doors show as walls */
if ((ch = show(y, x)) == SECRETDOOR)
ch = secretdoor(y, x);
/*
* Don't show room walls if he is in a
* passage and check for maze turns
*/
if (off(player, ISBLIND))
{
if (y == hero.y && x == hero.x || (inpass && (ch == '-' ||
ch == '|')))
continue;
/* Are we at a crossroads in a maze? */
if (levtype == MAZELEV && (ch != '|' && ch != '-') &&
/* Not a wall */
((vertical && x != hero.x && y == hero.y) ||
(horizontal && y != hero.y && x == hero.x)))
do_light = TRUE;
/* Just came to a turn */
}
else if (y != hero.y || x != hero.x)
continue;
wmove(cw, y, x);
waddch(cw, ch);
if (door_stop && !firstmove && running)
{
switch (runch)
{
case 'h':
if (x == ex)
continue;
break;
case 'j':
if (y == hero.y - 1)
continue;
break;
case 'k':
if (y == ey)
continue;
break;
case 'l':
if (x == hero.x - 1)
continue;
break;
case 'y':
if ((x + y) - (hero.x + hero.y) >= 1)
continue;
break;
case 'u':
if ((y - x) - (hero.y - hero.x) >= 1)
continue;
break;
case 'n':
if ((x + y) - (hero.x + hero.y) <= -1)
continue;
break;
case 'b':
if ((y - x) - (hero.y - hero.x) <= -1)
continue;
break;
}
switch (ch)
{
case DOOR:
if (x == hero.x || y == hero.y)
running = FALSE;
break;
case PASSAGE:
if (x == hero.x || y == hero.y)
passcount++;
break;
case FLOOR:
/*
* Stop by new passages in a
* maze (floor next to us)
*/
if ((levtype == MAZELEV) &&
((horizontal && x == hero.x && y != hero.y) ||
(vertical && y == hero.y && x != hero.x)))
running = FALSE;
case '|':
case '-':
case ' ':
break;
default:
running = FALSE;
break;
}
}
}
if (door_stop && !firstmove && passcount > 1)
running = FALSE;
/*
* Do we have to light up the area (just stepped into a new
* corridor)?
*/
if (do_light && wakeup && /* wakeup will be true on a normal move */
!(rp->r_flags & ISDARK) && /* We have some light */
!ce(hero, player.t_oldpos)) /* Don't do anything if we didn't move */
light(&hero);
mvwaddch(cw, hero.y, hero.x, PLAYER);
wmove(cw, oldy, oldx);
if (wakeup)
{
player.t_oldpos = hero; /* Don't change if we didn't move */
oldrp = rp;
}
}