ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/lib/cf.pm

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.94 by root, Thu Dec 21 23:02:54 2006 UTC vs.
Revision 1.219 by root, Sat Feb 17 03:19:44 2007 UTC

1	package cf;	1	package cf;
		2
		3	use utf8;
		4	use strict;
2		5
3	use Symbol;	6	use Symbol;
4	use List::Util;	7	use List::Util;
5	use Storable;	8	use Storable;
6	use Opcode;	9	use Opcode;
7	use Safe;	10	use Safe;
8	use Safe::Hole;	11	use Safe::Hole;
9		12
		13	use Coro 3.5 ();
		14	use Coro::Event;
		15	use Coro::Timer;
		16	use Coro::Signal;
		17	use Coro::Semaphore;
		18	use Coro::AIO;
		19
		20	use BDB ();
		21	use Data::Dumper;
		22	use Digest::MD5;
		23	use Fcntl;
10	use IO::AIO ();	24	use IO::AIO 2.32 ();
11	use YAML::Syck ();	25	use YAML::Syck ();
12	use Time::HiRes;	26	use Time::HiRes;
13	use Event;	27	use Compress::LZF;
		28
		29	Compress::LZF::sfreeze_cr { }; # prime Compress::LZF so it does not use require later
		30
14	$Event::Eval = 1; # no idea why this is required, but it is	31	use Event; $Event::Eval = 1; # no idea why this is required, but it is
		32
		33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
15		34
16	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?	35	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
17	$YAML::Syck::ImplicitUnicode = 1;	36	$YAML::Syck::ImplicitUnicode = 1;
18		37
19	use strict;	38	$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
20
21	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
22		39
23	our %COMMAND = ();	40	our %COMMAND = ();
24	our %COMMAND_TIME = ();	41	our %COMMAND_TIME = ();
		42
		43	our @EXTS = (); # list of extension package names
25	our %EXTCMD = ();	44	our %EXTCMD = ();
26		45	our %EXT_CORO = (); # coroutines bound to extensions
27	_init_vars;	46	our %EXT_MAP = (); # pluggable maps
28		47
29	our @EVENT;	48	our @EVENT;
30	our $LIBDIR = datadir . "/ext";	49	our $LIBDIR = datadir . "/ext";
31		50
32	our $TICK = MAX_TIME * 1e-6;	51	our $TICK = MAX_TIME * 1e-6;
33	our $TICK_WATCHER;	52	our $TICK_WATCHER;
		53	our $AIO_POLL_WATCHER;
		54	our $NEXT_RUNTIME_WRITE; # when should the runtime file be written
34	our $NEXT_TICK;	55	our $NEXT_TICK;
		56	our $NOW;
		57	our $USE_FSYNC = 1; # use fsync to write maps - default off
		58
		59	our $BDB_POLL_WATCHER;
		60	our $DB_ENV;
35		61
36	our %CFG;	62	our %CFG;
37		63
38	our $UPTIME; $UPTIME ||= time;	64	our $UPTIME; $UPTIME ||= time;
		65	our $RUNTIME;
		66
		67	our %PLAYER; # all users
		68	our %MAP; # all maps
		69	our $LINK_MAP; # the special {link} map, which is always available
		70	our $RANDOM_MAPS = cf::localdir . "/random";
		71	our $BDB_ENV_DIR = cf::localdir . "/db";
		72
		73	our $WAIT_FOR_TICK; $WAIT_FOR_TICK ||= new Coro::Signal;
		74	our $WAIT_FOR_TICK_ONE; $WAIT_FOR_TICK_ONE ||= new Coro::Signal;
		75
		76	# used to convert map paths into valid unix filenames by replacing / by ∕
		77	our $PATH_SEP = "∕"; # U+2215, chosen purely for visual reasons
		78
		79	binmode STDOUT;
		80	binmode STDERR;
		81
		82	# read virtual server time, if available
		83	unless ($RUNTIME || !-e cf::localdir . "/runtime") {
		84	open my $fh, "<", cf::localdir . "/runtime"
		85	or die "unable to read runtime file: $!";
		86	$RUNTIME = <$fh> + 0.;
		87	}
		88
		89	mkdir cf::localdir;
		90	mkdir cf::localdir . "/" . cf::playerdir;
		91	mkdir cf::localdir . "/" . cf::tmpdir;
		92	mkdir cf::localdir . "/" . cf::uniquedir;
		93	mkdir $RANDOM_MAPS;
		94	mkdir $BDB_ENV_DIR;
		95
		96	our $EMERGENCY_POSITION;
		97
		98	sub cf::map::normalise;
39		99
40	#############################################################################	100	#############################################################################
41		101
42	=head2 GLOBAL VARIABLES	102	=head2 GLOBAL VARIABLES
43		103
44	=over 4	104	=over 4
45		105
46	=item $cf::UPTIME	106	=item $cf::UPTIME
47		107
48	The timestamp of the server start (so not actually an uptime).	108	The timestamp of the server start (so not actually an uptime).
		109
		110	=item $cf::RUNTIME
		111
		112	The time this server has run, starts at 0 and is increased by $cf::TICK on
		113	every server tick.
49		114
50	=item $cf::LIBDIR	115	=item $cf::LIBDIR
51		116
52	The perl library directory, where extensions and cf-specific modules can	117	The perl library directory, where extensions and cf-specific modules can
53	be found. It will be added to C<@INC> automatically.	118	be found. It will be added to C<@INC> automatically.
54		119
		120	=item $cf::NOW
		121
		122	The time of the last (current) server tick.
		123
55	=item $cf::TICK	124	=item $cf::TICK
56		125
57	The interval between server ticks, in seconds.	126	The interval between server ticks, in seconds.
58		127
59	=item %cf::CFG	128	=item %cf::CFG
60		129
61	Configuration for the server, loaded from C</etc/crossfire/config>, or	130	Configuration for the server, loaded from C</etc/crossfire/config>, or
62	from wherever your confdir points to.	131	from wherever your confdir points to.
		132
		133	=item $cf::WAIT_FOR_TICK, $cf::WAIT_FOR_TICK_ONE
		134
		135	These are Coro::Signal objects that are C<< ->broadcast >> (WAIT_FOR_TICK)
		136	or C<< ->send >> (WAIT_FOR_TICK_ONE) on after normal server tick
		137	processing has been done. Call C<< ->wait >> on them to maximise the
		138	window of cpu time available, or simply to synchronise to the server tick.
63		139
64	=back	140	=back
65		141
66	=cut	142	=cut
67		143
68	BEGIN {	144	BEGIN {
69	*CORE::GLOBAL::warn = sub {	145	*CORE::GLOBAL::warn = sub {
70	my $msg = join "", @_;	146	my $msg = join "", @_;
		147	utf8::encode $msg;
		148
71	$msg .= "\n"	149	$msg .= "\n"
72	unless $msg =~ /\n$/;	150	unless $msg =~ /\n$/;
73		151
74	print STDERR "cfperl: $msg";
75	LOG llevError, "cfperl: $msg";	152	LOG llevError, $msg;
76	};	153	};
77	}	154	}
78		155
79	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';	156	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';
80	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';	157	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';
…		…
84	@safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';	161	@safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';
85		162
86	# we bless all objects into (empty) derived classes to force a method lookup	163	# we bless all objects into (empty) derived classes to force a method lookup
87	# within the Safe compartment.	164	# within the Safe compartment.
88	for my $pkg (qw(	165	for my $pkg (qw(
89	cf::global	166	cf::global cf::attachable
90	cf::object cf::object::player	167	cf::object cf::object::player
91	cf::client cf::player	168	cf::client cf::player
92	cf::arch cf::living	169	cf::arch cf::living
93	cf::map cf::party cf::region	170	cf::map cf::party cf::region
94	)) {	171	)) {
…		…
98		175
99	$Event::DIED = sub {	176	$Event::DIED = sub {
100	warn "error in event callback: @_";	177	warn "error in event callback: @_";
101	};	178	};
102		179
103	my %ext_pkg;
104	my @exts;
105	my @hook;
106
107	=head2 UTILITY FUNCTIONS	180	=head2 UTILITY FUNCTIONS
108		181
109	=over 4	182	=over 4
110		183
		184	=item dumpval $ref
		185
111	=cut	186	=cut
		187
		188	sub dumpval {
		189	eval {
		190	local $SIG{__DIE__};
		191	my $d;
		192	if (1) {
		193	$d = new Data::Dumper([$_[0]], ["*var"]);
		194	$d->Terse(1);
		195	$d->Indent(2);
		196	$d->Quotekeys(0);
		197	$d->Useqq(1);
		198	#$d->Bless(...);
		199	$d->Seen($_[1]) if @_ > 1;
		200	$d = $d->Dump();
		201	}
		202	$d =~ s/([\x00-\x07\x09\x0b\x0c\x0e-\x1f])/sprintf "\\x%02x", ord($1)/ge;
		203	$d
		204	} || "[unable to dump $_[0]: '$@']";
		205	}
112		206
113	use JSON::Syck (); # TODO# replace by JSON::PC once working	207	use JSON::Syck (); # TODO# replace by JSON::PC once working
114		208
115	=item $ref = cf::from_json $json	209	=item $ref = cf::from_json $json
116		210
…		…
130	=cut	224	=cut
131		225
132	sub to_json($) {	226	sub to_json($) {
133	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	227	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
134	JSON::Syck::Dump $_[0]	228	JSON::Syck::Dump $_[0]
		229	}
		230
		231	=item cf::lock_wait $string
		232
		233	Wait until the given lock is available. See cf::lock_acquire.
		234
		235	=item my $lock = cf::lock_acquire $string
		236
		237	Wait until the given lock is available and then acquires it and returns
		238	a Coro::guard object. If the guard object gets destroyed (goes out of scope,
		239	for example when the coroutine gets canceled), the lock is automatically
		240	returned.
		241
		242	Lock names should begin with a unique identifier (for example, cf::map::find
		243	uses map_find and cf::map::load uses map_load).
		244
		245	=cut
		246
		247	our %LOCK;
		248
		249	sub lock_wait($) {
		250	my ($key) = @_;
		251
		252	# wait for lock, if any
		253	while ($LOCK{$key}) {
		254	push @{ $LOCK{$key} }, $Coro::current;
		255	Coro::schedule;
		256	}
		257	}
		258
		259	sub lock_acquire($) {
		260	my ($key) = @_;
		261
		262	# wait, to be sure we are not locked
		263	lock_wait $key;
		264
		265	$LOCK{$key} = [];
		266
		267	Coro::guard {
		268	# wake up all waiters, to be on the safe side
		269	$_->ready for @{ delete $LOCK{$key} };
		270	}
		271	}
		272
		273	sub freeze_mainloop {
		274	return unless $TICK_WATCHER->is_active;
		275
		276	my $guard = Coro::guard {
		277	$TICK_WATCHER->start;
		278	};
		279	$TICK_WATCHER->stop;
		280	$guard
		281	}
		282
		283	=item cf::async { BLOCK }
		284
		285	Currently the same as Coro::async_pool, meaning you cannot use
		286	C<on_destroy>, C<join> or other gimmicks on these coroutines. The only
		287	thing you are allowed to do is call C<prio> on it.
		288
		289	=cut
		290
		291	BEGIN { *async = \&Coro::async_pool }
		292
		293	=item cf::sync_job { BLOCK }
		294
		295	The design of crossfire+ requires that the main coro ($Coro::main) is
		296	always able to handle events or runnable, as crossfire+ is only partly
		297	reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
		298
		299	If it must be done, put the blocking parts into C<sync_job>. This will run
		300	the given BLOCK in another coroutine while waiting for the result. The
		301	server will be frozen during this time, so the block should either finish
		302	fast or be very important.
		303
		304	=cut
		305
		306	sub sync_job(&) {
		307	my ($job) = @_;
		308
		309	if ($Coro::current == $Coro::main) {
		310	# this is the main coro, too bad, we have to block
		311	# till the operation succeeds, freezing the server :/
		312
		313	# TODO: use suspend/resume instead
		314	# (but this is cancel-safe)
		315	my $freeze_guard = freeze_mainloop;
		316
		317	my $busy = 1;
		318	my @res;
		319
		320	(async {
		321	@res = eval { $job->() };
		322	warn $@ if $@;
		323	undef $busy;
		324	})->prio (Coro::PRIO_MAX);
		325
		326	while ($busy) {
		327	Coro::cede or Event::one_event;
		328	}
		329
		330	wantarray ? @res : $res[0]
		331	} else {
		332	# we are in another coroutine, how wonderful, everything just works
		333
		334	$job->()
		335	}
		336	}
		337
		338	=item $coro = cf::async_ext { BLOCK }
		339
		340	Like async, but this coro is automatically being canceled when the
		341	extension calling this is being unloaded.
		342
		343	=cut
		344
		345	sub async_ext(&) {
		346	my $cb = shift;
		347
		348	my $coro = &Coro::async ($cb);
		349
		350	$coro->on_destroy (sub {
		351	delete $EXT_CORO{$coro+0};
		352	});
		353	$EXT_CORO{$coro+0} = $coro;
		354
		355	$coro
		356	}
		357
		358	sub write_runtime {
		359	my $guard = cf::lock_acquire "write_runtime";
		360
		361	my $runtime = cf::localdir . "/runtime";
		362
		363	my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644
		364	or return;
		365
		366	my $value = $cf::RUNTIME + 90 + 10;
		367	# 10 is the runtime save interval, for a monotonic clock
		368	# 60 allows for the watchdog to kill the server.
		369
		370	(aio_write $fh, 0, (length $value), $value, 0) <= 0
		371	and return;
		372
		373	# always fsync - this file is important
		374	aio_fsync $fh
		375	and return;
		376
		377	close $fh
		378	or return;
		379
		380	aio_rename "$runtime~", $runtime
		381	and return;
		382
		383	1
135	}	384	}
136		385
137	=back	386	=back
138		387
139	=cut	388	=cut
…		…
249	my ($self, $victim) = @_;	498	my ($self, $victim) = @_;
250	...	499	...
251	}	500	}
252	}	501	}
253		502
		503	=item $attachable->valid
		504
		505	Just because you have a perl object does not mean that the corresponding
		506	C-level object still exists. If you try to access an object that has no
		507	valid C counterpart anymore you get an exception at runtime. This method
		508	can be used to test for existence of the C object part without causing an
		509	exception.
		510
