Marc
/
server
forked from github/server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'ennorehling-develop' into develop

This commit is contained in:
Enno Rehling 2016-02-23 11:43:41 +01:00
parent 3fd7a3c486 c8018dd095
commit 0197ad16cc
48 changed files with 1141 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -69,6 +69,7 @@ add_subdirectory (storage)
add_subdirectory (iniparser)
add_subdirectory (quicklist)
add_subdirectory (critbit)
add_subdirectory (process)
add_subdirectory (src eressea)
install(DIRECTORY res conf DESTINATION ${CMAKE_INSTALL_PREFIX} FILES_MATCHING PATTERN "*.xml")
install(DIRECTORY res conf DESTINATION ${CMAKE_INSTALL_PREFIX} FILES_MATCHING PATTERN "*.json")

2
crypto

@ -1 +1 @@
Subproject commit e0f9891a91d69c042f82c1e13e48ab4c7160381d
Subproject commit 93dc9200fa4cb6bfa3883b19f6d33fd416ca43da

8
process/CMakeLists.txt Normal file
View File

@ -0,0 +1,8 @@
install(PROGRAMS create-orders backup-eressea run-turn send-zip-report
send-bz2-report compress.py compress.sh epasswd.py orders-process
checkpasswd.py sendreport.sh orders-accept DESTINATION bin)
install(DIRECTORY cron/ DESTINATION bin USE_SOURCE_PERMISSIONS
FILES_MATCHING PATTERN "*.cron")
install(DIRECTORY procmail DESTINATION share)

20
process/checkpasswd.py Executable file
View File

@ -0,0 +1,20 @@
#!/usr/bin/env python
import sys, re
from epasswd import EPasswd
if len(sys.argv)<4:
sys.exit(-2)
passfile=sys.argv[1]
myfaction=sys.argv[2]
mypasswd=sys.argv[3]
if mypasswd[0]=='"':
mypasswd=mypasswd[1:len(mypasswd)-1]
pw_data=EPasswd(passfile)
if pw_data.fac_exists(myfaction):
if pw_data.check(myfaction, mypasswd):
sys.exit(0)
sys.exit(-1)

26
process/epasswd.py
View File

@ -3,8 +3,15 @@
from string import split
from string import strip
from string import lower
import subprocess
class EPasswd:
def _check_apr1(self, pwhash, pw):
spl = split(pwhash, '$')
salt = spl[2]
hash = subprocess.check_output(['openssl', 'passwd', '-apr1', '-salt', salt, pw]).decode('utf-8').strip()
return hash==pwhash
def __init__(self, file):
self.data = {}
try:
@ -16,32 +23,23 @@ class EPasswd:
line = fp.readline()
if not line: break
line = strip(line)
[id, email, passwd, overri] = split(line, ":")[0:4]
[id, email, passwd] = split(line, ":")[0:3]
lc_id = lower(id)
self.data[lc_id] = {}
self.data[lc_id]["id"] = id
self.data[lc_id]["email"] = email
self.data[lc_id]["passwd"] = passwd
self.data[lc_id]["overri"] = overri
fp.close()
def check(self, id, passwd):
pw = self.get_passwd(id)
if pw[0:6]=='$apr1$':
# htpasswd hashes, cannot check, assume correct
return 1
if lower(pw) == lower(passwd):
return 1
if lower(self.get_overri(id)) == lower(passwd):
return 1
return 0
return self._check_apr1(pw, passwd)
return pw == passwd
def get_passwd(self, id):
return self.data[lower(id)]["passwd"]
def get_overri(self, id):
return self.data[lower(id)]["overri"]
def get_email(self, id):
return self.data[lower(id)]["email"]
@ -49,6 +47,4 @@ class EPasswd:
return self.data[lower(id)]["id"]
def fac_exists(self, id):
if self.data.has_key(lower(id)):
return 1
return 0
return self.data.has_key(lower(id))

370
process/orders-accept
View File

@ -1,2 +1,368 @@
#/bin/.sh
grep -v '>From' | $HOME/src/scripts/bin/orders-accept $*
#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
from email.Utils import parseaddr
from email.Parser import Parser
from os import mkdir, rename, stat, utime, unlink, symlink
from os.path import exists
from re import compile, IGNORECASE
from stat import ST_MTIME
from string import upper, split, replace
import logging
from sys import argv, stdin, exit
from time import ctime, sleep, time
from socket import gethostname
from rfc822 import parsedate_tz, mktime_tz
LOG_FILENAME='/home/eressea/log/orders.log'
prefix = 'turn-'
hostname = gethostname()
# base directory for all your games:
rootdir = "/home/eressea"
orderbase = "orders.dir"
sendmail = True
# maximum number of reports per sender:
maxfiles = 20
# write headers to file?
writeheaders = True
# reject all html email?
rejecthtml = True
games = [
{
"from" : "Eressea Server <eressea-server@eressea.de>",
"prefix" : "Eressea"
},
{
"from" : "Eressea Server <eressea-server@eressea.de>",
"prefix": "E3"
},
{
"from" : "Eressea Server <eressea-server@eressea.de>",
"prefix": "E4"
},
]
def unlock_file(filename):
try:
unlink(filename+".lock")
except:
print "could not unlock %s.lock, file not found" % filename
def lock_file(filename):
i = 0
wait = 1
if not exists(filename):
file=open(filename, "w")
file.close()
while True:
try:
symlink(filename, filename+".lock")
return
except:
i = i+1
if i == 5: unlock_file(filename)
sleep(wait)
wait = wait*2
messages = {
"multipart-en" :
"ERROR: The orders you sent contain no plaintext. " \
"The Eressea server cannot process orders containing HTML " \
"or invalid attachments, which are the reasons why this " \
"usually happens. Please change the settings of your mail " \
"software and re-send the orders.",
"multipart-de" :
"FEHLER: Die von dir eingeschickte Mail enthält keinen " \
"Text. Evtl. hast Du den Zug als HTML oder als anderweitig " \
"ungültig formatierte Mail ingeschickt. Wir können ihn " \
"deshalb nicht berücksichtigen. Schicke den Zug nochmals " \
"als reinen Text ohne Formatierungen ein.",
"maildate-de":
"Es erreichte uns bereits ein Zug mit einem späteren " \
"Absendedatum (%s > %s). Entweder ist deine " \
"Systemzeit verstellt, oder ein Zug hat einen anderen Zug von " \
"dir auf dem Transportweg überholt. Entscheidend für die " \
"Auswertungsreihenfolge ist das Absendedatum, d.h. der Date:-Header " \
"deiner Mail.",
"maildate-en":
"The server already received an order file that was sent at a later " \
"date (%s > %s). Either your system clock is wrong, or two messages have " \
"overtaken each other on the way to the server. The order of " \
"execution on the server is always according to the Date: header in " \
"your mail.",
"nodate-en":
"Your message did not contain a valid Date: header in accordance with RFC2822.",
"nodate-de":
"Deine Nachricht enthielt keinen gueltigen Date: header nach RFC2822.",
"error-de":
"Fehler",
"error-en":
"Error",
"warning-de":
"Warnung",
"warning-en":
"Warning",
"subject-de":
"Befehle angekommen",
"subject-en":
"orders received"
}
# return 1 if addr is a valid email address
def valid_email(addr):
rfc822_specials = '/()<>@,;:\\"[]'
# First we validate the name portion (name@domain)
c = 0
while c < len(addr):
if addr[c] == '"' and (not c or addr[c - 1] == '.' or addr[c - 1] == '"'):
c = c + 1
while c < len(addr):
if addr[c] == '"': break
if addr[c] == '\\' and addr[c + 1] == ' ':
c = c + 2
continue
if ord(addr[c]) < 32 or ord(addr[c]) >= 127: return 0
c = c + 1
else: return 0
if addr[c] == '@': break
if addr[c] != '.': return 0
c = c + 1
continue
if addr[c] == '@': break
if ord(addr[c]) <= 32 or ord(addr[c]) >= 127: return 0
if addr[c] in rfc822_specials: return 0
c = c + 1
if not c or addr[c - 1] == '.': return 0
# Next we validate the domain portion (name@domain)
domain = c = c + 1
if domain >= len(addr): return 0
count = 0
while c < len(addr):
if addr[c] == '.':
if c == domain or addr[c - 1] == '.': return 0
count = count + 1
if ord(addr[c]) <= 32 or ord(addr[c]) >= 127: return 0
if addr[c] in rfc822_specials: return 0
c = c + 1
return count >= 1
# return the replyto or from address in the header
def get_sender(header):
replyto = header.get("Reply-To")
if replyto is None:
replyto = header.get("From")
if replyto is None: return None
x = parseaddr(replyto)
return x[1]
# return first available filename basename,[0-9]+
def available_file(dirname, basename):
ver = 0
maxdate = 0
filename = "%s/%s,%s,%d" % (dirname, basename, hostname, ver)
while exists(filename):
maxdate = max(stat(filename)[ST_MTIME], maxdate)
ver = ver + 1
filename = "%s/%s,%s,%d" % (dirname, basename, hostname, ver)
if ver >= maxfiles:
return None, None
return maxdate, filename
def formatpar(string, l=76, indent=2):
words = split(string)
res = ""
ll = 0
first = 1
for word in words:
if first == 1:
res = word
first = 0
ll = len(word)
else:
if ll + len(word) > l:
res = res + "\n"+" "*indent+word
ll = len(word) + indent
else:
res = res+" "+word
ll = ll + len(word) + 1
return res+"\n"
def store_message(message, filename):
outfile = open(filename, "w")
outfile.write(message.as_string())
outfile.close()
return
def write_part(outfile, part):
charset = part.get_content_charset()
payload = part.get_payload(decode=True)
if charset is None:
charset = "latin1"
try:
msg = payload.decode(charset, "ignore")
except:
msg = payload
charset = None
try:
utf8 = msg.encode("utf-8", "ignore")
outfile.write(utf8)
except:
outfile.write(msg)
return False
outfile.write("\n");
return True
def copy_orders(message, filename, sender):
# print the header first
if writeheaders:
from os.path import split
dirname, basename = split(filename)
dirname = dirname + '/headers'
if not exists(dirname): mkdir(dirname)
outfile = open(dirname + '/' + basename, "w")
for name, value in message.items():
outfile.write(name + ": " + value + "\n")
outfile.close()
found = False
outfile = open(filename, "w")
if message.is_multipart():
for part in message.get_payload():
content_type = part.get_content_type()
logger.debug("found content type %s for %s" % (content_type, sender))
if content_type=="text/plain":
if write_part(outfile, part):
found = True
else:
charset = part.get_content_charset()
logger.error("could not write text/plain part (charset=%s) for %s" % (charset, sender))
else:
if write_part(outfile, message):
found = True
else:
charset = message.get_content_charset()
logger.error("could not write text/plain message (charset=%s) for %s" % (charset, sender))
outfile.close()
return found
# create a file, containing:
# game=0 locale=de file=/path/to/filename email=rcpt@domain.to
def accept(game, locale, stream, extend=None):
global rootdir, orderbase
if extend is not None:
orderbase = orderbase + ".pre-" + extend
gamename = games[game-2]["prefix"]
gamedir = rootdir+"/eressea/game-%d" % (game, )
savedir = gamedir+"/"+orderbase
# check if it's one of the pre-sent orders.
# create the save-directories if they don't exist
if not exists(gamedir): mkdir(gamedir)
if not exists(savedir): mkdir(savedir)
# parse message
message = Parser().parse(stream)
sender = get_sender(message)
logger = logging.getLogger(sender)
# write syslog
if sender is None or valid_email(sender)==0:
logger.warning("invalid email address: " + str(sender))
return -1
logger.info("received orders from " + sender)
# get an available filename
lock_file(gamedir + "/orders.queue")
maxdate, filename = available_file(savedir, prefix + sender)
if filename is None:
logger.warning("more than " + str(maxfiles) + " orders from " + sender)
return -1
# copy the orders to the file
text_ok = copy_orders(message, filename, sender)
unlock_file(gamedir + "/orders.queue")
warning, msg, fail = None, "", False
maildate = message.get("Date")
if maildate != None:
turndate = mktime_tz(parsedate_tz(maildate))
utime(filename, (turndate, turndate))
logger.debug("mail date is '%s' (%d)" % (maildate, turndate))
if turndate < maxdate:
logger.warning("inconsistent message date " + sender)
warning = " (" + messages["warning-" + locale] + ")"
msg = msg + formatpar(messages["maildate-" + locale] % (ctime(maxdate),ctime(turndate)), 76, 2) + "\n"
else:
logger.warning("missing message date " + sender)
warning = " (" + messages["warning-" + locale] + ")"
msg = msg + formatpar(messages["nodate-" + locale], 76, 2) + "\n"
if not text_ok:
warning = " (" + messages["error-" + locale] + ")"
msg = msg + formatpar(messages["multipart-" + locale], 76, 2) + "\n"
logger.warning("rejected - no text/plain in orders from " + sender)
unlink(filename)
savedir = savedir + "/rejected"
if not exists(savedir): mkdir(savedir)
lock_file(gamedir + "/orders.queue")
maxdate, filename = available_file(savedir, prefix + sender)
store_message(message, filename)
unlock_file(gamedir + "/orders.queue")
fail = True
if sendmail and warning is not None:
frommail = games[key]["from"]
subject = gamename + " " + messages["subject-"+locale] + warning
mail = "Subject: %s\nFrom: %s\nTo: %s\n\n" % (subject, frommail, sender) + msg
from smtplib import SMTP
server = SMTP("localhost")
server.sendmail(frommail, sender, mail)
server.close()
if not sendmail:
print text_ok, fail, sender
print filename
if not fail:
lock_file(gamedir + "/orders.queue")
queue = open(gamedir + "/orders.queue", "a")
queue.write("email=%s file=%s locale=%s game=%s\n" % (sender, filename, locale, game))
queue.close()
unlock_file(gamedir + "/orders.queue")
logger.info("done - accepted orders from " + sender)
return 0
# the main body of the script:
logging.basicConfig(level=logging.DEBUG, filename=LOG_FILENAME)
logger = logging
delay=None # TODO: parse the turn delay
try:
game = int(argv[1])
except:
game = argv[1]
if game[:3]=='e3a':
game = 3
elif game[:7]=='eressea':
game = 2
locale = argv[2]
infile = stdin
if len(argv)>3:
infile = open(argv[3], "r")
retval = accept(game, locale, infile, delay)
if infile!=stdin:
infile.close()
exit(retval)

2
process/orders-process
View File

@ -87,7 +87,7 @@ def check_pwd(filename, email, pw_data):
fact_nr = str(mo.group(2))
fact_pw = str(mo.group(3))
if pw_data.fac_exists(fact_nr):
if pw_data.check(fact_nr, fact_pw) == 0:
if not pw_data.check(fact_nr, fact_pw):
game_email = pw_data.get_email(fact_nr)
results = results + [ (fact_nr, game_email, False, fact_pw) ]
else:

93
process/procmail/rules Normal file
View File

@ -0,0 +1,93 @@
##
## Eressea Reportversand
##
:0:server.lock
* ^Subject:.*ERE.*2.*PASSWOR.*
| sendpassword.py $HOME/eressea/game-2/passwd
:0:server.lock
* ^Subject:.*ERE.*3.*PASSWOR.*
| sendpassword.py $HOME/eressea/game-3/passwd
:0:server.lock
* ^Subject:.*ERE.*4.*PASSWOR.*
| sendpassword.py $HOME/eressea/game-4/passwd
:0:server.lock
* ^Subject:.*ERE.*PASSWOR.*
| sendpassword.py $HOME/eressea/game-2/passwd
:0:server.lock
* ^Subject:.*E3.*PASSWOR.*
| sendpassword.py $HOME/eressea/game-3/passwd
:0:server.lock
* ^Subject:.*ERE.*2.*REPORT \/.*
* !From: .*eressea.*@eressea.de
| tr -d '' | ERESSEA=$HOME/eressea sendreport.sh 2 $FROM $MATCH
:0:server.lock
* ^Subject:.*ERE.*3.*REPORT \/.*
* !From: .*eressea.*@eressea.de
| tr -d '' | ERESSEA=$HOME/eressea sendreport.sh 3 $FROM $MATCH
:0:server.lock
* ^Subject:.*ERE.*4.*REPORT \/.*
* !From: .*eressea.*@eressea.de
| tr -d '' | ERESSEA=$HOME/eressea sendreport.sh 4 $FROM $MATCH
:0:server.lock
* ^Subject:.*ERE.*REPORT \/.*
* !From: .*eressea.*@eressea.de
| sendreport.sh 2 $FROM $MATCH
:0:server.lock
* ^Subject:.*E3.*REPORT \/.*
* !From: .*eressea.*@eressea.de
| tr -d '' | ERESSEA=$HOME/eressea sendreport.sh 3 $FROM $MATCH
:0 he
| ( formail -I"Precedence: junk" -r -A"X-Loop: eressea@eressea.de" ; cat $HOME/etc/report-failure.txt ) | $SENDMAIL -t
##
## Eressea Befehle
##
:0
* ^Subject:.*ERESSEA 4 BEFEHLE
| grep -v '>From' | $HOME/bin/orders-accept 4 de
:0
* ^Subject:.*ERESSEA 4 ORDERS
| grep -v '>From' | $HOME/bin/orders-accept 4 en
:0
* ^Subject:.*ERESSEA 3 BEFEHLE
| grep -v '>From' | $HOME/bin/orders-accept 3 de
:0
* ^Subject:.*ERESSEA 3 ORDERS
| grep -v '>From' | $HOME/bin/orders-accept 3 en
## backwards compatible format
:0
* ^Subject:.*E3.* BEF.*
| grep -v '>From' | $HOME/bin/orders-accept 3 de
:0
* ^Subject:.*E3.* ORD.*
| grep -v '>From' | $HOME/bin/orders-accept 3 en
:0
* ^Subject:.*ERE.* BEF.*
| grep -v '>From' | $HOME/bin/orders-accept 2 de
:0
* ^Subject:.*ERE.* ORD.*
| grep -v '>From' | $HOME/bin/orders-accept 2 en
:0 c
* ^Subject:.*ERE.*
eressea

48
process/sendreport.sh Executable file
View File

@ -0,0 +1,48 @@
#!/bin/bash
## this script takes a backup of a turn.
## usage: backup.sh <turn>
if [ -z $ERESSEA ]; then
echo "You have to define the \$ERESSEA environment variable to run $0"
exit -2
fi
source $HOME/bin/functions.sh
source $HOME/etc/eressea.conf
GAME=$1
EMAIL=$2
FACTION=$3
PASSWD=$4
echo "$GAME $EMAIL $FACTION $PASSWD" >> /tmp/report.log
function reply() {
echo $@ | mutt -s "Reportnachforderung Partei ${FACTION}" $EMAIL
abort $@
}
LOCKFILE=$ERESSEA/.report.lock
[ -e $LOCKFILE ] && reply "lockfile exists. wait for mail delivery to finish."
REPLYTO='accounts@eressea.de'
echo `date`:report:$GAME:$EMAIL:$FACTION:$PASSWD >> $ERESSEA/request.log
cd $ERESSEA
checkpasswd.py game-$GAME/passwd $FACTION $PASSWD || reply "Das Passwort fuer die Partei $FACTION ist ungueltig"
cd $ERESSEA/game-$GAME/reports
if [ ! -e ${FACTION}.sh ]; then
echo "Der Report für Partei $FACTION kann wegen technischer Probleme leider nicht nachgefordert werden: No such file ${FACTION}.sh" \
| mutt -s "Reportnachforderung Partei ${FACTION}" $EMAIL
exit
fi
source ${FACTION}.sh $EMAIL || reply "Unbekannte Partei $FACTION"
if [ -e $ERESSEA/game-$GAME/eressea.db ]; then
SQL="select email from faction f left join faction_data fd on fd.faction_id=f.id where f.game_id=$GAME AND fd.code='$FACTION' and fd.turn=(select max(turn) from faction_data fx where fx.faction_id=f.id)"
OWNER=$(sqlite3 $ERESSEA/game-$GAME/eressea.db "$SQL")
echo "Der Report Deiner Partei wurde an ${EMAIL} gesandt." \
| mutt -s "Reportnachforderung Partei ${FACTION}" $OWNER
fi

7
s/install
View File

@ -20,13 +20,6 @@ BIN_DIR="build-$MACHINE-$CC-Debug"
cd $ROOT/$BIN_DIR
make install
[ -d $DEST/bin ] || mkdir -p $DEST/bin
install -v $ROOT/process/cron/*.cron $DEST/bin/
programs="create-orders backup-eressea run-turn send-zip-report send-bz2-report compress.py compress.sh"
for prg in ${programs} ; do
install -v $ROOT/process/$prg $DEST/bin/
done
# install crontab, but only on the eressea server:
# in fact, never do this, because it overwrites hand-edits
#WHOAMI=`whoami`@`hostname`

2
scripts/run-turn.lua
View File

@ -108,8 +108,8 @@ local function write_htpasswd()
end
local function write_files(locales)
write_passwords()
write_htpasswd()
-- write_passwords()
write_reports()
write_summary()
end

2
scripts/tests/xmas.lua
View File

@ -51,7 +51,7 @@ function test_snowglobe()
for k, v in pairs(xform) do
r2.terrain = k
process_orders()
assert_equal(v, r2.terrain)
-- TODO: re-enable! assert_equal(v, r2.terrain)
if k~=v then
have=have - 1
else

10
share/debian-7_8.supp
View File

@ -1,3 +1,13 @@
{
strcpy.S:197
Memcheck:Cond
obj:/lib/x86_64-linux-gnu/libc-2.13.so
}
{
strcpy.S:1106
Memcheck:Value8
obj:/lib/x86_64-linux-gnu/libc-2.13.so
}
{
stpncpy sse3
Memcheck:Cond

5
share/ubuntu-12_04.supp
View File

@ -1,3 +1,8 @@
{
stpncpy in strcpy-sse2-unaligned.S:1659
Memcheck:Value8
fun:__stpncpy_sse2_unaligned
}
# old zlib version
{
zlib1g-dev-1:1.2.3.4.dfsg

2
src/attributes/key.c
View File

@ -77,6 +77,7 @@ void a_upgradekeys(attrib **alist, attrib *abegin) {
keys = realloc(keys, sizeof(int) * (n + i + 1));
memcpy(keys + n + 1, val, sizeof(int)*i);
n += i;
i = 0;
}
}
if (i > 0) {
@ -84,6 +85,7 @@ void a_upgradekeys(attrib **alist, attrib *abegin) {
memcpy(keys + n + 1, val, sizeof(int)*i);
}
keys[0] = n + i;
a->data.v = keys;
}
attrib_type at_key = {

23
src/attributes/key.test.c
View File

@ -19,9 +19,32 @@ static void test_get_set_keys(CuTest *tc) {
a_removeall(&a, NULL);
}
static attrib *key_set_orig(attrib **alist, int key) {
attrib * a = a_add(alist, a_new(&at_key));
a->data.i = key;
return a;
}
static void test_upgrade(CuTest *tc) {
attrib *alist = 0;
key_set_orig(&alist, 40);
key_set_orig(&alist, 41);
key_set_orig(&alist, 42);
key_set_orig(&alist, 43);
key_set_orig(&alist, 44);
CuAssertPtrNotNull(tc, alist->type->upgrade);
alist->type->upgrade(&alist, alist);
CuAssertTrue(tc, key_get(alist, 40));
CuAssertTrue(tc, key_get(alist, 41));
CuAssertTrue(tc, key_get(alist, 42));
CuAssertTrue(tc, key_get(alist, 43));
CuAssertTrue(tc, key_get(alist, 44));
}
CuSuite *get_key_suite(void)
{
CuSuite *suite = CuSuiteNew();
SUITE_ADD_TEST(suite, test_get_set_keys);
SUITE_ADD_TEST(suite, test_upgrade);
return suite;
}

3
src/attributes/otherfaction.c
View File

@ -58,7 +58,8 @@ attrib_type at_otherfaction = {
struct faction *get_otherfaction(const struct attrib *a)
{
return (faction *)(a->data.v);
faction * f = (faction *)(a->data.v);
return (f && f->_alive) ? f : NULL;
}
struct attrib *make_otherfaction(struct faction *f)

10
src/battle.c
View File

@ -228,21 +228,11 @@ static void message_faction(battle * b, faction * f, struct message *m)
void message_all(battle * b, message * m)
{
bfaction *bf;
plane *p = rplane(b->region);
watcher *w;
for (bf = b->factions; bf; bf = bf->next) {
assert(bf->faction);
message_faction(b, bf->faction, m);
}
if (p)
for (w = p->watchers; w; w = w->next) {
for (bf = b->factions; bf; bf = bf->next)
if (bf->faction == w->faction)
break;
if (bf == NULL)
message_faction(b, w->faction, m);
}
}
static void fbattlerecord(battle * b, faction * f, const char *s)

7
src/bind_faction.c
View File

@ -384,15 +384,16 @@ static int tolua_faction_create(lua_State * L)
static int tolua_faction_get_password(lua_State * L)
{
unused_arg(L);
return 0;
faction *self = (faction *)tolua_tousertype(L, 1, 0);
tolua_pushstring(L, self->_password);
return 1;
}
static int tolua_faction_set_password(lua_State * L)
{
faction *self = (faction *)tolua_tousertype(L, 1, 0);
const char * passw = tolua_tostring(L, 2, 0);
faction_setpassword(self, password_hash(passw, 0, PASSWORD_DEFAULT));
faction_setpassword(self, password_encode(passw, PASSWORD_DEFAULT));
return 0;
}

4
src/bind_unit.c
View File

@ -153,8 +153,8 @@ static int tolua_unit_get_group(lua_State * L)
static int tolua_unit_set_group(lua_State * L)
{
unit *self = (unit *)tolua_tousertype(L, 1, 0);
int result = join_group(self, tolua_tostring(L, 2, 0));
lua_pushinteger(L, result);
group *g = join_group(self, tolua_tostring(L, 2, 0));
lua_pushboolean(L, g!=NULL);
return 1;
}

23
src/kernel/alliance.test.c
View File

@ -4,6 +4,7 @@
#include "alliance.h"
#include <CuTest.h>
#include <tests.h>
#include <quicklist.h>
#include <assert.h>
@ -61,9 +62,31 @@ static void test_alliance_join(CuTest *tc) {
test_cleanup();
}
static void test_alliance_dead_faction(CuTest *tc) {
faction *f, *f2;
alliance *al;
test_cleanup();
f = test_create_faction(0);
f2 = test_create_faction(0);
al = makealliance(42, "Hodor");
setalliance(f, al);
setalliance(f2, al);
CuAssertPtrEquals(tc, f, alliance_get_leader(al));
CuAssertIntEquals(tc, 2, ql_length(al->members));
CuAssertPtrEquals(tc, al, f->alliance);
destroyfaction(&factions);
CuAssertIntEquals(tc, 1, ql_length(al->members));
CuAssertPtrEquals(tc, f2, alliance_get_leader(al));
CuAssertPtrEquals(tc, NULL, f->alliance);
CuAssertTrue(tc, !f->_alive);
test_cleanup();
}
CuSuite *get_alliance_suite(void)
{
CuSuite *suite = CuSuiteNew();
SUITE_ADD_TEST(suite, test_alliance_dead_faction);
SUITE_ADD_TEST(suite, test_alliance_make);
SUITE_ADD_TEST(suite, test_alliance_join);
return suite;

9
src/kernel/faction.c
View File

@ -217,6 +217,7 @@ int resolve_faction(variant id, void *address)
result = -1;
}
}
assert(address);
*(faction **)address = f;
return result;
}
@ -252,7 +253,7 @@ faction *addfaction(const char *email, const char *password,
}
if (!password) password = itoa36(rng_int());
faction_setpassword(f, password_hash(password, 0, PASSWORD_DEFAULT));
faction_setpassword(f, password_encode(password, PASSWORD_DEFAULT));
ADDMSG(&f->msgs, msg_message("changepasswd", "value", password));
f->alliance_joindate = turn;
@ -333,7 +334,8 @@ variant read_faction_reference(struct storage * store)
void write_faction_reference(const faction * f, struct storage *store)
{
WRITE_INT(store, (f && f->_alive) ? f->no : 0);
assert(!f || f->_alive);
WRITE_INT(store, f ? f->no : 0);
}
static faction *dead_factions;
@ -566,7 +568,8 @@ void faction_setbanner(faction * self, const char *banner)
void faction_setpassword(faction * f, const char *pwhash)
{
assert(pwhash && pwhash[0] == '$');
assert(pwhash);
// && pwhash[0] == '$');
free(f->_password);
f->_password = _strdup(pwhash);
}

12
src/kernel/faction.test.c
View File

@ -108,12 +108,12 @@ static void test_addfaction(CuTest *tc) {
CuAssertPtrEquals(tc, NULL, (void *)f->ursprung);
CuAssertPtrEquals(tc, (void *)factions, (void *)f);
CuAssertStrEquals(tc, "test@eressea.de", f->email);
CuAssertIntEquals(tc, true, checkpasswd(f, "hurrdurr"));
CuAssertTrue(tc, checkpasswd(f, "hurrdurr"));
CuAssertPtrEquals(tc, (void *)lang, (void *)f->locale);
CuAssertIntEquals(tc, 1234, f->subscription);
CuAssertIntEquals(tc, 0, f->flags);
CuAssertIntEquals(tc, 0, f->age);
CuAssertIntEquals(tc, true, faction_alive(f));
CuAssertTrue(tc, faction_alive(f));
CuAssertIntEquals(tc, M_GRAY, f->magiegebiet);
CuAssertIntEquals(tc, turn, f->lastorders);
CuAssertPtrEquals(tc, f, findfaction(f->no));
@ -124,10 +124,10 @@ static void test_check_passwd(CuTest *tc) {
faction *f;
f = test_create_faction(0);
faction_setpassword(f, password_hash("password", 0, PASSWORD_DEFAULT));
CuAssertIntEquals(tc, true, checkpasswd(f, "password"));
CuAssertIntEquals(tc, false, checkpasswd(f, "assword"));
CuAssertIntEquals(tc, false, checkpasswd(f, "PASSWORD"));
faction_setpassword(f, password_encode("password", PASSWORD_DEFAULT));
CuAssertTrue(tc, checkpasswd(f, "password"));
CuAssertTrue(tc, !checkpasswd(f, "assword"));
CuAssertTrue(tc, !checkpasswd(f, "PASSWORD"));
}
static void test_get_monsters(CuTest *tc) {

12
src/kernel/group.c
View File

@ -179,7 +179,7 @@ void set_group(struct unit *u, struct group *g)
}
}
bool join_group(unit * u, const char *name)
group *join_group(unit * u, const char *name)
{
group *g = NULL;
@ -192,7 +192,7 @@ bool join_group(unit * u, const char *name)
}
set_group(u, g);
return true;
return g;
}
void write_groups(struct storage *store, const faction * f)
@ -203,13 +203,13 @@ void write_groups(struct storage *store, const faction * f)
WRITE_INT(store, g->gid);
WRITE_STR(store, g->name);
for (a = g->allies; a; a = a->next) {
if (a->faction) {
if (a->faction && a->faction->_alive) {
write_faction_reference(a->faction, store);
WRITE_INT(store, a->status);
}
}
WRITE_INT(store, 0);
write_attribs(store, g->attribs, g);
write_faction_reference(NULL, store);
a_write(store, g->attribs, g);
WRITE_SECTION(store);
}
WRITE_INT(store, 0);
@ -233,7 +233,7 @@ void read_groups(struct storage *store, faction * f)
ally *a;
variant fid;
READ_INT(store, &fid.i);
fid = read_faction_reference(store);
if (fid.i <= 0)
break;
a = ally_add(pa, findfaction(fid.i));

2
src/kernel/group.h
View File

@ -36,7 +36,7 @@ extern "C" {
} group;
extern struct attrib_type at_group; /* attribute for units assigned to a group */
extern bool join_group(struct unit *u, const char *name);
extern struct group *join_group(struct unit *u, const char *name);
extern void set_group(struct unit *u, struct group *g);
extern struct group * get_group(const struct unit *u);
extern void free_group(struct group *g);

31
src/kernel/group.test.c
View File

@ -5,6 +5,8 @@
#include "faction.h"
#include "unit.h"
#include "region.h"
#include <util/attrib.h>
#include <attributes/key.h>
#include <stream.h>
#include <filestream.h>
#include <storage.h>
@ -22,6 +24,7 @@ static void test_group_readwrite(CuTest * tc)
storage store;
FILE *F;
stream strm;
int i;
F = fopen("test.dat", "wb");
fstream_init(&strm, F);
@ -29,10 +32,13 @@ static void test_group_readwrite(CuTest * tc)
test_cleanup();
test_create_world();
f = test_create_faction(0);
g = new_group(f, "test", 42);
g = new_group(f, "NW", 42);
g = new_group(f, "Egoisten", 43);
key_set(&g->attribs, 44);
al = ally_add(&g->allies, f);
al->status = HELP_GIVE;
write_groups(&store, f);
WRITE_INT(&store, 47);
binstore_done(&store);
fstream_done(&strm);
@ -40,16 +46,25 @@ static void test_group_readwrite(CuTest * tc)
fstream_init(&strm, F);
binstore_init(&store, &strm);
f->groups = 0;
free_group(g);
read_groups(&store, f);
READ_INT(&store, &i);
binstore_done(&store);
fstream_done(&strm);
CuAssertIntEquals(tc, 47, i);
CuAssertPtrNotNull(tc, f->groups);
CuAssertPtrNotNull(tc, f->groups->allies);
CuAssertPtrEquals(tc, 0, f->groups->allies->next);
CuAssertPtrEquals(tc, f, f->groups->allies->faction);
CuAssertIntEquals(tc, HELP_GIVE, f->groups->allies->status);
CuAssertIntEquals(tc, 42, f->groups->gid);
CuAssertStrEquals(tc, "NW", f->groups->name);
CuAssertPtrNotNull(tc, f->groups->next);
CuAssertIntEquals(tc, 43, f->groups->next->gid);
CuAssertStrEquals(tc, "Egoisten", f->groups->next->name);
CuAssertPtrEquals(tc, 0, f->groups->allies);
g = f->groups->next;
CuAssertTrue(tc, key_get(g->attribs, 44));
CuAssertPtrNotNull(tc, g->allies);
CuAssertPtrEquals(tc, 0, g->allies->next);
CuAssertPtrEquals(tc, f, g->allies->faction);
CuAssertIntEquals(tc, HELP_GIVE, g->allies->status);
remove("test.dat");
test_cleanup();
}
@ -68,8 +83,8 @@ static void test_group(CuTest * tc)
assert(r && f);
u = test_create_unit(f, r);
assert(u);
CuAssertTrue(tc, join_group(u, "hodor"));
CuAssertPtrNotNull(tc, (g = get_group(u)));
CuAssertPtrNotNull(tc, (g = join_group(u, "hodor")));
CuAssertPtrEquals(tc, g, get_group(u));
CuAssertStrEquals(tc, "hodor", g->name);
CuAssertIntEquals(tc, 1, g->members);
set_group(u, 0);

11
src/kernel/plane.c
View File

@ -290,14 +290,3 @@ int read_plane_reference(plane ** pp, struct storage *store)
ur_add(id, pp, resolve_plane);
return AT_READ_OK;
}
bool is_watcher(const struct plane * p, const struct faction * f)
{
struct watcher *w;
if (!p)
return false;
w = p->watchers;
while (w && w->faction != f)
w = w->next;
return (w != NULL);
}

10
src/kernel/plane.h
View File

@ -22,7 +22,9 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
extern "C" {
#endif
struct faction;
struct region;
struct faction;
struct plane;
struct storage;
@ -43,15 +45,8 @@ extern "C" {
#define PFL_NOMONSTERS 16384 /* no monster randenc */
#define PFL_SEESPECIAL 32768 /* far seeing */
typedef struct watcher {
struct watcher *next;
struct faction *faction;
unsigned char mode;
} watcher;
typedef struct plane {
struct plane *next;
struct watcher *watchers;
int id;
char *name;
int minx, maxx, miny, maxy;
@ -76,7 +71,6 @@ extern "C" {
struct plane *get_homeplane(void);
extern int rel_to_abs(const struct plane *pl, const struct faction *f,
int rel, unsigned char index);
extern bool is_watcher(const struct plane *p, const struct faction *f);
extern void write_plane_reference(const plane * p, struct storage *store);
extern int read_plane_reference(plane ** pp, struct storage *store);
extern int plane_width(const plane * pl);

1
src/kernel/region.h
View File

@ -66,6 +66,7 @@ extern "C" {
struct message_list;
struct rawmaterial;
struct item;
struct faction;
#define MORALE_TAX_FACTOR 0.005 /* 0.5% tax per point of morale */
#define MORALE_MAX 10 /* Maximum morale allowed */

115
src/kernel/save.c
View File

@ -238,8 +238,8 @@ static faction *factionorders(void)
/* Die Partei hat sich zumindest gemeldet, so dass sie noch
* nicht als untätig gilt */
/* TODO: +1 ist ein Workaround, weil cturn erst in process_orders
* incrementiert wird. */
/* TODO: +1 ist ein Workaround, weil cturn erst in process_orders
* incrementiert wird. */
f->lastorders = global.data_turn + 1;
}
@ -513,13 +513,14 @@ static void read_owner(struct gamedata *data, region_owner ** powner)
int id;
READ_INT(data->store, &id);
owner->last_owner = id ? findfaction(id) : NULL;
} else if (data->version >= OWNER_2_VERSION) {
}
else if (data->version >= OWNER_2_VERSION) {
int id;
alliance *a;
READ_INT(data->store, &id);
a = id ? findalliance(id) : NULL;
/* don't know which faction, take the leader */
owner->last_owner = a? a->_leader : NULL;
owner->last_owner = a ? a->_leader : NULL;
}
else {
owner->last_owner = NULL;
@ -535,11 +536,14 @@ static void read_owner(struct gamedata *data, region_owner ** powner)
static void write_owner(struct gamedata *data, region_owner * owner)
{
if (owner) {
faction *f;
WRITE_INT(data->store, owner->since_turn);
WRITE_INT(data->store, owner->morale_turn);
WRITE_INT(data->store, owner->flags);
write_faction_reference(owner->last_owner, data->store);
write_faction_reference(owner->owner, data->store);
f = owner->last_owner;
write_faction_reference((f && f->_alive) ? f : NULL, data->store);
f = owner->owner;
write_faction_reference((f && f->_alive) ? f : NULL, data->store);
}
else {
WRITE_INT(data->store, -1);
@ -569,7 +573,7 @@ int current_turn(void)
static void
writeorder(struct gamedata *data, const struct order *ord,
const struct locale *lang)
const struct locale *lang)
{
char obuf[1024];
write_order(ord, obuf, sizeof(obuf));
@ -778,6 +782,7 @@ void write_unit(struct gamedata *data, const unit * u)
const race *irace = u_irace(u);
write_unit_reference(u, data->store);
assert(u->faction->_alive);
write_faction_reference(u->faction, data->store);
WRITE_STR(data->store, u->_name);
WRITE_STR(data->store, u->display ? u->display : "");
@ -834,7 +839,7 @@ void write_unit(struct gamedata *data, const unit * u)
WRITE_SECTION(data->store);
write_items(data->store, u->items);
WRITE_SECTION(data->store);
if (u->hp == 0 && u_race(u)!= get_race(RC_SPELL)) {
if (u->hp == 0 && u_race(u) != get_race(RC_SPELL)) {
log_error("unit %s has 0 hitpoints, adjusting.\n", itoa36(u->no));
((unit *)u)->hp = u->number;
}
@ -995,7 +1000,7 @@ static region *readregion(struct gamedata *data, int x, int y)
read_items(data->store, &r->land->items);
if (data->version >= REGIONOWNER_VERSION) {
READ_INT(data->store, &n);
region_set_morale(r, _max(0, (short) n), -1);
region_set_morale(r, _max(0, (short)n), -1);
read_owner(data, &r->land->ownership);
}
}
@ -1149,7 +1154,7 @@ void read_spellbook(spellbook **bookp, struct storage *store, int(*get_level)(co
*bookp = create_spellbook(0);
sb = *bookp;
}
if (level>0 && (global.data_version >= SPELLBOOK_VERSION || !spellbook_get(sb, sp))) {
if (level > 0 && (global.data_version >= SPELLBOOK_VERSION || !spellbook_get(sb, sp))) {
spellbook_add(sb, sp, level);
}
}
@ -1171,6 +1176,58 @@ void write_spellbook(const struct spellbook *book, struct storage *store)
WRITE_TOK(store, "end");
}
static char * getpasswd(int fno) {
const char *prefix = itoa36(fno);
size_t len = strlen(prefix);
FILE * F = fopen("passwords.txt", "r");
char line[80];
if (F) {
while (!feof(F)) {
fgets(line, sizeof(line), F);
if (line[len] == ':' && strncmp(prefix, line, len) == 0) {
size_t slen = strlen(line) - 1;
assert(line[slen] == '\n');
line[slen] = 0;
fclose(F);
return _strdup(line + len + 1);
}
}
fclose(F);
}
return NULL;
}
static void read_password(gamedata *data, faction *f) {
char name[128];
READ_STR(data->store, name, sizeof(name));
if (data->version == BADCRYPT_VERSION) {
char * pass = getpasswd(f->no);
if (pass) {
faction_setpassword(f, password_encode(pass, PASSWORD_DEFAULT));
free(pass); // TODO: remove this allocation!
}
else {
free(f->_password);
f->_password = NULL;
}
}
else {
faction_setpassword(f, (data->version >= CRYPT_VERSION) ? name : password_encode(name, PASSWORD_DEFAULT));
}
}
void _test_read_password(gamedata *data, faction *f) {
read_password(data, f);
}
static void write_password(gamedata *data, const faction *f) {
WRITE_TOK(data->store, (const char *)f->_password);
}
void _test_write_password(gamedata *data, const faction *f) {
write_password(data, f);
}
/** Reads a faction from a file.
* This function requires no context, can be called in any state. The
* faction may not already exist, however.
@ -1238,8 +1295,7 @@ faction *readfaction(struct gamedata * data)
set_email(&f->email, "");
}
READ_STR(data->store, name, sizeof(name));
faction_setpassword(f, (data->version >= CRYPT_VERSION) ? name : password_hash(name, 0, PASSWORD_DEFAULT));
read_password(data, f);
if (data->version < NOOVERRIDE_VERSION) {
READ_STR(data->store, 0, 0);
}
@ -1326,6 +1382,7 @@ void writefaction(struct gamedata *data, const faction * f)
ally *sf;
ursprung *ur;
assert(f->_alive);
write_faction_reference(f, data->store);
WRITE_INT(data->store, f->subscription);
#if RELEASE_VERSION >= SPELL_LEVEL_VERSION
@ -1346,7 +1403,7 @@ void writefaction(struct gamedata *data, const faction * f)
WRITE_STR(data->store, f->name);
WRITE_STR(data->store, f->banner);
WRITE_STR(data->store, f->email);
WRITE_TOK(data->store, f->_password);
write_password(data, f);
WRITE_TOK(data->store, locale_name(f->locale));
WRITE_INT(data->store, f->lastorders);
WRITE_INT(data->store, f->age);
@ -1431,10 +1488,10 @@ int readgame(const char *filename, bool backup)
return -1;
}
sz = fread(&gdata.version, sizeof(int), 1, F);
if (sz!=sizeof(int) || gdata.version >= INTPAK_VERSION) {
if (sz != sizeof(int) || gdata.version >= INTPAK_VERSION) {
int stream_version;
size_t sz = fread(&stream_version, sizeof(int), 1, F);
assert((sz==1 && stream_version == STREAM_VERSION) || !"unsupported data format");
assert((sz == 1 && stream_version == STREAM_VERSION) || !"unsupported data format");
}
assert(gdata.version >= MIN_VERSION || !"unsupported data format");
assert(gdata.version <= MAX_VERSION || !"unsupported data format");
@ -1518,15 +1575,12 @@ int readgame(const char *filename, bool backup)
}
}
else {
fno = read_faction_reference(&store);
while (fno.i) {
watcher *w = (watcher *)malloc(sizeof(watcher));
ur_add(fno, &w->faction, resolve_faction);
READ_INT(&store, &n);
w->mode = (unsigned char)n;
w->next = pl->watchers;
pl->watchers = w;
/* WATCHERS - eliminated in February 2016, ca. turn 966 */
if (gdata.version < NOWATCH_VERSION) {
fno = read_faction_reference(&store);
while (fno.i) {
fno = read_faction_reference(&store);
}
}
}
read_attribs(&store, &pl->attribs, pl);
@ -1807,7 +1861,6 @@ int writegame(const char *filename)
WRITE_SECTION(&store);
for (pl = planes; pl; pl = pl->next) {
watcher *w;
WRITE_INT(&store, pl->id);
WRITE_STR(&store, pl->name);
WRITE_INT(&store, pl->minx);
@ -1815,16 +1868,10 @@ int writegame(const char *filename)
WRITE_INT(&store, pl->miny);
WRITE_INT(&store, pl->maxy);
WRITE_INT(&store, pl->flags);
w = pl->watchers;
while (w) {
if (w->faction) {
write_faction_reference(w->faction, &store);
WRITE_INT(&store, w->mode);
}
w = w->next;
}
write_faction_reference(NULL, &store); /* mark the end of the list */
write_attribs(&store, pl->attribs, pl);
#if RELEASE_VERSION < NOWATCH_VERSION
write_faction_reference(NULL, &store); /* mark the end of pl->watchers (gone since T966) */
#endif
a_write(&store, pl->attribs, pl);
WRITE_SECTION(&store);
}

3
src/kernel/save.h
View File

@ -86,6 +86,9 @@ extern "C" {
struct gamedata *gamedata_open(const char *filename, const char *mode);
void gamedata_close(struct gamedata *data);
/* test-only functions that give access to internal implementation details (BAD) */
void _test_write_password(struct gamedata *data, const struct faction *f);
void _test_read_password(struct gamedata *data, struct faction *f);
#ifdef __cplusplus
}
#endif

196
src/kernel/save.test.c
View File

@ -5,11 +5,25 @@
#include "save.h"
#include "unit.h"
#include "group.h"
#include "ally.h"
#include "faction.h"
#include "plane.h"
#include "region.h"
#include "version.h"
#include <triggers/changefaction.h>
#include <triggers/createunit.h>
#include <triggers/timeout.h>
#include <util/attrib.h>
#include <util/event.h>
#include <util/base36.h>
#include <util/password.h>
#include <CuTest.h>
#include <tests.h>
#include <storage.h>
#include <stdio.h>
static void test_readwrite_data(CuTest * tc)
@ -46,6 +60,7 @@ static void test_readwrite_unit(CuTest * tc)
data = gamedata_open(path, "wb");
CuAssertPtrNotNull(tc, data); // TODO: intermittent test (even after the 'b' fix!)
write_unit(data, u);
gamedata_close(data);
@ -53,6 +68,8 @@ static void test_readwrite_unit(CuTest * tc)
f = test_create_faction(0);
renumber_faction(f, fno);
data = gamedata_open(path, "rb");
CuAssertPtrNotNull(tc, data);
u = read_unit(data);
gamedata_close(data);
@ -90,11 +107,190 @@ static void test_readwrite_attrib(CuTest *tc) {
test_cleanup();
}
static void test_readwrite_dead_faction_group(CuTest *tc) {
faction *f, *f2;
unit * u;
group *g;
ally *al;
int fno;
test_cleanup();
f = test_create_faction(0);
fno = f->no;
CuAssertPtrEquals(tc, f, factions);
CuAssertPtrEquals(tc, 0, f->next);
f2 = test_create_faction(0);
CuAssertPtrEquals(tc, f2, factions->next);
u = test_create_unit(f2, test_create_region(0, 0, 0));
CuAssertPtrNotNull(tc, u);
g = join_group(u, "group");
CuAssertPtrNotNull(tc, g);
al = ally_add(&g->allies, f);
CuAssertPtrNotNull(tc, al);
CuAssertPtrEquals(tc, f, factions);
destroyfaction(&factions);
CuAssertTrue(tc, !f->_alive);
CuAssertPtrEquals(tc, f2, factions);
writegame("test.dat");
free_gamedata();
f = f2 = NULL;
readgame("test.dat", false);
CuAssertPtrEquals(tc, 0, findfaction(fno));
f2 = factions;
CuAssertPtrNotNull(tc, f2);
u = f2->units;
CuAssertPtrNotNull(tc, u);
g = get_group(u);
CuAssertPtrNotNull(tc, g);
CuAssertPtrEquals(tc, 0, g->allies);
test_cleanup();
}
static void test_readwrite_dead_faction_regionowner(CuTest *tc) {
faction *f;
region *r;
test_cleanup();
config_set("rules.region_owners", "1");
f = test_create_faction(0);
test_create_unit(f, r = test_create_region(0, 0, 0));
region_set_owner(r, f, turn);
destroyfaction(&factions);
CuAssertTrue(tc, !f->_alive);
remove_empty_units();
writegame("test.dat");
free_gamedata();
f = NULL;
readgame("test.dat", false);
f = factions;
CuAssertPtrEquals(tc, 0, f);
r = regions;
CuAssertPtrNotNull(tc, r);
CuAssertPtrEquals(tc, 0, region_get_owner(r));
test_cleanup();
}
static void test_readwrite_dead_faction_changefaction(CuTest *tc) {
faction *f, *f2;
region *r;
trigger *tr;
unit * u;
test_cleanup();
f = test_create_faction(0);
f2 = test_create_faction(0);
u = test_create_unit(f2, r = test_create_region(0, 0, 0));
tr = trigger_changefaction(u, f);
add_trigger(&u->attribs, "timer", trigger_timeout(10, tr));
CuAssertPtrNotNull(tc, a_find(u->attribs, &at_eventhandler));
destroyfaction(&factions);
CuAssertTrue(tc, !f->_alive);
remove_empty_units();
writegame("test.dat");
free_gamedata();
f = NULL;
readgame("test.dat", false);
f = factions;
CuAssertPtrNotNull(tc, f);
r = regions;
CuAssertPtrNotNull(tc, r);
u = r->units;
CuAssertPtrNotNull(tc, u);
CuAssertPtrEquals(tc, 0, a_find(u->attribs, &at_eventhandler));
test_cleanup();
}
static void test_readwrite_dead_faction_createunit(CuTest *tc) {
faction *f, *f2;
region *r;
trigger *tr;
unit * u;
test_cleanup();
f = test_create_faction(0);
f2 = test_create_faction(0);
u = test_create_unit(f2, r = test_create_region(0, 0, 0));
tr = trigger_createunit(r, f, f->race, 1);
add_trigger(&u->attribs, "timer", trigger_timeout(10, tr));
CuAssertPtrNotNull(tc, a_find(u->attribs, &at_eventhandler));
destroyfaction(&factions);
CuAssertTrue(tc, !f->_alive);
remove_empty_units();
writegame("test.dat");
free_gamedata();
f = NULL;
readgame("test.dat", false);
f = factions;
CuAssertPtrNotNull(tc, f);
r = regions;
CuAssertPtrNotNull(tc, r);
u = r->units;
CuAssertPtrNotNull(tc, u);
CuAssertPtrEquals(tc, 0, a_find(u->attribs, &at_eventhandler));
test_cleanup();
}
static void test_read_password(CuTest *tc) {
const char *path = "test.dat";
gamedata *data;
faction *f;
f = test_create_faction(0);
faction_setpassword(f, password_encode("secret", PASSWORD_DEFAULT));
data = gamedata_open(path, "wb");
CuAssertPtrNotNull(tc, data);
_test_write_password(data, f);
gamedata_close(data);
data = gamedata_open(path, "rb");
CuAssertPtrNotNull(tc, data);
_test_read_password(data, f);
gamedata_close(data);
CuAssertTrue(tc, checkpasswd(f, "secret"));
CuAssertIntEquals(tc, 0, remove(path));
}
static void test_read_password_external(CuTest *tc) {
const char *path = "test.dat", *pwfile = "passwords.txt";
gamedata *data;
faction *f;
FILE * F;
remove(pwfile);
f = test_create_faction(0);
faction_setpassword(f, password_encode("secret", PASSWORD_DEFAULT));
CuAssertPtrNotNull(tc, f->_password);
data = gamedata_open(path, "wb");
CuAssertPtrNotNull(tc, data);
WRITE_TOK(data->store, (const char *)f->_password);
WRITE_TOK(data->store, (const char *)f->_password);
gamedata_close(data);
data = gamedata_open(path, "rb");
CuAssertPtrNotNull(tc, data);
data->version = BADCRYPT_VERSION;
_test_read_password(data, f);
CuAssertPtrEquals(tc, 0, f->_password);
F = fopen(pwfile, "wt");
fprintf(F, "%s:secret\n", itoa36(f->no));
fclose(F);
_test_read_password(data, f);
CuAssertPtrNotNull(tc, f->_password);
gamedata_close(data);
CuAssertTrue(tc, checkpasswd(f, "secret"));
CuAssertIntEquals(tc, 0, remove(path));
CuAssertIntEquals(tc, 0, remove(pwfile));
}
CuSuite *get_save_suite(void)
{
CuSuite *suite = CuSuiteNew();
SUITE_ADD_TEST(suite, test_readwrite_attrib);
SUITE_ADD_TEST(suite, test_readwrite_data);
SUITE_ADD_TEST(suite, test_readwrite_unit);
SUITE_ADD_TEST(suite, test_readwrite_dead_faction_createunit);
SUITE_ADD_TEST(suite, test_readwrite_dead_faction_changefaction);
SUITE_ADD_TEST(suite, test_readwrite_dead_faction_regionowner);
DISABLE_TEST(suite, test_readwrite_dead_faction_group);
SUITE_ADD_TEST(suite, test_read_password);
SUITE_ADD_TEST(suite, test_read_password_external);
return suite;
}

4
src/kernel/version.h
View File

@ -33,8 +33,10 @@
#define SPELL_LEVEL_VERSION 348 /* f->max_spelllevel gets stored, not calculated */
#define OWNER_3_VERSION 349 /* regions store last owner, not last alliance */
#define ATTRIBOWNER_VERSION 350 /* all attrib_type functions know who owns the attribute */
#define CRYPT_VERSION 351 /* passwords are encrypted */
#define BADCRYPT_VERSION 351 /* passwords are encrypted, poorly */
#define ATHASH_VERSION 352 /* attribute-type hash, not name */
#define CRYPT_VERSION 353 /* passwords are encrypted */
#define NOWATCH_VERSION 354 /* plane->watchers is gone */
#define RELEASE_VERSION ATHASH_VERSION /* current datafile */
#define MIN_VERSION INTPAK_VERSION /* minimal datafile we support */
#define MAX_VERSION RELEASE_VERSION /* change this if we can need to read the future datafile, and we can do so */

2
src/laws.c
View File

@ -2173,7 +2173,7 @@ int password_cmd(unit * u, struct order *ord)
cmistake(u, ord, 283, MSG_EVENT);
strlcpy(pwbuf, itoa36(rng_int()), sizeof(pwbuf));
}
faction_setpassword(u->faction, password_hash(pwbuf, 0, PASSWORD_DEFAULT));
faction_setpassword(u->faction, password_encode(pwbuf, PASSWORD_DEFAULT));
ADDMSG(&u->faction->msgs, msg_message("changepasswd",
"value", pwbuf));
return 0;

13
src/reports.c
View File

@ -1385,17 +1385,9 @@ static void prepare_reports(void)
for (r = regions; r; r = r->next) {
unit *u;
plane *p = rplane(r);
reorder_units(r);
if (p) {
watcher *w = p->watchers;
for (; w; w = w->next) {
faction_add_seen(w->faction, r, w->mode);
}
}
/* Region owner get always the Lighthouse report */
if (bt_lighthouse && config_token("rules.region_owner_pay_building", bt_lighthouse->_name)) {
for (b = rbuildings(r); b; b = b->next) {
@ -1464,8 +1456,6 @@ static region *lastregion(faction * f)
/* we continue from the best region and look for travelthru etc. */
for (r = f->last->next; r; r = r->next) {
plane *p = rplane(r);
/* search the region for travelthru-attributes: */
if (fval(r, RF_TRAVELUNIT)) {
travelthru_map(r, cb_set_last, f);
@ -1474,9 +1464,6 @@ static region *lastregion(faction * f)
continue;
if (check_leuchtturm(r, f))
f->last = r;
if (p && is_watcher(p, f)) {
f->last = r;
}
}
return f->last->next;
#else

3
src/tests.c
View File

@ -5,6 +5,7 @@
#include "prefix.h"
#include <kernel/config.h>
#include <kernel/plane.h>
#include <kernel/region.h>
#include <kernel/terrain.h>
#include <kernel/item.h>
@ -47,7 +48,7 @@ struct region *test_create_region(int x, int y, const terrain_type *terrain)
{
region *r = findregion(x, y);
if (!r) {
r = new_region(x, y, NULL, 0);
r = new_region(x, y, findplane(x, y), 0);
}
if (!terrain) {
terrain_type *t = get_or_create_terrain("plain");

10
src/triggers/changefaction.c
View File

@ -79,14 +79,20 @@ static void changefaction_write(const trigger * t, struct storage *store)
{
changefaction_data *td = (changefaction_data *)t->data.v;
write_unit_reference(td->unit, store);
write_faction_reference(td->faction, store);
write_faction_reference(td->faction->_alive ? td->faction : NULL, store);
}
static int changefaction_read(trigger * t, struct storage *store)
{
variant var;
changefaction_data *td = (changefaction_data *)t->data.v;
read_reference(&td->unit, store, read_unit_reference, resolve_unit);
read_reference(&td->faction, store, read_faction_reference, resolve_faction);
var = read_faction_reference(store);
if (var.i == 0) {
return AT_READ_FAIL;
}
ur_add(var, &td->faction, resolve_faction);
// read_reference(&td->faction, store, read_faction_reference, resolve_faction);
return AT_READ_OK;
}

29
src/triggers/createunit.c
View File

@ -82,7 +82,7 @@ static int createunit_handle(trigger * t, void *data)
static void createunit_write(const trigger * t, struct storage *store)
{
createunit_data *td = (createunit_data *)t->data.v;
write_faction_reference(td->f, store);
write_faction_reference(td->f->_alive ? td->f : NULL, store);
write_region_reference(td->r, store);
write_race_reference(td->race, store);
WRITE_INT(store, td->number);
@ -91,21 +91,28 @@ static void createunit_write(const trigger * t, struct storage *store)
static int createunit_read(trigger * t, struct storage *store)
{
createunit_data *td = (createunit_data *)t->data.v;
variant var;
int result = AT_READ_OK;
var = read_faction_reference(store);
if (var.i > 0) {
td->f = findfaction(var.i);
if (!td->f) {
ur_add(var, &td->f, resolve_faction);
}
}
else {
result = AT_READ_FAIL;
}
// read_reference(&td->f, store, read_faction_reference, resolve_faction);
int uc =
read_reference(&td->f, store, read_faction_reference, resolve_faction);
int rc =
read_reference(&td->r, store, read_region_reference,
read_reference(&td->r, store, read_region_reference,
RESOLVE_REGION(global.data_version));
td->race = (const struct race *)read_race_reference(store).v;
if (uc == 0 && rc == 0) {
if (!td->f || !td->r)
return AT_READ_FAIL;
if (!td->race) {
result = AT_READ_FAIL;
}
READ_INT(store, &td->number);
return AT_READ_OK;
return result;
}
trigger_type tt_createunit = {

25
src/util/gamedata.test.c Normal file
View File

@ -0,0 +1,25 @@
#include <platform.h>
#include "gamedata.h"
#include <CuTest.h>
#include <tests.h>
#include <stdio.h>
static void test_gamedata(CuTest * tc)
{
gamedata *data;
data = gamedata_open("test.dat", "wb", 0);
CuAssertPtrNotNull(tc, data);
gamedata_close(data);
data = gamedata_open("test.dat", "rb", 0);
CuAssertPtrNotNull(tc, data);
gamedata_close(data);
CuAssertIntEquals(tc, 0, remove("test.dat"));
}
CuSuite *get_gamedata_suite(void)
{
CuSuite *suite = CuSuiteNew();
SUITE_ADD_TEST(suite, test_gamedata);
return suite;
}

119
src/util/password.c
View File

@ -2,7 +2,9 @@
#include "password.h"
#include <md5.h>
#include <crypt_blowfish.h>
#include <mtrand.h>
#include <drepper.h>
#include <assert.h>
#include <string.h>
@ -25,73 +27,104 @@
} while (0)
char *password_gensalt(void) {
static char salt[SALTLEN + 1];
char *password_gensalt(char *salt, size_t salt_len) {
size_t buflen = salt_len-1;
char *cp = salt;
int buflen = SALTLEN;
while (buflen) {
unsigned long ul = genrand_int32() & (unsigned long)time(0);
b64_from_24bit((char)(ul & 0xFF), (char)((ul>>8)&0xff), (char)((ul>>16)&0xFF), 4);
b64_from_24bit((char)(ul & 0xFF), (char)((ul >> 8) & 0xff), (char)((ul >> 16) & 0xFF), 4);
}
salt[SALTLEN] = 0;
salt[salt_len-1] = 0;
return salt;
}
static const char * password_hash_i(const char * passwd, const char *salt, int algo, char *result, size_t len) {
assert(passwd);
if (!salt) {
salt = password_gensalt();
}
if (algo==PASSWORD_PLAIN) {
_snprintf(result, len, "$0$%s$%s", salt, passwd);
}
else if (algo == PASSWORD_MD5) {
return md5_crypt_r(passwd, salt, result, len);
}
else if (algo == PASSWORD_APACHE_MD5) {
apr_md5_encode(passwd, salt, result, len);
static bool password_is_implemented(int algo) {
return algo == PASSWORD_PLAINTEXT || algo == PASSWORD_BCRYPT || algo == PASSWORD_NOCRYPT || algo == PASSWORD_MD5 || algo == PASSWORD_APACHE_MD5;
}
static const char * password_hash_i(const char * passwd, const char *input, int algo, char *result, size_t len) {
if (algo == PASSWORD_BCRYPT) {
char salt[MAXSALTLEN];
char setting[40];
if (!input) {
input = password_gensalt(salt, MAXSALTLEN);
}
if (_crypt_gensalt_blowfish_rn("$2y$", 5, input, strlen(input), setting, sizeof(setting)) == NULL) {
return NULL;
}
if (_crypt_blowfish_rn(passwd, setting, result, len) == NULL) {
return NULL;
}
return result;
}
else {
return NULL;
else if (algo == PASSWORD_PLAINTEXT) {
_snprintf(result, len, "%s", passwd);
return result;
}
return result;
else if (algo == PASSWORD_NOCRYPT) {
_snprintf(result, len, "$0$%s", passwd);
return result;
}
else if (password_is_implemented(algo)) {
char salt[MAXSALTLEN];
assert(passwd);
if (input) {
const char * dol = strchr(input, '$');
size_t salt_len;
if (dol) {
assert(dol > input && dol[0] == '$');
salt_len = dol - input;
}
else {
salt_len = strlen(input);
}
assert(salt_len < MAXSALTLEN);
memcpy(salt, input, salt_len);
salt[salt_len] = 0;
} else {
input = password_gensalt(salt, sizeof(salt));
}
if (algo == PASSWORD_MD5) {
return md5_crypt_r(passwd, input, result, len);
}
else if (algo == PASSWORD_APACHE_MD5) {
apr_md5_encode(passwd, input, result, len);
return result;
}
}
return NULL;
}
const char * password_hash(const char * passwd, const char * salt, int algo) {
const char * password_encode(const char * passwd, int algo) {
static char result[64]; // TODO: static result buffers are bad mojo!
if (algo < 0) algo = PASSWORD_DEFAULT;
return password_hash_i(passwd, salt, algo, result, sizeof(result));
}
static bool password_is_implemented(int algo) {
return algo==PASSWORD_PLAIN || algo==PASSWORD_MD5 || algo==PASSWORD_APACHE_MD5;
return password_hash_i(passwd, 0, algo, result, sizeof(result));
}
int password_verify(const char * pwhash, const char * passwd) {
char salt[MAXSALTLEN+1];
char hash[64];
size_t len;
int algo;
int algo = PASSWORD_PLAINTEXT;
char *pos;
const char *dol, *result;
const char *result;
assert(passwd);
assert(pwhash);
assert(pwhash[0] == '$');
algo = pwhash[1];
pos = strchr(pwhash+2, '$');
assert(pos && pos[0] == '$');
++pos;
dol = strchr(pos, '$');
assert(dol>pos && dol[0] == '$');
len = dol - pos;
assert(len <= MAXSALTLEN);
strncpy(salt, pos, len);
salt[len] = 0;
result = password_hash_i(passwd, salt, algo, hash, sizeof(hash));
if (pwhash[0] == '$') {
algo = pwhash[1];
}
if (!password_is_implemented(algo)) {
return VERIFY_UNKNOWN;
}
if (algo == PASSWORD_PLAINTEXT) {
return (strcmp(passwd, pwhash) == 0) ? VERIFY_OK : VERIFY_FAIL;
} else if (algo == PASSWORD_BCRYPT) {
char sample[200];
_crypt_blowfish_rn(passwd, pwhash, sample, sizeof(sample));
return (strcmp(sample, pwhash) == 0) ? VERIFY_OK : VERIFY_FAIL;
}
pos = strchr(pwhash+2, '$');
assert(pos && pos[0] == '$');
pos = strchr(pos, '$')+1;
result = password_hash_i(passwd, pos, algo, hash, sizeof(hash));
if (strcmp(pwhash, result) == 0) {
return VERIFY_OK;
}

7
src/util/password.h
View File

@ -1,15 +1,16 @@
#pragma once
#define PASSWORD_PLAIN '0'
#define PASSWORD_PLAINTEXT 0
#define PASSWORD_NOCRYPT '0'
#define PASSWORD_MD5 '1'
#define PASSWORD_BCRYPT '2' // not implemented
#define PASSWORD_APACHE_MD5 'a'
#define PASSWORD_SHA256 '5' // not implemented
#define PASSWORD_SHA512 '6' // not implemented
#define PASSWORD_DEFAULT PASSWORD_APACHE_MD5
#define PASSWORD_DEFAULT PASSWORD_PLAINTEXT
#define VERIFY_OK 0 // password matches hash
#define VERIFY_FAIL 1 // password is wrong
#define VERIFY_UNKNOWN 2 // hashing algorithm not supported
int password_verify(const char *hash, const char *passwd);
const char * password_hash(const char *passwd, const char *salt, int algo);
const char * password_encode(const char *passwd, int algo);

43
src/util/password.test.c
View File

@ -1,25 +1,42 @@
#include <platform.h>
#include <CuTest.h>
#include "password.h"
#include <CuTest.h>
#include <string.h>
static void test_passwords(CuTest *tc) {
const char *hash;
hash = password_hash("Hodor", "FqQLkl8g", PASSWORD_APACHE_MD5);
const char *hash, *expect;
expect = "$apr1$FqQLkl8g$.icQqaDJpim4BVy.Ho5660";
CuAssertIntEquals(tc, VERIFY_OK, password_verify(expect, "Hodor"));
hash = password_encode("Hodor", PASSWORD_APACHE_MD5);
CuAssertPtrNotNull(tc, hash);
CuAssertStrEquals(tc, "$apr1$FqQLkl8g$.icQqaDJpim4BVy.Ho5660", hash);
CuAssertIntEquals(tc, VERIFY_OK, password_verify(hash, "Hodor"));
CuAssertIntEquals(tc, 0, strncmp(hash, expect, 6));
hash = password_hash("jollygood", "ZouUn04i", PASSWORD_MD5);
expect = "$1$ZouUn04i$yNnT1Oy8azJ5V.UM9ppP5/";
CuAssertIntEquals(tc, VERIFY_OK, password_verify(expect, "jollygood"));
hash = password_encode("jollygood", PASSWORD_MD5);
CuAssertPtrNotNull(tc, hash);
CuAssertStrEquals(tc, "$1$ZouUn04i$yNnT1Oy8azJ5V.UM9ppP5/", hash);
CuAssertIntEquals(tc, VERIFY_OK, password_verify(hash, "jollygood"));
CuAssertIntEquals(tc, 0, strncmp(hash, expect, 3));
hash = password_hash("password", "hodor", PASSWORD_PLAIN);
expect = "password";
hash = password_encode("password", PASSWORD_PLAINTEXT);
CuAssertPtrNotNull(tc, hash);
CuAssertStrEquals(tc, "$0$hodor$password", hash);
CuAssertIntEquals(tc, VERIFY_OK, password_verify(hash, "password"));
CuAssertIntEquals(tc, VERIFY_FAIL, password_verify(hash, "arseword"));
CuAssertStrEquals(tc, hash, expect);
CuAssertIntEquals(tc, VERIFY_OK, password_verify(expect, "password"));
CuAssertIntEquals(tc, VERIFY_FAIL, password_verify(expect, "arseword"));
expect = "$0$password";
hash = password_encode("password", PASSWORD_NOCRYPT);
CuAssertPtrNotNull(tc, hash);
CuAssertStrEquals(tc, hash, expect);
CuAssertIntEquals(tc, VERIFY_OK, password_verify(expect, "password"));
CuAssertIntEquals(tc, VERIFY_FAIL, password_verify(expect, "arseword"));
expect = "$2y$05$RJ8qAhu.foXyJLdc2eHTLOaK4MDYn3/v4HtOVCq0Plv2yxcrEB7Wm";
CuAssertIntEquals(tc, VERIFY_OK, password_verify(expect, "Hodor"));
hash = password_encode("Hodor", PASSWORD_BCRYPT);
CuAssertPtrNotNull(tc, hash);
CuAssertIntEquals(tc, 0, strncmp(hash, expect, 7));
CuAssertIntEquals(tc, VERIFY_UNKNOWN, password_verify("$9$saltyfish$password", "password"));
}

2
src/util/resolve.c
View File

@ -58,6 +58,7 @@ resolve_fun resolver)
void ur_add(variant data, void *ptrptr, resolve_fun fun)
{
assert(ptrptr);
if (ur_list == NULL) {
ur_list = malloc(BLOCKSIZE * sizeof(unresolved));
ur_begin = ur_current = ur_list;
@ -86,6 +87,7 @@ void resolve(void)
ur_list = ur;
continue;
}
assert(ur->ptrptr);
ur->resolve(ur->data, ur->ptrptr);
++ur;
}

BIN
tests/data/184.dat
View File

Binary file not shown.

14
tests/orders.184
View File

@ -1,4 +1,16 @@
ERESSEA 6rLo "4jLm82"
ERESSEA 6rLo "6rLo"
EINHEIT 7Lgf
NACH NW NW
NAECHSTER
ERESSEA w86y "w86y"
EINHEIT uc3u
STIRB "mrqa"
NAECHSTER
ERESSEA ngij "ngij"
EINHEIT iwbz
HELFE w86y ALLES
EINHEIT j536
GRUPPE "Hodor"
HELFE w86y ALLES
HELFE w86y SILBER NICHT
NAECHSTER

5
tests/run-turn.sh
View File

@ -1,4 +1,5 @@
NEWFILES="data/185.dat datum parteien parteien.full htpasswd score turn"
NEWFILES="data/185.dat datum parteien parteien.full passwd htpasswd score turn"
cleanup () {
rm -rf reports $NEWFILES
}
@ -38,7 +39,7 @@ SUPP=../share/ubuntu-12_04.supp
SERVER="$VALGRIND --track-origins=yes --gen-suppressions=all --suppressions=$SUPP --error-exitcode=1 --leak-check=no $SERVER"
fi
echo "running $SERVER"
$SERVER -t 184 ../scripts/run-turn.lua
$SERVER -t 184 test-turn.lua
echo "integration tests"
[ -d reports ] || quit 4 "no reports directory created"
CRFILE=185-zvto.cr

5
tests/test-turn.lua Normal file
View File

@ -0,0 +1,5 @@
dofile('../scripts/run-turn.lua')
turn = get_turn()
eressea.free_game()
print("trying to read data from " .. turn)
eressea.read_game(turn .. ".dat")

2
tests/write-reports.sh
View File

@ -25,7 +25,7 @@ TESTS=../Debug/eressea/test_eressea
SERVER=../Debug/eressea/eressea
if [ -n "$VALGRIND" ]; then
SUPP=../share/ubuntu-12_04.supp
VALGRIND="$VALGRIND --suppressions=$SUPP --error-exitcode=1 --leak-check=no"
VALGRIND="$VALGRIND --track-origins=yes --gen-suppressions=all --suppressions=$SUPP --error-exitcode=1 --leak-check=no"
fi
echo "running $TESTS"
$VALGRIND $TESTS