254	=cut	511	=cut
255		512
256	# the following variables are defined in .xs and must not be re-created	513	# the following variables are defined in .xs and must not be re-created
257	our @CB_GLOBAL = (); # registry for all global events	514	our @CB_GLOBAL = (); # registry for all global events
		515	our @CB_ATTACHABLE = (); # registry for all attachables
258	our @CB_OBJECT = (); # all objects (should not be used except in emergency)	516	our @CB_OBJECT = (); # all objects (should not be used except in emergency)
259	our @CB_PLAYER = ();	517	our @CB_PLAYER = ();
260	our @CB_CLIENT = ();	518	our @CB_CLIENT = ();
261	our @CB_TYPE = (); # registry for type (cf-object class) based events	519	our @CB_TYPE = (); # registry for type (cf-object class) based events
262	our @CB_MAP = ();	520	our @CB_MAP = ();
263		521
264	my %attachment;	522	my %attachment;
		523
		524	sub cf::attachable::thawer_merge {
		525	# simply override everything except _meta
		526	local $_[0]{_meta};
		527	%{$_[0]} = %{$_[1]};
		528	}
265		529
266	sub _attach_cb($$$$) {	530	sub _attach_cb($$$$) {
267	my ($registry, $event, $prio, $cb) = @_;	531	my ($registry, $event, $prio, $cb) = @_;
268		532
269	use sort 'stable';	533	use sort 'stable';
…		…
272		536
273	@{$registry->[$event]} = sort	537	@{$registry->[$event]} = sort
274	{ $a->[0] cmp $b->[0] }	538	{ $a->[0] cmp $b->[0] }
275	@{$registry->[$event] || []}, $cb;	539	@{$registry->[$event] || []}, $cb;
276	}	540	}
		541
		542	# hack
		543	my %attachable_klass = map +($_ => 1), KLASS_OBJECT, KLASS_CLIENT, KLASS_PLAYER, KLASS_MAP;
277		544
278	# attach handles attaching event callbacks	545	# attach handles attaching event callbacks
279	# the only thing the caller has to do is pass the correct	546	# the only thing the caller has to do is pass the correct
280	# registry (== where the callback attaches to).	547	# registry (== where the callback attaches to).
281	sub _attach {	548	sub _attach {
…		…
283		550
284	my $object_type;	551	my $object_type;
285	my $prio = 0;	552	my $prio = 0;
286	my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT;	553	my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT;
287		554
		555	#TODO: get rid of this hack
		556	if ($attachable_klass{$klass}) {
		557	%cb_id = (%cb_id, map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == KLASS_ATTACHABLE, 0 .. $#EVENT);
		558	}
		559
288	while (@arg) {	560	while (@arg) {
289	my $type = shift @arg;	561	my $type = shift @arg;
290		562
291	if ($type eq "prio") {	563	if ($type eq "prio") {
292	$prio = shift @arg;	564	$prio = shift @arg;
…		…
367	my ($obj, $name) = @_;	639	my ($obj, $name) = @_;
368		640
369	exists $obj->{_attachment}{$name}	641	exists $obj->{_attachment}{$name}
370	}	642	}
371		643
372	for my $klass (qw(GLOBAL OBJECT PLAYER CLIENT MAP)) {	644	for my $klass (qw(ATTACHABLE GLOBAL OBJECT PLAYER CLIENT MAP)) {
373	eval "#line " . __LINE__ . " 'cf.pm'	645	eval "#line " . __LINE__ . " 'cf.pm'
374	sub cf::\L$klass\E::_attach_registry {	646	sub cf::\L$klass\E::_attach_registry {
375	(\\\@CB_$klass, KLASS_$klass)	647	(\\\@CB_$klass, KLASS_$klass)
376	}	648	}
377		649
…		…
413	}	685	}
414		686
415	0	687	0
416	}	688	}
417		689
418	=item $bool = cf::invoke EVENT_GLOBAL_XXX, ...	690	=item $bool = cf::global::invoke (EVENT_CLASS_XXX, ...)
419		691
420	=item $bool = $object->invoke (EVENT_OBJECT_XXX, ...)
421
422	=item $bool = $player->invoke (EVENT_PLAYER_XXX, ...)
423
424	=item $bool = $client->invoke (EVENT_CLIENT_XXX, ...)	692	=item $bool = $attachable->invoke (EVENT_CLASS_XXX, ...)
425		693
426	=item $bool = $map->invoke (EVENT_MAP_XXX, ...)
427
428	Generate a global/object/player/map-specific event with the given arguments.	694	Generate an object-specific event with the given arguments.
429		695
430	This API is preliminary (most likely, the EVENT_KLASS_xxx prefix will be	696	This API is preliminary (most likely, the EVENT_CLASS_xxx prefix will be
431	removed in future versions), and there is no public API to access override	697	removed in future versions), and there is no public API to access override
432	results (if you must, access C<@cf::invoke_results> directly).	698	results (if you must, access C<@cf::invoke_results> directly).
433		699
434	=back	700	=back
435		701
436	=cut	702	=cut
437		703
438	#############################################################################	704	#############################################################################
439
440	=head2 METHODS VALID FOR ALL ATTACHABLE OBJECTS
441
442	Attachable objects includes objects, players, clients and maps.
443
444	=over 4
445
446	=item $object->valid
447
448	Just because you have a perl object does not mean that the corresponding
449	C-level object still exists. If you try to access an object that has no
450	valid C counterpart anymore you get an exception at runtime. This method
451	can be used to test for existence of the C object part without causing an
452	exception.
453
454	=back
455
456	=cut
457
458	#############################################################################
459	# object support	705	# object support
460		706
461	sub instantiate {
462	my ($obj, $data) = @_;
463
464	$data = from_json $data;
465
466	for (@$data) {
467	my ($name, $args) = @$_;
468
469	$obj->attach ($name, %{$args || {} });
470	}
471	}
472
473	# basically do the same as instantiate, without calling instantiate
474	sub reattach {	707	sub reattach {
		708	# basically do the same as instantiate, without calling instantiate
475	my ($obj) = @_;	709	my ($obj) = @_;
		710
		711	bless $obj, ref $obj; # re-bless in case extensions have been reloaded
		712
476	my $registry = $obj->registry;	713	my $registry = $obj->registry;
477		714
478	@$registry = ();	715	@$registry = ();
479		716
480	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} || {} };	717	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} || {} };
…		…
489	warn "object uses attachment '$name' that is not available, postponing.\n";	726	warn "object uses attachment '$name' that is not available, postponing.\n";
490	}	727	}
491	}	728	}
492	}	729	}
493		730
494	sub object_freezer_save {	731	cf::attachable->attach (
495	my ($filename, $rdata, $objs) = @_;
496
497	if (length $$rdata) {
498	warn sprintf "saving %s (%d,%d)\n",
499	$filename, length $$rdata, scalar @$objs;
500
501	if (open my $fh, ">:raw", "$filename~") {
502	chmod SAVE_MODE, $fh;
503	syswrite $fh, $$rdata;
504	close $fh;
505
506	if (@$objs && open my $fh, ">:raw", "$filename.pst~") {
507	chmod SAVE_MODE, $fh;
508	syswrite $fh, Storable::nfreeze { version => 1, objs => $objs };
509	close $fh;
510	rename "$filename.pst~", "$filename.pst";
511	} else {
512	unlink "$filename.pst";
513	}
514
515	rename "$filename~", $filename;
516	} else {
517	warn "FATAL: $filename~: $!\n";
518	}
519	} else {
520	unlink $filename;
521	unlink "$filename.pst";
522	}
523	}
524
525	sub object_freezer_as_string {
526	my ($rdata, $objs) = @_;
527
528	use Data::Dumper;
529
530	$$rdata . Dumper $objs
531	}
532
533	sub object_thawer_load {
534	my ($filename) = @_;
535
536	local $/;
537
538	my $av;
539
540	#TODO: use sysread etc.
541	if (open my $data, "<:raw:perlio", $filename) {
542	$data = <$data>;
543	if (open my $pst, "<:raw:perlio", "$filename.pst") {
544	$av = eval { (Storable::thaw <$pst>)->{objs} };
545	}
546	return ($data, $av);
547	}
548
549	()
550	}
551
552	cf::object->attach (
553	prio => -1000000,	732	prio => -1000000,
		733	on_instantiate => sub {
		734	my ($obj, $data) = @_;
		735
		736	$data = from_json $data;
		737
		738	for (@$data) {
		739	my ($name, $args) = @$_;
		740
		741	$obj->attach ($name, %{$args || {} });
		742	}
		743	},
		744	on_reattach => \&reattach,
554	on_clone => sub {	745	on_clone => sub {
555	my ($src, $dst) = @_;	746	my ($src, $dst) = @_;
556		747
557	@{$dst->registry} = @{$src->registry};	748	@{$dst->registry} = @{$src->registry};
558		749
…		…
561	%{$dst->{_attachment}} = %{$src->{_attachment}}	752	%{$dst->{_attachment}} = %{$src->{_attachment}}
562	if exists $src->{_attachment};	753	if exists $src->{_attachment};
563	},	754	},
564	);	755	);
565		756
		757	sub object_freezer_save {
		758	my ($filename, $rdata, $objs) = @_;
		759
		760	sync_job {
		761	if (length $$rdata) {
		762	warn sprintf "saving %s (%d,%d)\n",
		763	$filename, length $$rdata, scalar @$objs;
		764
		765	if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) {
		766	chmod SAVE_MODE, $fh;
		767	aio_write $fh, 0, (length $$rdata), $$rdata, 0;
		768	aio_fsync $fh if $cf::USE_FSYNC;
		769	close $fh;
		770
		771	if (@$objs) {
		772	if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {
		773	chmod SAVE_MODE, $fh;
		774	my $data = Storable::nfreeze { version => 1, objs => $objs };
		775	aio_write $fh, 0, (length $data), $data, 0;
		776	aio_fsync $fh if $cf::USE_FSYNC;
		777	close $fh;
		778	aio_rename "$filename.pst~", "$filename.pst";
		779	}
		780	} else {
		781	aio_unlink "$filename.pst";
		782	}
		783
		784	aio_rename "$filename~", $filename;
		785	} else {
		786	warn "FATAL: $filename~: $!\n";
		787	}
		788	} else {
		789	aio_unlink $filename;
		790	aio_unlink "$filename.pst";
		791	}
		792	}
		793	}
		794
		795	sub object_freezer_as_string {
		796	my ($rdata, $objs) = @_;
		797
		798	use Data::Dumper;
		799
		800	$$rdata . Dumper $objs
		801	}
		802
		803	sub object_thawer_load {
		804	my ($filename) = @_;
		805
		806	my ($data, $av);
		807
		808	(aio_load $filename, $data) >= 0
		809	or return;
		810
		811	unless (aio_stat "$filename.pst") {
		812	(aio_load "$filename.pst", $av) >= 0
		813	or return;
		814	$av = eval { (Storable::thaw $av)->{objs} };
		815	}
		816
		817	warn sprintf "loading %s (%d)\n",
		818	$filename, length $data, scalar @{$av || []};#d#
		819	return ($data, $av);
		820	}
		821
566	#############################################################################	822	#############################################################################
567	# command handling &c	823	# command handling &c
568		824
569	=item cf::register_command $name => \&callback($ob,$args);	825	=item cf::register_command $name => \&callback($ob,$args);
570		826
…		…
592	=cut	848	=cut
593		849
594	sub register_extcmd {	850	sub register_extcmd {
595	my ($name, $cb) = @_;	851	my ($name, $cb) = @_;
596		852
597	my $caller = caller;
598	#warn "registering extcmd '$name' to '$caller'";
599
600	$EXTCMD{$name} = [$cb, $caller];	853	$EXTCMD{$name} = $cb;
601	}	854	}
602		855
603	cf::player->attach (	856	cf::player->attach (
604	on_command => sub {	857	on_command => sub {
605	my ($pl, $name, $params) = @_;	858	my ($pl, $name, $params) = @_;
…		…
618		871
619	my $msg = eval { from_json $buf };	872	my $msg = eval { from_json $buf };
620		873
621	if (ref $msg) {	874	if (ref $msg) {
622	if (my $cb = $EXTCMD{$msg->{msgtype}}) {	875	if (my $cb = $EXTCMD{$msg->{msgtype}}) {
623	if (my %reply = $cb->[0]->($pl, $msg)) {	876	if (my %reply = $cb->($pl, $msg)) {
624	$pl->ext_reply ($msg->{msgid}, %reply);	877	$pl->ext_reply ($msg->{msgid}, %reply);
625	}	878	}
626	}	879	}
627	} else {	880	} else {
628	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";	881	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";
…		…
630		883
631	cf::override;	884	cf::override;
632	},	885	},
633	);	886	);
634		887
635	sub register {
636	my ($base, $pkg) = @_;
637
638	#TODO
639	}
640
641	sub load_extension {	888	sub load_extension {
642	my ($path) = @_;	889	my ($path) = @_;
643		890
644	$path =~ /([^\/\\]+)\.ext$/ or die "$path";	891	$path =~ /([^\/\\]+)\.ext$/ or die "$path";
645	my $base = $1;	892	my $base = $1;
646	my $pkg = $1;	893	my $pkg = $1;
647	$pkg =~ s/[^[:word:]]/_/g;	894	$pkg =~ s/[^[:word:]]/_/g;
648	$pkg = "ext::$pkg";	895	$pkg = "ext::$pkg";
649		896
650	warn "loading '$path' into '$pkg'\n";	897	warn "... loading '$path' into '$pkg'\n";
651		898
652	open my $fh, "<:utf8", $path	899	open my $fh, "<:utf8", $path
653	or die "$path: $!";	900	or die "$path: $!";
654		901
655	my $source =	902	my $source =
656	"package $pkg; use strict; use utf8;\n"	903	"package $pkg; use strict; use utf8;\n"
657	. "#line 1 \"$path\"\n{\n"	904	. "#line 1 \"$path\"\n{\n"
658	. (do { local $/; <$fh> })	905	. (do { local $/; <$fh> })
659	. "\n};\n1";	906	. "\n};\n1";
660		907
661	eval $source	908	unless (eval $source) {
662	or die $@ ? "$path: $@\n"	909	my $msg = $@ ? "$path: $@\n"
663	: "extension disabled.\n";	910	: "extension disabled.\n";
664		911	if ($source =~ /^#!.*perl.*#.*MANDATORY/m) { # ugly match
665	push @exts, $pkg;	912	warn $@;
666	$ext_pkg{$base} = $pkg;	913	warn "mandatory extension failed to load, exiting.\n";
667		914	exit 1;
668	# no strict 'refs';	915	}
669	# @{"$pkg\::ISA"} = ext::;	916	die $@;
670
671	register $base, $pkg;
672	}
673
674	sub unload_extension {
675	my ($pkg) = @_;
676
677	warn "removing extension $pkg\n";
678
679	# remove hooks
680	#TODO
681	# for my $idx (0 .. $#PLUGIN_EVENT) {
682	# delete $hook[$idx]{$pkg};
683	# }	917	}
684		918
685	# remove commands	919	push @EXTS, $pkg;
686	for my $name (keys %COMMAND) {
687	my @cb = grep $_->[0] ne $pkg, @{ $COMMAND{$name} };
688
689	if (@cb) {
690	$COMMAND{$name} = \@cb;
691	} else {
692	delete $COMMAND{$name};
693	}
694	}
695
696	# remove extcmds
697	for my $name (grep $EXTCMD{$_}[1] eq $pkg, keys %EXTCMD) {
698	delete $EXTCMD{$name};
699	}
700
701	if (my $cb = $pkg->can ("unload")) {
702	eval {
703	$cb->($pkg);
704	1
705	} or warn "$pkg unloaded, but with errors: $@";
706	}
707
708	Symbol::delete_package $pkg;
709	}	920	}
710		921
711	sub load_extensions {	922	sub load_extensions {
712	for my $ext (<$LIBDIR/*.ext>) {	923	for my $ext (<$LIBDIR/*.ext>) {
713	next unless -r $ext;	924	next unless -r $ext;
…		…
717	} or warn "$ext not loaded: $@";	928	} or warn "$ext not loaded: $@";
718	}	929	}
719	}	930	}
720		931
721	#############################################################################	932	#############################################################################
722	# load/save/clean perl data associated with a map
723		933
724	*cf::mapsupport::on_clean = sub {	934	=head2 CORE EXTENSIONS
		935
		936	Functions and methods that extend core crossfire objects.
		937
		938	=cut
		939
		940	package cf::player;
		941
		942	use Coro::AIO;
		943
		944	=head3 cf::player
		945
		946	=over 4
		947
		948	=item cf::player::find $login
		949
		950	Returns the given player object, loading it if necessary (might block).
		951
		952	=cut
		953
		954	sub playerdir($) {
		955	cf::localdir
		956	. "/"
		957	. cf::playerdir
		958	. "/"
		959	. (ref $_[0] ? $_[0]->ob->name : $_[0])
		960	}
		961
		962	sub path($) {
		963	my $login = ref $_[0] ? $_[0]->ob->name : $_[0];
		964
		965	(playerdir $login) . "/$login.pl"
		966	}
		967
		968	sub find_active($) {
		969	$cf::PLAYER{$_[0]}
		970	and $cf::PLAYER{$_[0]}->active
		971	and $cf::PLAYER{$_[0]}
		972	}
		973
		974	sub exists($) {
		975	my ($login) = @_;
		976
		977	$cf::PLAYER{$login}
		978	or cf::sync_job { !aio_stat path $login }
		979	}
		980
		981	sub find($) {
		982	return $cf::PLAYER{$_[0]} || do {
		983	my $login = $_[0];
		984
		985	my $guard = cf::lock_acquire "user_find:$login";
		986
		987	$cf::PLAYER{$_[0]} || do {
		988	my $pl = load_pl path $login
		989	or return;
		990	$cf::PLAYER{$login} = $pl
		991	}
		992	}
		993	}
		994
		995	sub save($) {
		996	my ($pl) = @_;
		997
		998	return if $pl->{deny_save};
		999
		1000	my $path = path $pl;
		1001	my $guard = cf::lock_acquire "user_save:$path";
		1002
		1003	return if $pl->{deny_save};
		1004
		1005	aio_mkdir playerdir $pl, 0770;
		1006	$pl->{last_save} = $cf::RUNTIME;
		1007
		1008	$pl->save_pl ($path);
		1009	Coro::cede;
		1010	}
		1011
		1012	sub new($) {
		1013	my ($login) = @_;
		1014
		1015	my $self = create;
		1016
		1017	$self->ob->name ($login);
		1018	$self->{deny_save} = 1;
		1019
		1020	$cf::PLAYER{$login} = $self;
		1021
		1022	$self
		1023	}
		1024
		1025	=item $pl->quit_character
		1026
		1027	Nukes the player without looking back. If logged in, the connection will
		1028	be destroyed. May block for a long time.
		1029
		1030	=cut
		1031
		1032	sub quit_character {
		1033	my ($pl) = @_;
		1034
		1035	$pl->{deny_save} = 1;
		1036	$pl->password ("*"); # this should lock out the player until we nuked the dir
		1037
		1038	$pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->active;
		1039	$pl->deactivate;
		1040	$pl->invoke (cf::EVENT_PLAYER_QUIT);
		1041	$pl->ns->destroy if $pl->ns;
		1042
		1043	my $path = playerdir $pl;
		1044	my $temp = "$path~$cf::RUNTIME~deleting~";
		1045	aio_rename $path, $temp;
		1046	delete $cf::PLAYER{$pl->ob->name};
		1047	$pl->destroy;
		1048	IO::AIO::aio_rmtree $temp;
		1049	}
		1050
		1051	=item cf::player::list_logins
		1052
		1053	Returns am arrayref of all valid playernames in the system, can take a
		1054	while and may block, so not sync_job-capable, ever.
		1055
		1056	=cut
		1057
		1058	sub list_logins {
		1059	my $dirs = aio_readdir cf::localdir . "/" . cf::playerdir
		1060	or return [];
		1061
		1062	my @logins;
		1063
		1064	for my $login (@$dirs) {
		1065	my $fh = aio_open path $login, Fcntl::O_RDONLY, 0 or next;
		1066	aio_read $fh, 0, 512, my $buf, 0 or next;
		1067	$buf !~ /^password -------------$/m or next; # official not-valid tag
		1068
		1069	utf8::decode $login;
		1070	push @logins, $login;
		1071	}
		1072
		1073	\@logins
		1074	}
		1075
		1076	=item $player->maps
		1077
		1078	Returns an arrayref of map paths that are private for this
		1079	player. May block.
		1080
		1081	=cut
		1082
		1083	sub maps($) {
		1084	my ($pl) = @_;
		1085
		1086	$pl = ref $pl ? $pl->ob->name : $pl;
		1087
		1088	my $files = aio_readdir playerdir $pl
		1089	or return;
		1090
		1091	my @paths;
		1092
		1093	for (@$files) {
		1094	utf8::decode $_;
		1095	next if /\.(?:pl|pst)$/;
		1096	next unless /^$PATH_SEP/o;
		1097
		1098	push @paths, cf::map::normalise "~$pl/$_";
		1099	}
		1100
		1101	\@paths
		1102	}
		1103
		1104	=item $player->ext_reply ($msgid, $msgtype, %msg)
		1105
		1106	Sends an ext reply to the player.
		1107
		1108	=cut
		1109
		1110	sub ext_reply($$$%) {
		1111	my ($self, $id, %msg) = @_;
		1112
		1113	$msg{msgid} = $id;
		1114
		1115	$self->send ("ext " . cf::to_json \%msg);
		1116	}
		1117
		1118	package cf;
		1119
		1120	=back
		1121
		1122
		1123	=head3 cf::map
		1124
		1125	=over 4
		1126
		1127	=cut
		1128
		1129	package cf::map;
		1130
		1131	use Fcntl;
		1132	use Coro::AIO;
		1133
		1134	use overload
		1135	'""' => \&as_string,
		1136	fallback => 1;
		1137
		1138	our $MAX_RESET = 3600;
		1139	our $DEFAULT_RESET = 3000;
		1140
		1141	sub generate_random_map {
		1142	my ($self, $rmp) = @_;
		1143	# mit "rum" bekleckern, nicht
		1144	$self->_create_random_map (
		1145	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
		1146	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
		1147	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
		1148	$rmp->{exit_on_final_map},
		1149	$rmp->{xsize}, $rmp->{ysize},
		1150	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
		1151	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
		1152	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
		1153	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
		1154	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
		1155	(cf::region::find $rmp->{region}), $rmp->{custom}
		1156	)
		1157	}
		1158
		1159	=item cf::map->register ($regex, $prio)
		1160
		1161	Register a handler for the map path matching the given regex at the
		1162	givne priority (higher is better, built-in handlers have priority 0, the
		1163	default).
		1164
		1165	=cut
		1166
		1167	sub register {
		1168	my (undef, $regex, $prio) = @_;
		1169	my $pkg = caller;
		1170
		1171	no strict;
		1172	push @{"$pkg\::ISA"}, __PACKAGE__;
		1173
		1174	$EXT_MAP{$pkg} = [$prio, qr<$regex>];
		1175	}
		1176
		1177	# also paths starting with '/'
		1178	$EXT_MAP{"cf::map"} = [0, qr{^(?=/)}];
		1179
		1180	sub thawer_merge {
		1181	my ($self, $merge) = @_;
		1182
		1183	# we have to keep some variables in memory intact
		1184	local $self->{path};
		1185	local $self->{load_path};
		1186	local $self->{deny_save};
		1187	local $self->{deny_reset};
		1188
		1189	$self->SUPER::thawer_merge ($merge);
		1190	}
		1191
		1192	sub normalise {
		1193	my ($path, $base) = @_;
		1194
		1195	$path = "$path"; # make sure its a string
		1196
		1197	$path =~ s/\.map$//;
		1198
		1199	# map plan:
		1200	#
		1201	# /! non-realised random map exit (special hack!)
		1202	# {... are special paths that are not being touched
		1203	# ?xxx/... are special absolute paths
		1204	# ?random/... random maps
		1205	# /... normal maps
		1206	# ~user/... per-player map of a specific user
		1207
		1208	$path =~ s/$PATH_SEP/\//go;
		1209
		1210	# treat it as relative path if it starts with
		1211	# something that looks reasonable
		1212	if ($path =~ m{^(?:\./|\.\./|\w)}) {
		1213	$base or Carp::carp "normalise called with relative path and no base: '$path'";
		1214
		1215	$base =~ s{[^/]+/?$}{};
		1216	$path = "$base/$path";
		1217	}
		1218
		1219	for ($path) {
		1220	redo if s{//}{/};
		1221	redo if s{/\.?/}{/};
		1222	redo if s{/[^/]+/\.\./}{/};
		1223	}
		1224
		1225	$path
		1226	}
		1227
		1228	sub new_from_path {
		1229	my (undef, $path, $base) = @_;
		1230
		1231	return $path if UNIVERSAL::isa $path, "cf::map"; # already a map object
		1232
		1233	$path = normalise $path, $base;
		1234
		1235	for my $pkg (sort { $EXT_MAP{$b}[0] <=> $EXT_MAP{$a}[0] } keys %EXT_MAP) {
		1236	if ($path =~ $EXT_MAP{$pkg}[1]) {
		1237	my $self = bless cf::map::new, $pkg;
		1238	$self->{path} = $path; $self->path ($path);
		1239	$self->init; # pass $1 etc.
		1240	return $self;
		1241	}
		1242	}
		1243
		1244	Carp::carp "unable to resolve path '$path' (base '$base').";
		1245	()
		1246	}
		1247
		1248	sub init {
		1249	my ($self) = @_;
		1250
		1251	$self
		1252	}
		1253
		1254	sub as_string {
		1255	my ($self) = @_;
		1256
		1257	"$self->{path}"
		1258	}
		1259
		1260	# the displayed name, this is a one way mapping
		1261	sub visible_name {
		1262	&as_string
		1263	}
		1264
		1265	# the original (read-only) location
		1266	sub load_path {
		1267	my ($self) = @_;
		1268
		1269	sprintf "%s/%s/%s.map", cf::datadir, cf::mapdir, $self->{path}
		1270	}
		1271
		1272	# the temporary/swap location
		1273	sub save_path {
		1274	my ($self) = @_;
		1275
		1276	(my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
		1277	sprintf "%s/%s/%s.map", cf::localdir, cf::tmpdir, $path
		1278	}
		1279
		1280	# the unique path, undef == no special unique path
		1281	sub uniq_path {
		1282	my ($self) = @_;
		1283
		1284	(my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
		1285	sprintf "%s/%s/%s", cf::localdir, cf::uniquedir, $path
		1286	}
		1287
		1288	# and all this just because we cannot iterate over
		1289	# all maps in C++...
		1290	sub change_all_map_light {
		1291	my ($change) = @_;
		1292
		1293	$_->change_map_light ($change)
		1294	for grep $_->outdoor, values %cf::MAP;
		1295	}
		1296
		1297	sub unlink_save {
		1298	my ($self) = @_;
		1299
		1300	utf8::encode (my $save = $self->save_path);
		1301	IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink $save;
		1302	IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink "$save.pst";
		1303	}
		1304
		1305	sub load_header_from($) {
		1306	my ($self, $path) = @_;
		1307
		1308	utf8::encode $path;
		1309	#aio_open $path, O_RDONLY, 0
		1310	# or return;
		1311
		1312	$self->_load_header ($path)
		1313	or return;
		1314
		1315	$self->{load_path} = $path;
		1316
		1317	1
		1318	}
		1319
		1320	sub load_header_orig {
		1321	my ($self) = @_;
		1322
		1323	$self->load_header_from ($self->load_path)
		1324	}
		1325
		1326	sub load_header_temp {
		1327	my ($self) = @_;
		1328
		1329	$self->load_header_from ($self->save_path)
		1330	}
		1331
		1332	sub prepare_temp {
		1333	my ($self) = @_;
		1334
		1335	$self->last_access ((delete $self->{last_access})
		1336	|| $cf::RUNTIME); #d#
		1337	# safety
		1338	$self->{instantiate_time} = $cf::RUNTIME
		1339	if $self->{instantiate_time} > $cf::RUNTIME;
		1340	}
		1341
		1342	sub prepare_orig {
		1343	my ($self) = @_;
		1344
		1345	$self->{load_original} = 1;
		1346	$self->{instantiate_time} = $cf::RUNTIME;
		1347	$self->last_access ($cf::RUNTIME);
		1348	$self->instantiate;
		1349	}
		1350
		1351	sub load_header {
		1352	my ($self) = @_;
		1353
		1354	if ($self->load_header_temp) {
		1355	$self->prepare_temp;
		1356	} else {
		1357	$self->load_header_orig
		1358	or return;
		1359	$self->prepare_orig;
		1360	}
		1361
		1362	1
		1363	}
		1364
		1365	sub find;
		1366	sub find {
		1367	my ($path, $origin) = @_;
		1368
		1369	$path = normalise $path, $origin && $origin->path;
		1370
		1371	cf::lock_wait "map_find:$path";
		1372
		1373	$cf::MAP{$path} || do {
		1374	my $guard = cf::lock_acquire "map_find:$path";
		1375	my $map = new_from_path cf::map $path
		1376	or return;
		1377
		1378	$map->{last_save} = $cf::RUNTIME;
		1379
		1380	$map->load_header
		1381	or return;
		1382
		1383	if ($map->should_reset && 0) {#d#TODO# disabled, crashy (locking issue?)
		1384	# doing this can freeze the server in a sync job, obviously
		1385	#$cf::WAIT_FOR_TICK->wait;
		1386	$map->reset;
		1387	undef $guard;
		1388	return find $path;
		1389	}
		1390
		1391	$cf::MAP{$path} = $map
		1392	}
		1393	}
		1394
		1395	sub pre_load { }
		1396	sub post_load { }
		1397
		1398	sub load {
		1399	my ($self) = @_;
		1400
		1401	local $self->{deny_reset} = 1; # loading can take a long time
		1402
		1403	my $path = $self->{path};
		1404	my $guard = cf::lock_acquire "map_load:$path";
		1405
		1406	return if $self->in_memory != cf::MAP_SWAPPED;
		1407
		1408	$self->in_memory (cf::MAP_LOADING);
		1409
		1410	$self->alloc;
		1411
		1412	$self->pre_load;
		1413
		1414	$self->_load_objects ($self->{load_path}, 1)
		1415	or return;
		1416
		1417	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1418	if delete $self->{load_original};
		1419
		1420	if (my $uniq = $self->uniq_path) {
		1421	utf8::encode $uniq;
		1422	if (aio_open $uniq, O_RDONLY, 0) {
		1423	$self->clear_unique_items;
		1424	$self->_load_objects ($uniq, 0);
		1425	}
		1426	}
		1427
		1428	Coro::cede;
		1429
		1430	# now do the right thing for maps
		1431	$self->link_multipart_objects;
		1432
		1433	unless ($self->{deny_activate}) {
		1434	$self->decay_objects;
		1435	$self->fix_auto_apply;
		1436	$self->update_buttons;
		1437	Coro::cede;
		1438	$self->set_darkness_map;
		1439	$self->difficulty ($self->estimate_difficulty)
		1440	unless $self->difficulty;
		1441	Coro::cede;
		1442	$self->activate;
		1443	}
		1444
		1445	$self->post_load;
		1446
		1447	$self->in_memory (cf::MAP_IN_MEMORY);
		1448	}
		1449
		1450	sub customise_for {
		1451	my ($self, $ob) = @_;
		1452
		1453	return find "~" . $ob->name . "/" . $self->{path}
		1454	if $self->per_player;
		1455
		1456	$self
		1457	}
		1458
		1459	# find and load all maps in the 3x3 area around a map
		1460	sub load_diag {
725	my ($map) = @_;	1461	my ($map) = @_;
726		1462
727	my $path = $map->tmpname;	1463	my @diag; # diagonal neighbours
728	defined $path or return;
729		1464
730	unlink "$path.pst";	1465	for (0 .. 3) {
731	};	1466	my $neigh = $map->tile_path ($_)
		1467	or next;
		1468	$neigh = find $neigh, $map
		1469	or next;
		1470	$neigh->load;
732		1471
733	cf::map->attach (prio => -10000, package => cf::mapsupport::);	1472	push @diag, [$neigh->tile_path (($_ + 3) % 4), $neigh],
		1473	[$neigh->tile_path (($_ + 1) % 4), $neigh];
		1474	}
734		1475
735	#############################################################################	1476	for (@diag) {
736	# load/save perl data associated with player->ob objects	1477	my $neigh = find @$_
737		1478	or next;
738	sub all_objects(@) {	1479	$neigh->load;
739	@_, map all_objects ($_->inv), @_	1480	}
740	}	1481	}
741		1482
742	# TODO: compatibility cruft, remove when no longer needed	1483	sub find_sync {
743	cf::player->attach (	1484	my ($path, $origin) = @_;
744	on_load => sub {
745	my ($pl, $path) = @_;
746		1485
747	for my $o (all_objects $pl->ob) {	1486	cf::sync_job { find $path, $origin }
748	if (my $value = $o->get_ob_key_value ("_perl_data")) {	1487	}
749	$o->set_ob_key_value ("_perl_data");
750		1488
751	%$o = %{ Storable::thaw pack "H*", $value };	1489	sub do_load_sync {
		1490	my ($map) = @_;
		1491
		1492	cf::sync_job { $map->load };
		1493	}
		1494
		1495	our %MAP_PREFETCH;
		1496	our $MAP_PREFETCHER = undef;
		1497
		1498	sub find_async {
		1499	my ($path, $origin) = @_;
		1500
		1501	$path = normalise $path, $origin && $origin->{path};
		1502
		1503	if (my $map = $cf::MAP{$path}) {
		1504	return $map if $map->in_memory == cf::MAP_IN_MEMORY;
		1505	}
		1506
		1507	undef $MAP_PREFETCH{$path};
		1508	$MAP_PREFETCHER ||= cf::async {
		1509	while (%MAP_PREFETCH) {
		1510	for my $path (keys %MAP_PREFETCH) {
		1511	my $map = find $path
		1512	or next;
		1513	$map->load;
		1514
		1515	delete $MAP_PREFETCH{$path};
752	}	1516	}
753	}	1517	}
		1518	undef $MAP_PREFETCHER;
		1519	};
		1520	$MAP_PREFETCHER->prio (6);
		1521
		1522	()
		1523	}
		1524
		1525	sub save {
		1526	my ($self) = @_;
		1527
		1528	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1529
		1530	$self->{last_save} = $cf::RUNTIME;
		1531
		1532	return unless $self->dirty;
		1533
		1534	my $save = $self->save_path; utf8::encode $save;
		1535	my $uniq = $self->uniq_path; utf8::encode $uniq;
		1536
		1537	$self->{load_path} = $save;
		1538
		1539	return if $self->{deny_save};
		1540
		1541	local $self->{last_access} = $self->last_access;#d#
		1542
		1543	cf::async {
		1544	$_->contr->save for $self->players;
		1545	};
		1546
		1547	if ($uniq) {
		1548	$self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
		1549	$self->_save_objects ($uniq, cf::IO_UNIQUES);
		1550	} else {
		1551	$self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
754	},	1552	}
755	);	1553	}
756		1554
757	#############################################################################	1555	sub swap_out {
		1556	my ($self) = @_;
758		1557
759	=head2 CORE EXTENSIONS	1558	# save first because save cedes
		1559	$self->save;
760		1560
761	Functions and methods that extend core crossfire objects.	1561	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1562
		1563	return if $self->players;
		1564	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1565	return if $self->{deny_save};
		1566
		1567	$self->clear;
		1568	$self->in_memory (cf::MAP_SWAPPED);
		1569	}
		1570
		1571	sub reset_at {
		1572	my ($self) = @_;
		1573
		1574	# TODO: safety, remove and allow resettable per-player maps
		1575	return 1e99 if $self->isa ("ext::map_per_player");#d#
		1576	return 1e99 if $self->{deny_reset};
		1577
		1578	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1579	my $to = List::Util::min $MAX_RESET, $self->reset_timeout || $DEFAULT_RESET;
		1580
		1581	$time + $to
		1582	}
		1583
		1584	sub should_reset {
		1585	my ($self) = @_;
		1586
		1587	$self->reset_at <= $cf::RUNTIME
		1588	}
		1589
		1590	sub reset {
		1591	my ($self) = @_;
		1592
		1593	my $lock = cf::lock_acquire "map_data:$self->{path}";
		1594
		1595	return if $self->players;
		1596	return if $self->isa ("ext::map_per_player");#d#
		1597
		1598	warn "resetting map ", $self->path;#d#
		1599
		1600	$self->in_memory (cf::MAP_SWAPPED);
		1601
		1602	# need to save uniques path
		1603	unless ($self->{deny_save}) {
		1604	my $uniq = $self->uniq_path; utf8::encode $uniq;
		1605
		1606	$self->_save_objects ($uniq, cf::IO_UNIQUES)
		1607	if $uniq;
		1608	}
		1609
		1610	delete $cf::MAP{$self->path};
		1611
		1612	$self->clear;
		1613
		1614	$_->clear_links_to ($self) for values %cf::MAP;
		1615
		1616	$self->unlink_save;
		1617	$self->destroy;
		1618	}
		1619
		1620	my $nuke_counter = "aaaa";
		1621
		1622	sub nuke {
		1623	my ($self) = @_;
		1624
		1625	delete $cf::MAP{$self->path};
		1626
		1627	$self->unlink_save;
		1628
		1629	bless $self, "cf::map";
		1630	delete $self->{deny_reset};
		1631	$self->{deny_save} = 1;
		1632	$self->reset_timeout (1);
		1633	$self->path ($self->{path} = "{nuke}/" . ($nuke_counter++));
		1634
		1635	$cf::MAP{$self->path} = $self;
		1636
		1637	$self->reset; # polite request, might not happen
		1638	}
		1639
		1640	=item cf::map::unique_maps
		1641
		1642	Returns an arrayref of paths of all shared maps that have
		1643	instantiated unique items. May block.
		1644
		1645	=cut
		1646
		1647	sub unique_maps() {
		1648	my $files = aio_readdir cf::localdir . "/" . cf::uniquedir
		1649	or return;
		1650
		1651	my @paths;
		1652
		1653	for (@$files) {
		1654	utf8::decode $_;
		1655	next if /\.pst$/;
		1656	next unless /^$PATH_SEP/o;
		1657
		1658	push @paths, cf::map::normalise $_;
		1659	}
		1660
		1661	\@paths
		1662	}
		1663
		1664	package cf;
		1665
		1666	=back
		1667
		1668	=head3 cf::object
		1669
		1670	=cut
		1671
		1672	package cf::object;
762		1673
763	=over 4	1674	=over 4
764		1675
765	=item cf::player::exists $login	1676	=item $ob->inv_recursive
766		1677
767	Returns true when the given account exists.	1678	Returns the inventory of the object _and_ their inventories, recursively.
768		1679
769	=cut	1680	=cut
770		1681
771	sub cf::player::exists($) {	1682	sub inv_recursive_;
772	cf::player::find $_[0]	1683	sub inv_recursive_ {
773	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;	1684	map { $_, inv_recursive_ $_->inv } @_
774	}	1685	}
		1686
		1687	sub inv_recursive {
		1688	inv_recursive_ inv $_[0]
		1689	}
		1690
		1691	package cf;
		1692
		1693	=back
		1694
		1695	=head3 cf::object::player
		1696
		1697	=over 4
775		1698
776	=item $player_object->reply ($npc, $msg[, $flags])	1699	=item $player_object->reply ($npc, $msg[, $flags])
777		1700
778	Sends a message to the player, as if the npc C<$npc> replied. C<$npc>	1701	Sends a message to the player, as if the npc C<$npc> replied. C<$npc>
779	can be C<undef>. Does the right thing when the player is currently in a	1702	can be C<undef>. Does the right thing when the player is currently in a
…		…
781		1704
782	=cut	1705	=cut
783		1706
784	# rough implementation of a future "reply" method that works	1707	# rough implementation of a future "reply" method that works
785	# with dialog boxes.	1708	# with dialog boxes.
		1709	#TODO: the first argument must go, split into a $npc->reply_to ( method
786	sub cf::object::player::reply($$$;$) {	1710	sub cf::object::player::reply($$$;$) {
787	my ($self, $npc, $msg, $flags) = @_;	1711	my ($self, $npc, $msg, $flags) = @_;
788		1712
789	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;	1713	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;
790		1714
…		…
794	$msg = $npc->name . " says: $msg" if $npc;	1718	$msg = $npc->name . " says: $msg" if $npc;
795	$self->message ($msg, $flags);	1719	$self->message ($msg, $flags);
796	}	1720	}
797	}	1721	}
798		1722
799	=item $player->ext_reply ($msgid, $msgtype, %msg)
800
801	Sends an ext reply to the player.
802
803	=cut
804
805	sub cf::player::ext_reply($$$%) {
806	my ($self, $id, %msg) = @_;
807
808	$msg{msgid} = $id;
809
810	$self->send ("ext " . to_json \%msg);
811	}
812
813	=item $player_object->may ("access")	1723	=item $player_object->may ("access")
814		1724
815	Returns wether the given player is authorized to access resource "access"	1725	Returns wether the given player is authorized to access resource "access"
816	(e.g. "command_wizcast").	1726	(e.g. "command_wizcast").
817		1727
…		…
824	(ref $cf::CFG{"may_$access"}	1734	(ref $cf::CFG{"may_$access"}
825	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1735	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
826	: $cf::CFG{"may_$access"})	1736	: $cf::CFG{"may_$access"})
827	}	1737	}
828		1738
829	=cut	1739	=item $player_object->enter_link
830		1740
831	#############################################################################	1741	Freezes the player and moves him/her to a special map (C<{link}>).
		1742
		1743	The player should be reasonably safe there for short amounts of time. You
		1744	I<MUST> call C<leave_link> as soon as possible, though.
		1745
		1746	Will never block.
		1747
		1748	=item $player_object->leave_link ($map, $x, $y)
		1749
		1750	Moves the player out of the special C<{link}> map onto the specified
		1751	map. If the map is not valid (or omitted), the player will be moved back
		1752	to the location he/she was before the call to C<enter_link>, or, if that
		1753	fails, to the emergency map position.
		1754
		1755	Might block.
		1756
		1757	=cut
		1758
		1759	sub link_map {
		1760	unless ($LINK_MAP) {
		1761	$LINK_MAP = cf::map::find "{link}"
		1762	or cf::cleanup "FATAL: unable to provide {link} map, exiting.";
		1763	$LINK_MAP->load;
		1764	}
		1765
		1766	$LINK_MAP
		1767	}
		1768
		1769	sub cf::object::player::enter_link {
		1770	my ($self) = @_;
		1771
		1772	$self->deactivate_recursive;
		1773
		1774	return if UNIVERSAL::isa $self->map, "ext::map_link";
		1775
		1776	$self->{_link_pos} ||= [$self->map->{path}, $self->x, $self->y]
		1777	if $self->map;
		1778
		1779	$self->enter_map ($LINK_MAP || link_map, 10, 10);
		1780	}
		1781
		1782	sub cf::object::player::leave_link {
		1783	my ($self, $map, $x, $y) = @_;
		1784
		1785	my $link_pos = delete $self->{_link_pos};
		1786
		1787	unless ($map) {
		1788	# restore original map position
		1789	($map, $x, $y) = @{ $link_pos || [] };
		1790	$map = cf::map::find $map;
		1791
		1792	unless ($map) {
		1793	($map, $x, $y) = @$EMERGENCY_POSITION;
		1794	$map = cf::map::find $map
		1795	or die "FATAL: cannot load emergency map\n";
		1796	}
		1797	}
		1798
		1799	($x, $y) = (-1, -1)
		1800	unless (defined $x) && (defined $y);
		1801
		1802	# use -1 or undef as default coordinates, not 0, 0
		1803	($x, $y) = ($map->enter_x, $map->enter_y)
		1804	if $x <=0 && $y <= 0;
		1805
		1806	$map->load;
		1807	$map->load_diag;
		1808
		1809	return unless $self->contr->active;
		1810	$self->activate_recursive;
		1811
		1812	local $self->{_prev_pos} = $link_pos; # ugly hack for rent.ext
		1813	$self->enter_map ($map, $x, $y);
		1814	}
		1815
		1816	cf::player->attach (
		1817	on_logout => sub {
		1818	my ($pl) = @_;
		1819
		1820	# abort map switching before logout
		1821	if ($pl->ob->{_link_pos}) {
		1822	cf::sync_job {
		1823	$pl->ob->leave_link
		1824	};
		1825	}
		1826	},
		1827	on_login => sub {
		1828	my ($pl) = @_;
		1829
		1830	# try to abort aborted map switching on player login :)
		1831	# should happen only on crashes
		1832	if ($pl->ob->{_link_pos}) {
		1833	$pl->ob->enter_link;
		1834	(async {
		1835	$pl->ob->reply (undef,
		1836	"There was an internal problem at your last logout, "
		1837	. "the server will try to bring you to your intended destination in a second.",
		1838	cf::NDI_RED);
		1839	# we need this sleep as the login has a concurrent enter_exit running
		1840	# and this sleep increases chances of the player not ending up in scorn
		1841	Coro::Timer::sleep 1;
		1842	$pl->ob->leave_link;
		1843	})->prio (2);
		1844	}
		1845	},
		1846	);
		1847
		1848	=item $player_object->goto ($path, $x, $y)
		1849
		1850	=cut
		1851
		1852	sub cf::object::player::goto {
		1853	my ($self, $path, $x, $y) = @_;
		1854
		1855	$self->enter_link;
		1856
		1857	(async {
		1858	my $map = eval {
		1859	my $map = cf::map::find $path;
		1860	$map = $map->customise_for ($self) if $map;
		1861	$map
		1862	} or
		1863	$self->message ("The exit to '$path' is closed", cf::NDI_UNIQUE | cf::NDI_RED);
		1864
		1865	$self->leave_link ($map, $x, $y);
		1866	})->prio (1);
		1867	}
		1868
		1869	=item $player_object->enter_exit ($exit_object)
		1870
		1871	=cut
		1872
		1873	sub parse_random_map_params {
		1874	my ($spec) = @_;
		1875
		1876	my $rmp = { # defaults
		1877	xsize => (cf::rndm 15, 40),
		1878	ysize => (cf::rndm 15, 40),
		1879	symmetry => (cf::rndm 1, cf::SYMMETRY_XY),
		1880	#layout => string,
		1881	};
		1882
		1883	for (split /\n/, $spec) {
		1884	my ($k, $v) = split /\s+/, $_, 2;
		1885
		1886	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1887	}
		1888
		1889	$rmp
		1890	}
		1891
		1892	sub prepare_random_map {
		1893	my ($exit) = @_;
		1894
		1895	my $guard = cf::lock_acquire "exit_prepare:$exit";
		1896
		1897	# all this does is basically replace the /! path by
		1898	# a new random map path (?random/...) with a seed
		1899	# that depends on the exit object
		1900
		1901	my $rmp = parse_random_map_params $exit->msg;
		1902
		1903	if ($exit->map) {
		1904	$rmp->{region} = $exit->region->name;
		1905	$rmp->{origin_map} = $exit->map->path;
		1906	$rmp->{origin_x} = $exit->x;
		1907	$rmp->{origin_y} = $exit->y;
		1908	}
		1909
		1910	$rmp->{random_seed} ||= $exit->random_seed;
		1911
		1912	my $data = cf::to_json $rmp;
		1913	my $md5 = Digest::MD5::md5_hex $data;
		1914	my $meta = "$cf::RANDOM_MAPS/$md5.meta";
		1915
		1916	if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) {
		1917	aio_write $fh, 0, (length $data), $data, 0;
		1918	undef $fh;
		1919	aio_rename "$meta~", $meta;
		1920
		1921	$exit->slaying ("?random/$md5");
		1922	$exit->msg (undef);
		1923	}
		1924	}
		1925
		1926	sub cf::object::player::enter_exit {
		1927	my ($self, $exit) = @_;
		1928
		1929	return unless $self->type == cf::PLAYER;
		1930
		1931	if ($exit->slaying eq "/!") {
		1932	#TODO: this should de-fi-ni-te-ly not be a sync-job
		1933	cf::sync_job { prepare_random_map $exit };
		1934	}
		1935
		1936	my $slaying = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
		1937	my $hp = $exit->stats->hp;
		1938	my $sp = $exit->stats->sp;
		1939
		1940	$self->enter_link;
		1941
		1942	(async {
		1943	$self->deactivate_recursive; # just to be sure
		1944	unless (eval {
		1945	$self->goto ($slaying, $hp, $sp);
		1946
		1947	1;
		1948	}) {
		1949	$self->message ("Something went wrong deep within the crossfire server. "
		1950	. "I'll try to bring you back to the map you were before. "
		1951	. "Please report this to the dungeon master!",
		1952	cf::NDI_UNIQUE | cf::NDI_RED);
		1953
		1954	warn "ERROR in enter_exit: $@";
		1955	$self->leave_link;
		1956	}
		1957	})->prio (1);
		1958	}
		1959
		1960	=head3 cf::client
		1961
		1962	=over 4
		1963
		1964	=item $client->send_drawinfo ($text, $flags)
		1965
		1966	Sends a drawinfo packet to the client. Circumvents output buffering so
		1967	should not be used under normal circumstances.
		1968
		1969	=cut
		1970
		1971	sub cf::client::send_drawinfo {
		1972	my ($self, $text, $flags) = @_;
		1973
		1974	utf8::encode $text;
		1975	$self->send_packet (sprintf "drawinfo %d %s", $flags, $text);
		1976	}
		1977
		1978
		1979	=item $success = $client->query ($flags, "text", \&cb)
		1980
		1981	Queues a query to the client, calling the given callback with
		1982	the reply text on a reply. flags can be C<cf::CS_QUERY_YESNO>,
		1983	C<cf::CS_QUERY_SINGLECHAR> or C<cf::CS_QUERY_HIDEINPUT> or C<0>.
		1984
		1985	Queries can fail, so check the return code. Or don't, as queries will become
		1986	reliable at some point in the future.
		1987
		1988	=cut
		1989
		1990	sub cf::client::query {
		1991	my ($self, $flags, $text, $cb) = @_;
		1992
		1993	return unless $self->state == ST_PLAYING
		1994	|| $self->state == ST_SETUP
		1995	|| $self->state == ST_CUSTOM;
		1996
		1997	$self->state (ST_CUSTOM);
		1998
		1999	utf8::encode $text;
		2000	push @{ $self->{query_queue} }, [(sprintf "query %d %s", $flags, $text), $cb];
		2001
		2002	$self->send_packet ($self->{query_queue}[0][0])
		2003	if @{ $self->{query_queue} } == 1;
		2004	}
		2005
		2006	cf::client->attach (
		2007	on_reply => sub {
		2008	my ($ns, $msg) = @_;
		2009
		2010	# this weird shuffling is so that direct followup queries
		2011	# get handled first
		2012	my $queue = delete $ns->{query_queue}
		2013	or return; # be conservative, not sure how that can happen, but we saw a crash here
		2014
		2015	(shift @$queue)->[1]->($msg);
		2016	return unless $ns->valid; # temporary(?) workaround for callback destroying socket
		2017
		2018	push @{ $ns->{query_queue} }, @$queue;
		2019
		2020	if (@{ $ns->{query_queue} } == @$queue) {
		2021	if (@$queue) {
		2022	$ns->send_packet ($ns->{query_queue}[0][0]);
		2023	} else {
		2024	$ns->state (ST_PLAYING) if $ns->state == ST_CUSTOM;
		2025	}
		2026	}
		2027	},
		2028	);
		2029
		2030	=item $client->async (\&cb)
		2031
		2032	Create a new coroutine, running the specified callback. The coroutine will
		2033	be automatically cancelled when the client gets destroyed (e.g. on logout,
		2034	or loss of connection).
		2035
		2036	=cut
		2037
		2038	sub cf::client::async {
		2039	my ($self, $cb) = @_;
		2040
		2041	my $coro = &Coro::async ($cb);
		2042
		2043	$coro->on_destroy (sub {
		2044	delete $self->{_coro}{$coro+0};
		2045	});
		2046
		2047	$self->{_coro}{$coro+0} = $coro;
		2048
		2049	$coro
		2050	}
		2051
		2052	cf::client->attach (
		2053	on_destroy => sub {
		2054	my ($ns) = @_;
		2055
		2056	$_->cancel for values %{ (delete $ns->{_coro}) || {} };
		2057	},
		2058	);
		2059
		2060	=back
		2061
832		2062
833	=head2 SAFE SCRIPTING	2063	=head2 SAFE SCRIPTING
834		2064
835	Functions that provide a safe environment to compile and execute	2065	Functions that provide a safe environment to compile and execute
836	snippets of perl code without them endangering the safety of the server	2066	snippets of perl code without them endangering the safety of the server
…		…
952	The parameter C<$family> should best start with the name of the extension	2182	The parameter C<$family> should best start with the name of the extension
953	using it, it should be unique.	2183	using it, it should be unique.
954		2184
955	=over 4	2185	=over 4
956		2186
957	=item $hashref = cf::db_get $family
958
959	Return a hashref for use by the extension C<$family>, which can be
960	modified. After modifications, you have to call C<cf::db_dirty> or
961	C<cf::db_sync>.
962
963	=item $value = cf::db_get $family => $key	2187	=item $value = cf::db_get $family => $key
964		2188
965	Returns a single value from the database	2189	Returns a single value from the database.
966
967	=item cf::db_put $family => $hashref
968
969	Stores the given family hashref into the database. Updates are delayed, if
970	you want the data to be synced to disk immediately, use C<cf::db_sync>.
971		2190
972	=item cf::db_put $family => $key => $value	2191	=item cf::db_put $family => $key => $value
973		2192
974	Stores the given C<$value> in the family hash. Updates are delayed, if you	2193	Stores the given C<$value> in the family.
975	want the data to be synced to disk immediately, use C<cf::db_sync>.
976
977	=item cf::db_dirty
978
979	Marks the database as dirty, to be updated at a later time.
980
981	=item cf::db_sync
982
983	Immediately write the database to disk I<if it is dirty>.
984		2194
985	=cut	2195	=cut
986		2196
987	our $DB;	2197	our $DB;
988		2198
989	{	2199	sub db_init {
		2200	unless ($DB) {
		2201	$DB = BDB::db_create $DB_ENV;
		2202
		2203	cf::sync_job {
		2204	eval {
		2205	$DB->set_flags (BDB::CHKSUM);
		2206
		2207	BDB::db_open $DB, undef, "db", undef, BDB::BTREE,
		2208	BDB::CREATE | BDB::AUTO_COMMIT, 0666;
		2209	cf::cleanup "db_open(db): $!" if $!;
		2210	};
		2211	cf::cleanup "db_open(db): $@" if $@;
		2212	};
		2213
990	my $path = cf::localdir . "/database.pst";	2214	my $path = cf::localdir . "/database.pst";
		2215	if (stat $path) {
		2216	cf::sync_job {
		2217	my $pst = Storable::retrieve $path;
991		2218
992	sub db_load() {	2219	cf::db_put (board => data => $pst->{board});
993	warn "loading database $path\n";#d# remove later	2220	cf::db_put (guildrules => data => $pst->{guildrules});
994	$DB = stat $path ? Storable::retrieve $path : { };	2221	cf::db_put (rent => balance => $pst->{rent}{balance});
995	}	2222	BDB::db_env_txn_checkpoint $DB_ENV;
996		2223
997	my $pid;	2224	unlink $path;
998
999	sub db_save() {
1000	warn "saving database $path\n";#d# remove later
1001	waitpid $pid, 0 if $pid;
1002	if (0 == ($pid = fork)) {
1003	$DB->{_meta}{version} = 1;
1004	Storable::nstore $DB, "$path~";
1005	rename "$path~", $path;
1006	cf::_exit 0 if defined $pid;
1007	}	2225	};
1008	}
1009
1010	my $dirty;
1011
1012	sub db_sync() {
1013	db_save if $dirty;
1014	undef $dirty;
1015	}
1016
1017	my $idle = Event->idle (min => $TICK * 2.8, max => 10, repeat => 0, data => WF_AUTOCANCEL, cb => sub {
1018	db_sync;
1019	});
1020
1021	sub db_dirty() {
1022	$dirty = 1;
1023	$idle->start;
1024	}
1025
1026	sub db_get($;$) {
1027	@_ >= 2
1028	? $DB->{$_[0]}{$_[1]}
1029	: ($DB->{$_[0]} ||= { })
1030	}
1031
1032	sub db_put($$;$) {
1033	if (@_ >= 3) {
1034	$DB->{$_[0]}{$_[1]} = $_[2];
1035	} else {
1036	$DB->{$_[0]} = $_[1];
1037	}
1038	db_dirty;
1039	}
1040
1041	cf::global->attach (
1042	prio => 10000,
1043	on_cleanup => sub {
1044	db_sync;
1045	},	2226	}
1046	);	2227	}
		2228	}
		2229
		2230	sub db_get($$) {
		2231	my $key = "$_[0]/$_[1]";
		2232
		2233	cf::sync_job {
		2234	BDB::db_get $DB, undef, $key, my $data;
		2235
		2236	$! ? ()
		2237	: Compress::LZF::sthaw $data
		2238	}
		2239	}
		2240
		2241	sub db_put($$$) {
		2242	BDB::dbreq_pri 4;
		2243	BDB::db_put $DB, undef, "$_[0]/$_[1]", Compress::LZF::sfreeze_cr $_[2], 0, sub { };
1047	}	2244	}
1048		2245
1049	#############################################################################	2246	#############################################################################
1050	# the server's main()	2247	# the server's init and main functions
		2248
		2249	sub init_resources {
		2250	load_resource_file sprintf "%s/%s/regions", cf::datadir, cf::mapdir
		2251	or die "unable to load regions file\n";#d#
		2252	}
1051		2253
1052	sub cfg_load {	2254	sub cfg_load {
1053	open my $fh, "<:utf8", cf::confdir . "/config"	2255	open my $fh, "<:utf8", cf::confdir . "/config"
1054	or return;	2256	or return;
1055		2257
1056	local $/;	2258	local $/;
1057	*CFG = YAML::Syck::Load <$fh>;	2259	*CFG = YAML::Syck::Load <$fh>;
		2260
		2261	$EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
		2262
		2263	$cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
		2264	$cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
		2265
		2266	if (exists $CFG{mlockall}) {
		2267	eval {
		2268	$CFG{mlockall} ? eval "mlockall()" : eval "munlockall()"
		2269	and die "WARNING: m(un)lockall failed: $!\n";
		2270	};
		2271	warn $@ if $@;
		2272	}
		2273	}
		2274
		2275	sub init {
		2276	init_resources;
1058	}	2277	}
1059		2278
1060	sub main {	2279	sub main {
		2280	# we must not ever block the main coroutine
		2281	local $Coro::idle = sub {
		2282	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
		2283	(async {
		2284	Event::one_event;
		2285	})->prio (Coro::PRIO_MAX);
		2286	};
		2287
1061	cfg_load;	2288	cfg_load;
1062	db_load;	2289	db_init;
1063	load_extensions;	2290	load_extensions;
		2291
		2292	$TICK_WATCHER->start;
1064	Event::loop;	2293	Event::loop;
1065	}	2294	}
1066		2295
1067	#############################################################################	2296	#############################################################################
1068	# initialisation	2297	# initialisation and cleanup
1069		2298
		2299	# install some emergency cleanup handlers
		2300	BEGIN {
		2301	for my $signal (qw(INT HUP TERM)) {
		2302	Event->signal (
		2303	reentrant => 0,
		2304	data => WF_AUTOCANCEL,
		2305	signal => $signal,
		2306	prio => 0,
		2307	cb => sub {
		2308	cf::cleanup "SIG$signal";
		2309	},
		2310	);
		2311	}
		2312	}
		2313
		2314	sub emergency_save() {
		2315	my $freeze_guard = cf::freeze_mainloop;
		2316
		2317	warn "enter emergency perl save\n";
		2318
		2319	cf::sync_job {
		2320	# use a peculiar iteration method to avoid tripping on perl
		2321	# refcount bugs in for. also avoids problems with players
		2322	# and maps saved/destroyed asynchronously.
		2323	warn "begin emergency player save\n";
		2324	for my $login (keys %cf::PLAYER) {
		2325	my $pl = $cf::PLAYER{$login} or next;
		2326	$pl->valid or next;
		2327	$pl->save;
		2328	}
		2329	warn "end emergency player save\n";
		2330
		2331	warn "begin emergency map save\n";
		2332	for my $path (keys %cf::MAP) {
		2333	my $map = $cf::MAP{$path} or next;
		2334	$map->valid or next;
		2335	$map->save;
		2336	}
		2337	warn "end emergency map save\n";
		2338
		2339	warn "begin emergency database checkpoint\n";
		2340	BDB::db_env_txn_checkpoint $DB_ENV;
		2341	warn "end emergency database checkpoint\n";
		2342	};
		2343
		2344	warn "leave emergency perl save\n";
		2345	}
		2346
		2347	sub post_cleanup {
		2348	my ($make_core) = @_;
		2349
		2350	warn Carp::longmess "post_cleanup backtrace"
		2351	if $make_core;
		2352	}
		2353
1070	sub _perl_reload(&) {	2354	sub reload() {
1071	my ($msg) = @_;	2355	# can/must only be called in main
		2356	if ($Coro::current != $Coro::main) {
		2357	warn "can only reload from main coroutine";
		2358	return;
		2359	}
1072		2360
1073	$msg->("reloading...");	2361	warn "reloading...";
1074		2362
1075	eval {	2363	warn "entering sync_job";
1076	# cancel all watchers	2364
		2365	cf::sync_job {
		2366	cf::write_runtime; # external watchdog should not bark
		2367	cf::emergency_save;
		2368	cf::write_runtime; # external watchdog should not bark
		2369
		2370	warn "syncing database to disk";
		2371	BDB::db_env_txn_checkpoint $DB_ENV;
		2372
		2373	# if anything goes wrong in here, we should simply crash as we already saved
		2374
		2375	warn "cancelling all WF_AUTOCANCEL watchers";
1077	for (Event::all_watchers) {	2376	for (Event::all_watchers) {
1078	$_->cancel if $_->data & WF_AUTOCANCEL;	2377	$_->cancel if $_->data & WF_AUTOCANCEL;
1079	}	2378	}
1080		2379
1081	# unload all extensions	2380	warn "flushing outstanding aio requests";
1082	for (@exts) {	2381	for (;;) {
1083	$msg->("unloading <$_>");	2382	BDB::flush;
1084	unload_extension $_;	2383	IO::AIO::flush;
		2384	Coro::cede;
		2385	last unless IO::AIO::nreqs || BDB::nreqs;
		2386	warn "iterate...";
		2387	}
		2388
		2389	warn "cancelling all extension coros";
		2390	$_->cancel for values %EXT_CORO;
		2391	%EXT_CORO = ();
		2392
		2393	warn "removing commands";
		2394	%COMMAND = ();
		2395
		2396	warn "removing ext commands";
		2397	%EXTCMD = ();
		2398
		2399	warn "unloading/nuking all extensions";
		2400	for my $pkg (@EXTS) {
		2401	warn "... unloading $pkg";
		2402
		2403	if (my $cb = $pkg->can ("unload")) {
		2404	eval {
		2405	$cb->($pkg);
		2406	1
		2407	} or warn "$pkg unloaded, but with errors: $@";
1085	}	2408	}
1086		2409
		2410	warn "... nuking $pkg";
		2411	Symbol::delete_package $pkg;
		2412	}
		2413
1087	# unload all modules loaded from $LIBDIR	2414	warn "unloading all perl modules loaded from $LIBDIR";
1088	while (my ($k, $v) = each %INC) {	2415	while (my ($k, $v) = each %INC) {
1089	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;	2416	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
1090		2417
1091	$msg->("removing <$k>");	2418	warn "... unloading $k";
1092	delete $INC{$k};	2419	delete $INC{$k};
1093		2420
1094	$k =~ s/\.pm$//;	2421	$k =~ s/\.pm$//;
1095	$k =~ s/\//::/g;	2422	$k =~ s/\//::/g;
1096		2423
…		…
1099	}	2426	}
1100		2427
1101	Symbol::delete_package $k;	2428	Symbol::delete_package $k;
1102	}	2429	}
1103		2430
1104	# sync database to disk
1105	cf::db_sync;
1106
1107	# get rid of safe::, as good as possible	2431	warn "getting rid of safe::, as good as possible";
1108	Symbol::delete_package "safe::$_"	2432	Symbol::delete_package "safe::$_"
1109	for qw(cf::object cf::object::player cf::player cf::map cf::party cf::region);	2433	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
1110		2434
1111	# remove register_script_function callbacks
1112	# TODO
1113
1114	# unload cf.pm "a bit"	2435	warn "unloading cf.pm \"a bit\"";
1115	delete $INC{"cf.pm"};	2436	delete $INC{"cf.pm"};
1116		2437
1117	# don't, removes xs symbols, too,	2438	# don't, removes xs symbols, too,
1118	# and global variables created in xs	2439	# and global variables created in xs
1119	#Symbol::delete_package __PACKAGE__;	2440	#Symbol::delete_package __PACKAGE__;
1120		2441
1121	# reload cf.pm	2442	warn "unload completed, starting to reload now";
		2443
1122	$msg->("reloading cf.pm");	2444	warn "reloading cf.pm";
1123	require cf;	2445	require cf;
		2446	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
1124		2447
1125	# load config and database again	2448	warn "loading config and database again";
1126	cf::cfg_load;	2449	cf::cfg_load;
1127	cf::db_load;
1128		2450
1129	# load extensions	2451	warn "loading extensions";
1130	$msg->("load extensions");
1131	cf::load_extensions;	2452	cf::load_extensions;
1132		2453
1133	# reattach attachments to objects	2454	warn "reattaching attachments to objects/players";
1134	$msg->("reattach");
1135	_global_reattach;	2455	_global_reattach;
		2456	warn "reattaching attachments to maps";
		2457	reattach $_ for values %MAP;
		2458
		2459	warn "loading reloadable resources";
		2460	init_resources;
		2461
		2462	warn "leaving sync_job";
		2463
		2464	1
		2465	} or do {
		2466	warn $@;
		2467	warn "error while reloading, exiting.";
		2468	exit 1;
1136	};	2469	};
1137	$msg->($@) if $@;
1138		2470
1139	$msg->("reloaded");	2471	warn "reloaded";
1140	};	2472	};
1141		2473
1142	sub perl_reload() {	2474	our $RELOAD_WATCHER; # used only during reload
1143	_perl_reload {
1144	warn $_[0];
1145	print "$_[0]\n";
1146	};
1147	}
1148		2475
1149	register "<global>", __PACKAGE__;
1150
1151	register_command "perl-reload" => sub {	2476	register_command "reload" => sub {
1152	my ($who, $arg) = @_;	2477	my ($who, $arg) = @_;
1153		2478
1154	if ($who->flag (FLAG_WIZ)) {	2479	if ($who->flag (FLAG_WIZ)) {
1155	_perl_reload {	2480	$who->message ("reloading server.");
1156	warn $_[0];	2481
1157	$who->message ($_[0]);	2482	# doing reload synchronously and two reloads happen back-to-back,
		2483	# coro crashes during coro_state_free->destroy here.
		2484
		2485	$RELOAD_WATCHER ||= Event->timer (
		2486	reentrant => 0,
		2487	after => 0,
		2488	data => WF_AUTOCANCEL,
		2489	cb => sub {
		2490	reload;
		2491	undef $RELOAD_WATCHER;
		2492	},
1158	};	2493	);
1159	}	2494	}
1160	};	2495	};
1161		2496
1162	unshift @INC, $LIBDIR;	2497	unshift @INC, $LIBDIR;
1163		2498
		2499	my $bug_warning = 0;
		2500
1164	$TICK_WATCHER = Event->timer (	2501	$TICK_WATCHER = Event->timer (
		2502	reentrant => 0,
		2503	parked => 1,
1165	prio => 0,	2504	prio => 0,
1166	at => $NEXT_TICK || 1,	2505	at => $NEXT_TICK || $TICK,
1167	data => WF_AUTOCANCEL,	2506	data => WF_AUTOCANCEL,
1168	cb => sub {	2507	cb => sub {
		2508	if ($Coro::current != $Coro::main) {
		2509	Carp::cluck "major BUG: server tick called outside of main coro, skipping it"
		2510	unless ++$bug_warning > 10;
		2511	return;
		2512	}
		2513
		2514	$NOW = Event::time;
		2515
1169	cf::server_tick; # one server iteration	2516	cf::server_tick; # one server iteration
1170		2517	$RUNTIME += $TICK;
1171	my $NOW = Event::time;
1172	$NEXT_TICK += $TICK;	2518	$NEXT_TICK += $TICK;
1173		2519
		2520	if ($NOW >= $NEXT_RUNTIME_WRITE) {
		2521	$NEXT_RUNTIME_WRITE = $NOW + 10;
		2522	Coro::async_pool {
		2523	write_runtime
		2524	or warn "ERROR: unable to write runtime file: $!";
		2525	};
		2526	}
		2527
		2528	$WAIT_FOR_TICK->broadcast;
		2529	$WAIT_FOR_TICK_ONE->send if $WAIT_FOR_TICK_ONE->awaited;
		2530
		2531	# my $AFTER = Event::time;
		2532	# warn $AFTER - $NOW;#d#
		2533
1174	# if we are delayed by four ticks or more, skip them all	2534	# if we are delayed by four ticks or more, skip them all
1175	$NEXT_TICK = $NOW if $NOW >= $NEXT_TICK + $TICK * 4;	2535	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
1176		2536
1177	$TICK_WATCHER->at ($NEXT_TICK);	2537	$TICK_WATCHER->at ($NEXT_TICK);
1178	$TICK_WATCHER->start;	2538	$TICK_WATCHER->start;
1179	},	2539	},
1180	);	2540	);
1181		2541
		2542	{
		2543	BDB::max_poll_time $TICK * 0.1;
		2544	$BDB_POLL_WATCHER = Event->io (
		2545	reentrant => 0,
		2546	fd => BDB::poll_fileno,
		2547	poll => 'r',
		2548	prio => 0,
		2549	data => WF_AUTOCANCEL,
		2550	cb => \&BDB::poll_cb,
		2551	);
		2552	BDB::min_parallel 8;
		2553
		2554	BDB::set_sync_prepare {
		2555	my $status;
		2556	my $current = $Coro::current;
		2557	(
		2558	sub {
		2559	$status = $!;
		2560	$current->ready; undef $current;
		2561	},
		2562	sub {
		2563	Coro::schedule while defined $current;
		2564	$! = $status;
		2565	},
		2566	)
		2567	};
		2568
		2569	unless ($DB_ENV) {
		2570	$DB_ENV = BDB::db_env_create;
		2571
		2572	cf::sync_job {
		2573	eval {
		2574	BDB::db_env_open
		2575	$DB_ENV,
		2576	$BDB_ENV_DIR,
		2577	BDB::INIT_LOCK | BDB::INIT_LOG | BDB::INIT_MPOOL | BDB::INIT_TXN
		2578	| BDB::RECOVER | BDB::REGISTER | BDB::USE_ENVIRON | BDB::CREATE,
		2579	0666;
		2580
		2581	cf::cleanup "db_env_open($BDB_ENV_DIR): $!" if $!;
		2582
		2583	$DB_ENV->set_flags (BDB::AUTO_COMMIT | BDB::REGION_INIT | BDB::TXN_NOSYNC, 1);
		2584	$DB_ENV->set_lk_detect;
		2585	};
		2586
		2587	cf::cleanup "db_env_open(db): $@" if $@;
		2588	};
		2589	}
		2590	}
		2591
		2592	{
		2593	IO::AIO::min_parallel 8;
		2594
		2595	undef $Coro::AIO::WATCHER;
1182	IO::AIO::max_poll_time $TICK * 0.2;	2596	IO::AIO::max_poll_time $TICK * 0.1;
1183		2597	$AIO_POLL_WATCHER = Event->io (
1184	Event->io (fd => IO::AIO::poll_fileno,	2598	reentrant => 0,
1185	poll => 'r',
1186	prio => 5,
1187	data => WF_AUTOCANCEL,	2599	data => WF_AUTOCANCEL,
		2600	fd => IO::AIO::poll_fileno,
		2601	poll => 'r',
		2602	prio => 6,
1188	cb => \&IO::AIO::poll_cb);	2603	cb => \&IO::AIO::poll_cb,
		2604	);
		2605	}
		2606
		2607	END { cf::emergency_save }
1189		2608
1190	1	2609	1
1191		2610

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines