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.32 by root, Tue Aug 15 18:07:25 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;
		24	use IO::AIO 2.32 ();
		25	use YAML::Syck ();
10	use Time::HiRes;	26	use Time::HiRes;
11	use Event;	27	use Compress::LZF;
		28
		29	Compress::LZF::sfreeze_cr { }; # prime Compress::LZF so it does not use require later
		30
12	$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
13		32
14	use strict;	33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
15		34
16	our %COMMAND;	35	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
		36	$YAML::Syck::ImplicitUnicode = 1;
		37
		38	$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
		39
		40	our %COMMAND = ();
		41	our %COMMAND_TIME = ();
		42
		43	our @EXTS = (); # list of extension package names
		44	our %EXTCMD = ();
		45	our %EXT_CORO = (); # coroutines bound to extensions
		46	our %EXT_MAP = (); # pluggable maps
		47
17	our @EVENT;	48	our @EVENT;
18	our %PROP_TYPE;	49	our $LIBDIR = datadir . "/ext";
19	our %PROP_IDX;	50
20	our $LIBDIR = maps_directory "perl";	51	our $TICK = MAX_TIME * 1e-6;
		52	our $TICK_WATCHER;
		53	our $AIO_POLL_WATCHER;
		54	our $NEXT_RUNTIME_WRITE; # when should the runtime file be written
		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;
		61
		62	our %CFG;
		63
		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;
		99
		100	#############################################################################
		101
		102	=head2 GLOBAL VARIABLES
		103
		104	=over 4
		105
		106	=item $cf::UPTIME
		107
		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.
		114
		115	=item $cf::LIBDIR
		116
		117	The perl library directory, where extensions and cf-specific modules can
		118	be found. It will be added to C<@INC> automatically.
		119
		120	=item $cf::NOW
		121
		122	The time of the last (current) server tick.
		123
		124	=item $cf::TICK
		125
		126	The interval between server ticks, in seconds.
		127
		128	=item %cf::CFG
		129
		130	Configuration for the server, loaded from C</etc/crossfire/config>, or
		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.
		139
		140	=back
		141
		142	=cut
21		143
22	BEGIN {	144	BEGIN {
23	@EVENT = map lc, @EVENT;
24
25	*CORE::GLOBAL::warn = sub {	145	*CORE::GLOBAL::warn = sub {
26	my $msg = join "", @_;	146	my $msg = join "", @_;
		147	utf8::encode $msg;
		148
27	$msg .= "\n"	149	$msg .= "\n"
28	unless $msg =~ /\n$/;	150	unless $msg =~ /\n$/;
29		151
30	print STDERR "cfperl: $msg";
31	LOG llevError, "cfperl: $msg";	152	LOG llevError, $msg;
32	};	153	};
33	}	154	}
34		155
35	my %ignore_set = (MAP_PROP_PATH => 1); # I hate the plug-in api. Deeply!	156	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';
		157	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';
		158	@safe::cf::player::ISA = @cf::player::ISA = 'cf::attachable';
		159	@safe::cf::client::ISA = @cf::client::ISA = 'cf::attachable';
		160	@safe::cf::map::ISA = @cf::map::ISA = 'cf::attachable';
		161	@safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';
36		162
37	# generate property mutators	163	# we bless all objects into (empty) derived classes to force a method lookup
38	sub prop_gen {	164	# within the Safe compartment.
39	my ($prefix, $class) = @_;	165	for my $pkg (qw(
40		166	cf::global cf::attachable
		167	cf::object cf::object::player
		168	cf::client cf::player
		169	cf::arch cf::living
		170	cf::map cf::party cf::region
		171	)) {
41	no strict 'refs';	172	no strict 'refs';
42
43	for my $prop (keys %PROP_TYPE) {
44	$prop =~ /^\Q$prefix\E_(.*$)/ or next;
45	my $sub = lc $1;
46
47	my $type = $PROP_TYPE{$prop};
48	my $idx = $PROP_IDX {$prop};
49
50	*{"$class\::get_$sub"} = *{"$class\::$sub"} = sub {
51	$_[0]->get_property ($type, $idx)
52	};
53
54	*{"$class\::set_$sub"} = sub {
55	$_[0]->set_property ($type, $idx, $_[1]);
56	} unless $ignore_set{$prop};
57	}
58	}
59
60	# auto-generate most of the API
61
62	prop_gen OBJECT_PROP => "cf::object";
63	# CFAPI_OBJECT_ANIMATION?
64	prop_gen PLAYER_PROP => "cf::object::player";
65
66	prop_gen MAP_PROP => "cf::map";
67	prop_gen ARCH_PROP => "cf::arch";
68
69	# guessed hierarchies
70
71	@ext::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';
72	@ext::cf::object::map::ISA = @cf::object::map::ISA = 'cf::object';
73
74	# we bless all objects into derived classes to force a method lookup
75	# within the Safe compartment.
76	for my $pkg (qw(cf::object cf::object::map cf::object::player cf::player cf::map cf::party cf::region cf::arch)) {
77	no strict 'refs';
78	@{"ext::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;	173	@{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;
79	}	174	}
80		175
81	$Event::DIED = sub {	176	$Event::DIED = sub {
82	warn "error in event callback: @_";	177	warn "error in event callback: @_";
83	};	178	};
84		179
85	my %ext_pkg;	180	=head2 UTILITY FUNCTIONS
86	my @exts;
87	my @hook;
88	my %command;
89	my %extcmd;
90		181
91	sub inject_event {	182	=over 4
92	my $extension = shift;	183
		184	=item dumpval $ref
		185
		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	}
		206
		207	use JSON::Syck (); # TODO# replace by JSON::PC once working
		208
		209	=item $ref = cf::from_json $json
		210
		211	Converts a JSON string into the corresponding perl data structure.
		212
		213	=cut
		214
		215	sub from_json($) {
		216	$JSON::Syck::ImplicitUnicode = 1; # work around JSON::Syck bugs
		217	JSON::Syck::Load $_[0]
		218	}
		219
		220	=item $json = cf::to_json $ref
		221
		222	Converts a perl data structure into its JSON representation.
		223
		224	=cut
		225
		226	sub to_json($) {
		227	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
		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(&) {
93	my $event_code = shift;	346	my $cb = shift;
94		347
95	my $cb = $hook[$event_code]{$extension}	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
96	or return;	364	or return;
97		365
98	&$cb	366	my $value = $cf::RUNTIME + 90 + 10;
99	}	367	# 10 is the runtime save interval, for a monotonic clock
		368	# 60 allows for the watchdog to kill the server.
100		369
101	sub inject_global_event {	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
		384	}
		385
		386	=back
		387
		388	=cut
		389
		390	#############################################################################
		391
		392	=head2 ATTACHABLE OBJECTS
		393
		394	Many objects in crossfire are so-called attachable objects. That means you can
		395	attach callbacks/event handlers (a collection of which is called an "attachment")
		396	to it. All such attachable objects support the following methods.
		397
		398	In the following description, CLASS can be any of C<global>, C<object>
		399	C<player>, C<client> or C<map> (i.e. the attachable objects in
		400	crossfire+).
		401
		402	=over 4
		403
		404	=item $attachable->attach ($attachment, key => $value...)
		405
		406	=item $attachable->detach ($attachment)
		407
		408	Attach/detach a pre-registered attachment to a specific object and give it
		409	the specified key/value pairs as arguments.
		410
		411	Example, attach a minesweeper attachment to the given object, making it a
		412	10x10 minesweeper game:
		413
		414	$obj->attach (minesweeper => width => 10, height => 10);
		415
		416	=item $bool = $attachable->attached ($name)
		417
		418	Checks wether the named attachment is currently attached to the object.
		419
		420	=item cf::CLASS->attach ...
		421
		422	=item cf::CLASS->detach ...
		423
		424	Define an anonymous attachment and attach it to all objects of the given
		425	CLASS. See the next function for an explanation of its arguments.
		426
		427	You can attach to global events by using the C<cf::global> class.
		428
		429	Example, log all player logins:
		430
		431	cf::player->attach (
		432	on_login => sub {
		433	my ($pl) = @_;
		434	...
		435	},
		436	);
		437
		438	Example, attach to the jeweler skill:
		439
		440	cf::object->attach (
		441	type => cf::SKILL,
		442	subtype => cf::SK_JEWELER,
		443	on_use_skill => sub {
		444	my ($sk, $ob, $part, $dir, $msg) = @_;
		445	...
		446	},
		447	);
		448
		449	=item cf::CLASS::attachment $name, ...
		450
		451	Register an attachment by C<$name> through which attachable objects of the
		452	given CLASS can refer to this attachment.
		453
		454	Some classes such as crossfire maps and objects can specify attachments
		455	that are attached at load/instantiate time, thus the need for a name.
		456
		457	These calls expect any number of the following handler/hook descriptions:
		458
		459	=over 4
		460
		461	=item prio => $number
		462
		463	Set the priority for all following handlers/hooks (unless overwritten
		464	by another C<prio> setting). Lower priority handlers get executed
		465	earlier. The default priority is C<0>, and many built-in handlers are
		466	registered at priority C<-1000>, so lower priorities should not be used
		467	unless you know what you are doing.
		468
		469	=item type => $type
		470
		471	(Only for C<< cf::object->attach >> calls), limits the attachment to the
		472	given type of objects only (the additional parameter C<subtype> can be
		473	used to further limit to the given subtype).
		474
		475	=item on_I<event> => \&cb
		476
		477	Call the given code reference whenever the named event happens (event is
		478	something like C<instantiate>, C<apply>, C<use_skill> and so on, and which
		479	handlers are recognised generally depends on the type of object these
		480	handlers attach to).
		481
		482	See F<include/eventinc.h> for the full list of events supported, and their
		483	class.
		484
		485	=item package => package::
		486
		487	Look for sub functions of the name C<< on_I<event> >> in the given
		488	package and register them. Only handlers for eevents supported by the
		489	object/class are recognised.
		490
		491	=back
		492
		493	Example, define an attachment called "sockpuppet" that calls the given
		494	event handler when a monster attacks:
		495
		496	cf::object::attachment sockpuppet =>
		497	on_skill_attack => sub {
		498	my ($self, $victim) = @_;
		499	...
		500	}
		501	}
		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
		511	=cut
		512
		513	# the following variables are defined in .xs and must not be re-created
		514	our @CB_GLOBAL = (); # registry for all global events
		515	our @CB_ATTACHABLE = (); # registry for all attachables
		516	our @CB_OBJECT = (); # all objects (should not be used except in emergency)
		517	our @CB_PLAYER = ();
		518	our @CB_CLIENT = ();
		519	our @CB_TYPE = (); # registry for type (cf-object class) based events
		520	our @CB_MAP = ();
		521
		522	my %attachment;
		523
		524	sub cf::attachable::thawer_merge {
		525	# simply override everything except _meta
		526	local $_[0]{_meta};
		527	%{$_[0]} = %{$_[1]};
		528	}
		529
		530	sub _attach_cb($$$$) {
		531	my ($registry, $event, $prio, $cb) = @_;
		532
		533	use sort 'stable';
		534
		535	$cb = [$prio, $cb];
		536
		537	@{$registry->[$event]} = sort
		538	{ $a->[0] cmp $b->[0] }
		539	@{$registry->[$event] || []}, $cb;
		540	}
		541
		542	# hack
		543	my %attachable_klass = map +($_ => 1), KLASS_OBJECT, KLASS_CLIENT, KLASS_PLAYER, KLASS_MAP;
		544
		545	# attach handles attaching event callbacks
		546	# the only thing the caller has to do is pass the correct
		547	# registry (== where the callback attaches to).
		548	sub _attach {
		549	my ($registry, $klass, @arg) = @_;
		550
		551	my $object_type;
		552	my $prio = 0;
		553	my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT;
		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
		560	while (@arg) {
		561	my $type = shift @arg;
		562
		563	if ($type eq "prio") {
		564	$prio = shift @arg;
		565
		566	} elsif ($type eq "type") {
		567	$object_type = shift @arg;
		568	$registry = $CB_TYPE[$object_type] ||= [];
		569
		570	} elsif ($type eq "subtype") {
		571	defined $object_type or Carp::croak "subtype specified without type";
		572	my $object_subtype = shift @arg;
		573	$registry = $CB_TYPE[$object_type + $object_subtype * NUM_SUBTYPES] ||= [];
		574
		575	} elsif ($type eq "package") {
		576	my $pkg = shift @arg;
		577
		578	while (my ($name, $id) = each %cb_id) {
		579	if (my $cb = $pkg->can ($name)) {
		580	_attach_cb $registry, $id, $prio, $cb;
		581	}
		582	}
		583
		584	} elsif (exists $cb_id{$type}) {
		585	_attach_cb $registry, $cb_id{$type}, $prio, shift @arg;
		586
		587	} elsif (ref $type) {
		588	warn "attaching objects not supported, ignoring.\n";
		589
		590	} else {
		591	shift @arg;
		592	warn "attach argument '$type' not supported, ignoring.\n";
		593	}
		594	}
		595	}
		596
		597	sub _object_attach {
		598	my ($obj, $name, %arg) = @_;
		599
		600	return if exists $obj->{_attachment}{$name};
		601
		602	if (my $attach = $attachment{$name}) {
		603	my $registry = $obj->registry;
		604
		605	for (@$attach) {
		606	my ($klass, @attach) = @$_;
		607	_attach $registry, $klass, @attach;
		608	}
		609
		610	$obj->{$name} = \%arg;
		611	} else {
		612	warn "object uses attachment '$name' that is not available, postponing.\n";
		613	}
		614
		615	$obj->{_attachment}{$name} = undef;
		616	}
		617
		618	sub cf::attachable::attach {
		619	if (ref $_[0]) {
		620	_object_attach @_;
		621	} else {
		622	_attach shift->_attach_registry, @_;
		623	}
		624	};
		625
		626	# all those should be optimised
		627	sub cf::attachable::detach {
		628	my ($obj, $name) = @_;
		629
		630	if (ref $obj) {
		631	delete $obj->{_attachment}{$name};
		632	reattach ($obj);
		633	} else {
		634	Carp::croak "cannot, currently, detach class attachments";
		635	}
		636	};
		637
		638	sub cf::attachable::attached {
		639	my ($obj, $name) = @_;
		640
		641	exists $obj->{_attachment}{$name}
		642	}
		643
		644	for my $klass (qw(ATTACHABLE GLOBAL OBJECT PLAYER CLIENT MAP)) {
		645	eval "#line " . __LINE__ . " 'cf.pm'
		646	sub cf::\L$klass\E::_attach_registry {
		647	(\\\@CB_$klass, KLASS_$klass)
		648	}
		649
		650	sub cf::\L$klass\E::attachment {
		651	my \$name = shift;
		652
		653	\$attachment{\$name} = [[KLASS_$klass, \@_]];
		654	}
		655	";
		656	die if $@;
		657	}
		658
		659	our $override;
		660	our @invoke_results = (); # referenced from .xs code. TODO: play tricks with reify and mortals?
		661
		662	sub override {
		663	$override = 1;
		664	@invoke_results = ();
		665	}
		666
		667	sub do_invoke {
102	my $event = shift;	668	my $event = shift;
		669	my $callbacks = shift;
103		670
104	my $cb = $hook[$event]	671	@invoke_results = ();
		672
		673	local $override;
		674
		675	for (@$callbacks) {
		676	eval { &{$_->[1]} };
		677
		678	if ($@) {
		679	warn "$@";
		680	warn "... while processing $EVENT[$event][0](@_) event, skipping processing altogether.\n";
		681	override;
		682	}
		683
		684	return 1 if $override;
		685	}
		686
		687	0
		688	}
		689
		690	=item $bool = cf::global::invoke (EVENT_CLASS_XXX, ...)
		691
		692	=item $bool = $attachable->invoke (EVENT_CLASS_XXX, ...)
		693
		694	Generate an object-specific event with the given arguments.
		695
		696	This API is preliminary (most likely, the EVENT_CLASS_xxx prefix will be
		697	removed in future versions), and there is no public API to access override
		698	results (if you must, access C<@cf::invoke_results> directly).
		699
		700	=back
		701
		702	=cut
		703
		704	#############################################################################
		705	# object support
		706
		707	sub reattach {
		708	# basically do the same as instantiate, without calling instantiate
		709	my ($obj) = @_;
		710
		711	bless $obj, ref $obj; # re-bless in case extensions have been reloaded
		712
		713	my $registry = $obj->registry;
		714
		715	@$registry = ();
		716
		717	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} || {} };
		718
		719	for my $name (keys %{ $obj->{_attachment} || {} }) {
		720	if (my $attach = $attachment{$name}) {
		721	for (@$attach) {
		722	my ($klass, @attach) = @$_;
		723	_attach $registry, $klass, @attach;
		724	}
		725	} else {
		726	warn "object uses attachment '$name' that is not available, postponing.\n";
		727	}
		728	}
		729	}
		730
		731	cf::attachable->attach (
		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,
		745	on_clone => sub {
		746	my ($src, $dst) = @_;
		747
		748	@{$dst->registry} = @{$src->registry};
		749
		750	%$dst = %$src;
		751
		752	%{$dst->{_attachment}} = %{$src->{_attachment}}
		753	if exists $src->{_attachment};
		754	},
		755	);
		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
105	or return;	809	or return;
106		810
107	List::Util::max map &$_, values %$cb	811	unless (aio_stat "$filename.pst") {
108	}	812	(aio_load "$filename.pst", $av) >= 0
109		813	or return;
110	sub inject_command {	814	$av = eval { (Storable::thaw $av)->{objs} };
111	my ($name, $obj, $params) = @_;
112
113	for my $cmd (@{ $command{$name} }) {
114	$cmd->[1]->($obj, $params);
115	}	815	}
116		816
117	-1	817	warn sprintf "loading %s (%d)\n",
		818	$filename, length $data, scalar @{$av || []};#d#
		819	return ($data, $av);
118	}	820	}
		821
		822	#############################################################################
		823	# command handling &c
		824
		825	=item cf::register_command $name => \&callback($ob,$args);
		826
		827	Register a callback for execution when the client sends the user command
		828	$name.
		829
		830	=cut
119		831
120	sub register_command {	832	sub register_command {
121	my ($name, $time, $cb) = @_;	833	my ($name, $cb) = @_;
122		834
123	my $caller = caller;	835	my $caller = caller;
124	#warn "registering command '$name/$time' to '$caller'";	836	#warn "registering command '$name/$time' to '$caller'";
125		837
126	push @{ $command{$name} }, [$time, $cb, $caller];	838	push @{ $COMMAND{$name} }, [$caller, $cb];
127	$COMMAND{"$name\000"} = List::Util::max map $_->[0], @{ $command{$name} };
128	}	839	}
		840
		841	=item cf::register_extcmd $name => \&callback($pl,$packet);
		842
		843	Register a callbackf ro execution when the client sends an extcmd packet.
		844
		845	If the callback returns something, it is sent back as if reply was being
		846	called.
		847
		848	=cut
129		849
130	sub register_extcmd {	850	sub register_extcmd {
131	my ($name, $cb) = @_;	851	my ($name, $cb) = @_;
132		852
133	my $caller = caller;	853	$EXTCMD{$name} = $cb;
134	#warn "registering extcmd '$name' to '$caller'";
135
136	$extcmd{$name} = [$cb, $caller];
137	}	854	}
138		855
139	sub register {	856	cf::player->attach (
140	my ($base, $pkg) = @_;	857	on_command => sub {
		858	my ($pl, $name, $params) = @_;
141		859
142	for my $idx (0 .. $#EVENT) {	860	my $cb = $COMMAND{$name}
143	if (my $ref = $pkg->can ("on_$EVENT[$idx]")) {	861	or return;
144	#warn "registering $EVENT[$idx] hook to '$pkg'\n";	862
145	$hook[$idx]{$base} = $ref;	863	for my $cmd (@$cb) {
		864	$cmd->[1]->($pl->ob, $params);
146	}	865	}
		866
		867	cf::override;
147	}	868	},
148	}	869	on_extcmd => sub {
		870	my ($pl, $buf) = @_;
		871
		872	my $msg = eval { from_json $buf };
		873
		874	if (ref $msg) {
		875	if (my $cb = $EXTCMD{$msg->{msgtype}}) {
		876	if (my %reply = $cb->($pl, $msg)) {
		877	$pl->ext_reply ($msg->{msgid}, %reply);
		878	}
		879	}
		880	} else {
		881	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";
		882	}
		883
		884	cf::override;
		885	},
		886	);
149		887
150	sub load_extension {	888	sub load_extension {
151	my ($path) = @_;	889	my ($path) = @_;
152		890
153	$path =~ /([^\/\\]+)\.ext$/ or die "$path";	891	$path =~ /([^\/\\]+)\.ext$/ or die "$path";
154	my $base = $1;	892	my $base = $1;
155	my $pkg = $1;	893	my $pkg = $1;
156	$pkg =~ s/[^[:word:]]/_/g;	894	$pkg =~ s/[^[:word:]]/_/g;
157	$pkg = "cf::ext::$pkg";	895	$pkg = "ext::$pkg";
158		896
159	warn "loading '$path' into '$pkg'\n";	897	warn "... loading '$path' into '$pkg'\n";
160		898
161	open my $fh, "<:utf8", $path	899	open my $fh, "<:utf8", $path
162	or die "$path: $!";	900	or die "$path: $!";
163		901
164	my $source =	902	my $source =
165	"package $pkg; use strict; use utf8;\n"	903	"package $pkg; use strict; use utf8;\n"
166	. "#line 1 \"$path\"\n{\n"	904	. "#line 1 \"$path\"\n{\n"
167	. (do { local $/; <$fh> })	905	. (do { local $/; <$fh> })
168	. "\n};\n1";	906	. "\n};\n1";
169		907
170	eval $source	908	unless (eval $source) {
171	or die "$path: $@";	909	my $msg = $@ ? "$path: $@\n"
		910	: "extension disabled.\n";
		911	if ($source =~ /^#!.*perl.*#.*MANDATORY/m) { # ugly match
		912	warn $@;
		913	warn "mandatory extension failed to load, exiting.\n";
		914	exit 1;
		915	}
		916	die $@;
		917	}
172		918
173	push @exts, $pkg;	919	push @EXTS, $pkg;
174	$ext_pkg{$base} = $pkg;
175
176	# no strict 'refs';
177	# @{"$pkg\::ISA"} = ext::;
178
179	register $base, $pkg;
180	}
181
182	sub unload_extension {
183	my ($pkg) = @_;
184
185	warn "removing extension $pkg\n";
186
187	# remove hooks
188	for my $idx (0 .. $#EVENT) {
189	delete $hook[$idx]{$pkg};
190	}
191
192	# remove commands
193	for my $name (keys %command) {
194	my @cb = grep $_->[2] ne $pkg, @{ $command{$name} };
195
196	if (@cb) {
197	$command{$name} = \@cb;
198	$COMMAND{"$name\000"} = List::Util::max map $_->[0], @cb;
199	} else {
200	delete $command{$name};
201	delete $COMMAND{"$name\000"};
202	}
203	}
204
205	# remove extcmds
206	for my $name (grep $extcmd{$_}[1] eq $pkg, keys %extcmd) {
207	delete $extcmd{$name};
208	}
209
210	if (my $cb = $pkg->can ("on_unload")) {
211	eval {
212	$cb->($pkg);
213	1
214	} or warn "$pkg unloaded, but with errors: $@";
215	}
216
217	Symbol::delete_package $pkg;
218	}	920	}
219		921
220	sub load_extensions {	922	sub load_extensions {
221	my $LIBDIR = maps_directory "perl";
222
223	for my $ext (<$LIBDIR/*.ext>) {	923	for my $ext (<$LIBDIR/*.ext>) {
224	next unless -r $ext;	924	next unless -r $ext;
225	eval {	925	eval {
226	load_extension $ext;	926	load_extension $ext;
227	1	927	1
228	} or warn "$ext not loaded: $@";	928	} or warn "$ext not loaded: $@";
229	}	929	}
230	}	930	}
231		931
232	register_command "perl-reload", 0, sub {	932	#############################################################################
		933
		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 {
233	my ($who, $arg) = @_;	1193	my ($path, $base) = @_;
234		1194
235	if ($who->flag (FLAG_WIZ)) {	1195	$path = "$path"; # make sure its a string
236	$who->message ("reloading...");
237		1196
238	warn "reloading...\n";	1197	$path =~ s/\.map$//;
239	eval {
240	# 1. cancel all watchers
241	$_->cancel for Event::all_watchers;
242		1198
243	# 2. unload all extensions	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 {
		1461	my ($map) = @_;
		1462
		1463	my @diag; # diagonal neighbours
		1464
		1465	for (0 .. 3) {
		1466	my $neigh = $map->tile_path ($_)
244	for (@exts) {	1467	or next;
245	$who->message ("unloading <$_>");	1468	$neigh = find $neigh, $map
246	unload_extension $_;	1469	or next;
		1470	$neigh->load;
		1471
		1472	push @diag, [$neigh->tile_path (($_ + 3) % 4), $neigh],
		1473	[$neigh->tile_path (($_ + 1) % 4), $neigh];
		1474	}
		1475
		1476	for (@diag) {
		1477	my $neigh = find @$_
		1478	or next;
		1479	$neigh->load;
		1480	}
		1481	}
		1482
		1483	sub find_sync {
		1484	my ($path, $origin) = @_;
		1485
		1486	cf::sync_job { find $path, $origin }
		1487	}
		1488
		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};
247	}	1516	}
248
249	# 3. unload all modules loaded from $LIBDIR
250	while (my ($k, $v) = each %INC) {
251	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
252
253	$who->message ("removing <$k>");
254	delete $INC{$k};
255
256	$k =~ s/\.pm$//;
257	$k =~ s/\//::/g;
258
259	if (my $cb = $k->can ("unload_module")) {
260	$cb->();
261	}
262
263	Symbol::delete_package $k;
264	}
265
266	# 4. get rid of ext::, as good as possible
267	Symbol::delete_package "ext::$_"
268	for qw(cf::object cf::object::map cf::object::player cf::player cf::map cf::party cf::region);
269
270	# 5. remove register_script_function callbacks
271	# TODO
272
273	# 6. unload cf.pm "a bit"
274	delete $INC{"cf.pm"};
275
276	# don't, removes xs symbols, too
277	#Symbol::delete_package __PACKAGE__;
278
279	# 7. reload cf.pm
280	$who->message ("reloading cf.pm");
281	require cf;
282	};	1517	}
283	warn $@ if $@;	1518	undef $MAP_PREFETCHER;
284	$who->message ($@) if $@;	1519	};
285	warn "reloaded\n";	1520	$MAP_PREFETCHER->prio (6);
286		1521
287	$who->message ("reloaded");	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);
288	} else {	1550	} else {
289	$who->message ("Intruder Alert!");	1551	$self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
290	}
291	};
292
293	#############################################################################
294	# utility functions
295
296	use JSON::Syck (); # TODO# replace by JSON::PC once working
297
298	sub from_json($) {
299	$JSON::Syck::ImplicitUnicode = 1; # work around JSON::Syck bugs
300	JSON::Syck::Load $_[0]
301	}
302
303	sub to_json($) {
304	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
305	JSON::Syck::Dump $_[0]
306	}
307
308	#############################################################################
309	# extcmd framework, basically convert ext <msg>
310	# into pkg::->on_extcmd_arg1 (...) while shortcutting a few
311
312	sub on_extcmd {
313	my ($pl, $buf) = @_;
314
315	my $msg = eval { from_json $buf };
316
317	if (ref $msg) {
318	if (my $cb = $extcmd{$msg->{msgtype}}) {
319	if (my %reply = $cb->[0]->($pl, $msg)) {
320	$pl->ext_reply ($msg->{msgid}, %reply);
321	}
322	}
323	} else {
324	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";
325	}
326
327	1	1552	}
328	}	1553	}
329		1554
330	#############################################################################	1555	sub swap_out {
331	# load/save/clean perl data associated with a map
332
333	*on_mapclean = sub {
334	my ($map) = @_;	1556	my ($self) = @_;
335		1557
336	my $path = $map->tmpname;	1558	# save first because save cedes
337	defined $path or return;	1559	$self->save;
338		1560
339	unlink "$path.cfperl";	1561	my $lock = cf::lock_acquire "map_data:" . $self->path;
340	};
341		1562
342	*on_mapin =	1563	return if $self->players;
343	*on_mapload = sub {	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 {
344	my ($map) = @_;	1572	my ($self) = @_;
345		1573
346	my $path = $map->tmpname;	1574	# TODO: safety, remove and allow resettable per-player maps
347	$path = $map->path unless defined $path;	1575	return 1e99 if $self->isa ("ext::map_per_player");#d#
		1576	return 1e99 if $self->{deny_reset};
348		1577
349	open my $fh, "<:raw", "$path.cfperl"	1578	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
350	or return; # no perl data	1579	my $to = List::Util::min $MAX_RESET, $self->reset_timeout || $DEFAULT_RESET;
351		1580
352	my $data = Storable::thaw do { local $/; <$fh> };	1581	$time + $to
		1582	}
353		1583
354	$data->{version} <= 1	1584	sub should_reset {
355	or return; # too new
356
357	$map->_set_obs ($data->{obs});
358	};
359
360	*on_mapout = sub {
361	my ($map) = @_;	1585	my ($self) = @_;
362		1586
363	my $path = $map->tmpname;	1587	$self->reset_at <= $cf::RUNTIME
364	$path = $map->path unless defined $path;
365
366	my $obs = $map->_get_obs;
367
368	if (defined $obs) {
369	open my $fh, ">:raw", "$path.cfperl"
370	or die "$path.cfperl: $!";
371
372	stat $path;
373
374	print $fh Storable::nfreeze {
375	size => (stat _)[7],
376	time => (stat _)[9],
377	version => 1,
378	obs => $obs,
379	};
380
381	chmod SAVE_MODE, "$path.cfperl"; # very racy, but cf-compatible *g*
382	} else {
383	unlink "$path.cfperl";
384	}
385	};
386
387	#############################################################################
388	# load/save perl data associated with player->ob objects
389
390	*on_player_load = sub {
391	my ($ob, $path) = @_;
392
393	for my $o ($ob, $ob->inv) {
394	if (my $value = $o->get_ob_key_value ("_perl_data")) {
395	$o->set_ob_key_value ("_perl_data");
396
397	%$o = %{ Storable::thaw pack "H*", $value };
398	}
399	}
400	};
401
402	*on_player_save = sub {
403	my ($ob, $path) = @_;
404
405	$_->set_ob_key_value (_perl_data => unpack "H*", Storable::nfreeze $_)
406	for grep %$_, $ob, $ob->inv;
407	};
408
409	#############################################################################
410	# core extensions - in perl
411
412	my $delta_timer = Event->timer (
413	parked => 1,
414	prio => Event::PRIO_HIGH,
415	cb => sub { Event::unloop (undef) },
416	);
417
418	sub sleep_delta($) {
419	$delta_timer->at (Event::time + $_[0]);
420	$delta_timer->start;
421	Event::loop;
422	}	1588	}
423		1589
424	=item cf::player::exists $login	1590	sub reset {
		1591	my ($self) = @_;
425		1592
426	Returns true when the given account exists.	1593	my $lock = cf::lock_acquire "map_data:$self->{path}";
427		1594
428	=cut	1595	return if $self->players;
		1596	return if $self->isa ("ext::map_per_player");#d#
429		1597
430	sub cf::player::exists($) {	1598	warn "resetting map ", $self->path;#d#
431	cf::player::find $_[0]
432	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;
433	}
434		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;
		1673
		1674	=over 4
		1675
		1676	=item $ob->inv_recursive
		1677
		1678	Returns the inventory of the object _and_ their inventories, recursively.
		1679
		1680	=cut
		1681
		1682	sub inv_recursive_;
		1683	sub inv_recursive_ {
		1684	map { $_, inv_recursive_ $_->inv } @_
		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
		1698
435	=item $player->reply ($npc, $msg[, $flags])	1699	=item $player_object->reply ($npc, $msg[, $flags])
436		1700
437	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>
438	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
439	dialogue with the given NPC character.	1703	dialogue with the given NPC character.
440		1704
441	=cut	1705	=cut
442		1706
443	# rough implementation of a future "reply" method that works	1707	# rough implementation of a future "reply" method that works
444	# with dialog boxes.	1708	# with dialog boxes.
		1709	#TODO: the first argument must go, split into a $npc->reply_to ( method
445	sub cf::object::player::reply($$$;$) {	1710	sub cf::object::player::reply($$$;$) {
446	my ($self, $npc, $msg, $flags) = @_;	1711	my ($self, $npc, $msg, $flags) = @_;
447		1712
448	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;	1713	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;
449		1714
…		…
453	$msg = $npc->name . " says: $msg" if $npc;	1718	$msg = $npc->name . " says: $msg" if $npc;
454	$self->message ($msg, $flags);	1719	$self->message ($msg, $flags);
455	}	1720	}
456	}	1721	}
457		1722
458	=item $player->ext_reply ($msgid, $msgtype, %msg)	1723	=item $player_object->may ("access")
459		1724
460	Sends an ext reply to the player.	1725	Returns wether the given player is authorized to access resource "access"
		1726	(e.g. "command_wizcast").
461		1727
462	=cut	1728	=cut
463		1729
464	sub cf::player::ext_reply($$$%) {	1730	sub cf::object::player::may {
		1731	my ($self, $access) = @_;
		1732
		1733	$self->flag (cf::FLAG_WIZ) ||
		1734	(ref $cf::CFG{"may_$access"}
		1735	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
		1736	: $cf::CFG{"may_$access"})
		1737	}
		1738
		1739	=item $player_object->enter_link
		1740
		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 {
465	my ($self, $id, %msg) = @_;	1927	my ($self, $exit) = @_;
466		1928
467	$msg{msgid} = $id;	1929	return unless $self->type == cf::PLAYER;
468		1930
469	$self->send ("ext " . to_json \%msg);	1931	if ($exit->slaying eq "/!") {
470	}	1932	#TODO: this should de-fi-ni-te-ly not be a sync-job
		1933	cf::sync_job { prepare_random_map $exit };
		1934	}
471		1935
472	#############################################################################	1936	my $slaying = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
473	# map scripting support	1937	my $hp = $exit->stats->hp;
		1938	my $sp = $exit->stats->sp;
474		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
		2062
		2063	=head2 SAFE SCRIPTING
		2064
		2065	Functions that provide a safe environment to compile and execute
		2066	snippets of perl code without them endangering the safety of the server
		2067	itself. Looping constructs, I/O operators and other built-in functionality
		2068	is not available in the safe scripting environment, and the number of
		2069	functions and methods that can be called is greatly reduced.
		2070
		2071	=cut
		2072
475	our $safe = new Safe "ext";	2073	our $safe = new Safe "safe";
476	our $safe_hole = new Safe::Hole;	2074	our $safe_hole = new Safe::Hole;
477		2075
478	$SIG{FPE} = 'IGNORE';	2076	$SIG{FPE} = 'IGNORE';
479		2077
480	$safe->permit_only (Opcode::opset qw(:base_core :base_mem :base_orig :base_math sort time));	2078	$safe->permit_only (Opcode::opset qw(:base_core :base_mem :base_orig :base_math sort time));
481		2079
482	# here we export the classes and methods available to script code	2080	# here we export the classes and methods available to script code
483		2081
		2082	=pod
		2083
		2084	The following fucntions and emthods are available within a safe environment:
		2085
		2086	cf::object contr pay_amount pay_player map
		2087	cf::object::player player
		2088	cf::player peaceful
		2089	cf::map trigger
		2090
		2091	=cut
		2092
484	for (	2093	for (
485	["cf::object" => qw(contr pay_amount pay_player)],	2094	["cf::object" => qw(contr pay_amount pay_player map)],
486	["cf::object::player" => qw(player)],	2095	["cf::object::player" => qw(player)],
487	["cf::player" => qw(peaceful)],	2096	["cf::player" => qw(peaceful)],
		2097	["cf::map" => qw(trigger)],
488	) {	2098	) {
489	no strict 'refs';	2099	no strict 'refs';
490	my ($pkg, @funs) = @$_;	2100	my ($pkg, @funs) = @$_;
491	*{"ext::$pkg\::$_"} = $safe_hole->wrap (\&{"$pkg\::$_"})	2101	*{"safe::$pkg\::$_"} = $safe_hole->wrap (\&{"$pkg\::$_"})
492	for @funs;	2102	for @funs;
493	}	2103	}
		2104
		2105	=over 4
		2106
		2107	=item @retval = safe_eval $code, [var => value, ...]
		2108
		2109	Compiled and executes the given perl code snippet. additional var/value
		2110	pairs result in temporary local (my) scalar variables of the given name
		2111	that are available in the code snippet. Example:
		2112
		2113	my $five = safe_eval '$first + $second', first => 1, second => 4;
		2114
		2115	=cut
494		2116
495	sub safe_eval($;@) {	2117	sub safe_eval($;@) {
496	my ($code, %vars) = @_;	2118	my ($code, %vars) = @_;
497		2119
498	my $qcode = $code;	2120	my $qcode = $code;
499	$qcode =~ s/"/‟/g; # not allowed in #line filenames	2121	$qcode =~ s/"/‟/g; # not allowed in #line filenames
500	$qcode =~ s/\n/\\n/g;	2122	$qcode =~ s/\n/\\n/g;
501		2123
502	local $_;	2124	local $_;
503	local @ext::cf::_safe_eval_args = values %vars;	2125	local @safe::cf::_safe_eval_args = values %vars;
504		2126
505	$code =	2127	my $eval =
506	"do {\n"	2128	"do {\n"
507	. "my (" . (join ",", map "\$$_", keys %vars) . ") = \@cf::_safe_eval_args;\n"	2129	. "my (" . (join ",", map "\$$_", keys %vars) . ") = \@cf::_safe_eval_args;\n"
508	. "#line 0 \"{$qcode}\"\n"	2130	. "#line 0 \"{$qcode}\"\n"
509	. $code	2131	. $code
510	. "\n}"	2132	. "\n}"
511	;	2133	;
512		2134
513	sub_generation_inc;	2135	sub_generation_inc;
514	my @res = wantarray ? $safe->reval ($code) : scalar $safe->reval ($code);	2136	my @res = wantarray ? $safe->reval ($eval) : scalar $safe->reval ($eval);
515	sub_generation_inc;	2137	sub_generation_inc;
516		2138
		2139	if ($@) {
		2140	warn "$@";
		2141	warn "while executing safe code '$code'\n";
		2142	warn "with arguments " . (join " ", %vars) . "\n";
		2143	}
		2144
517	wantarray ? @res : $res[0]	2145	wantarray ? @res : $res[0]
518	}	2146	}
		2147
		2148	=item cf::register_script_function $function => $cb
		2149
		2150	Register a function that can be called from within map/npc scripts. The
		2151	function should be reasonably secure and should be put into a package name
		2152	like the extension.
		2153
		2154	Example: register a function that gets called whenever a map script calls
		2155	C<rent::overview>, as used by the C<rent> extension.
		2156
		2157	cf::register_script_function "rent::overview" => sub {
		2158	...
		2159	};
		2160
		2161	=cut
519		2162
520	sub register_script_function {	2163	sub register_script_function {
521	my ($fun, $cb) = @_;	2164	my ($fun, $cb) = @_;
522		2165
523	no strict 'refs';	2166	no strict 'refs';
524	*{"ext::$fun"} = $safe_hole->wrap ($cb);	2167	*{"safe::$fun"} = $safe_hole->wrap ($cb);
525	}	2168	}
		2169
		2170	=back
		2171
		2172	=cut
526		2173
527	#############################################################################	2174	#############################################################################
528	# initialisation
529		2175
530	register "<global>", __PACKAGE__;	2176	=head2 EXTENSION DATABASE SUPPORT
		2177
		2178	Crossfire maintains a very simple database for extension use. It can
		2179	currently store anything that can be serialised using Storable, which
		2180	excludes objects.
		2181
		2182	The parameter C<$family> should best start with the name of the extension
		2183	using it, it should be unique.
		2184
		2185	=over 4
		2186
		2187	=item $value = cf::db_get $family => $key
		2188
		2189	Returns a single value from the database.
		2190
		2191	=item cf::db_put $family => $key => $value
		2192
		2193	Stores the given C<$value> in the family.
		2194
		2195	=cut
		2196
		2197	our $DB;
		2198
		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
		2214	my $path = cf::localdir . "/database.pst";
		2215	if (stat $path) {
		2216	cf::sync_job {
		2217	my $pst = Storable::retrieve $path;
		2218
		2219	cf::db_put (board => data => $pst->{board});
		2220	cf::db_put (guildrules => data => $pst->{guildrules});
		2221	cf::db_put (rent => balance => $pst->{rent}{balance});
		2222	BDB::db_env_txn_checkpoint $DB_ENV;
		2223
		2224	unlink $path;
		2225	};
		2226	}
		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 { };
		2244	}
		2245
		2246	#############################################################################
		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	}
		2253
		2254	sub cfg_load {
		2255	open my $fh, "<:utf8", cf::confdir . "/config"
		2256	or return;
		2257
		2258	local $/;
		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;
		2277	}
		2278
		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
		2288	cfg_load;
		2289	db_init;
		2290	load_extensions;
		2291
		2292	$TICK_WATCHER->start;
		2293	Event::loop;
		2294	}
		2295
		2296	#############################################################################
		2297	# initialisation and cleanup
		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
		2354	sub reload() {
		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	}
		2360
		2361	warn "reloading...";
		2362
		2363	warn "entering sync_job";
		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";
		2376	for (Event::all_watchers) {
		2377	$_->cancel if $_->data & WF_AUTOCANCEL;
		2378	}
		2379
		2380	warn "flushing outstanding aio requests";
		2381	for (;;) {
		2382	BDB::flush;
		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: $@";
		2408	}
		2409
		2410	warn "... nuking $pkg";
		2411	Symbol::delete_package $pkg;
		2412	}
		2413
		2414	warn "unloading all perl modules loaded from $LIBDIR";
		2415	while (my ($k, $v) = each %INC) {
		2416	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
		2417
		2418	warn "... unloading $k";
		2419	delete $INC{$k};
		2420
		2421	$k =~ s/\.pm$//;
		2422	$k =~ s/\//::/g;
		2423
		2424	if (my $cb = $k->can ("unload_module")) {
		2425	$cb->();
		2426	}
		2427
		2428	Symbol::delete_package $k;
		2429	}
		2430
		2431	warn "getting rid of safe::, as good as possible";
		2432	Symbol::delete_package "safe::$_"
		2433	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
		2434
		2435	warn "unloading cf.pm \"a bit\"";
		2436	delete $INC{"cf.pm"};
		2437
		2438	# don't, removes xs symbols, too,
		2439	# and global variables created in xs
		2440	#Symbol::delete_package __PACKAGE__;
		2441
		2442	warn "unload completed, starting to reload now";
		2443
		2444	warn "reloading cf.pm";
		2445	require cf;
		2446	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
		2447
		2448	warn "loading config and database again";
		2449	cf::cfg_load;
		2450
		2451	warn "loading extensions";
		2452	cf::load_extensions;
		2453
		2454	warn "reattaching attachments to objects/players";
		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;
		2469	};
		2470
		2471	warn "reloaded";
		2472	};
		2473
		2474	our $RELOAD_WATCHER; # used only during reload
		2475
		2476	register_command "reload" => sub {
		2477	my ($who, $arg) = @_;
		2478
		2479	if ($who->flag (FLAG_WIZ)) {
		2480	$who->message ("reloading server.");
		2481
		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	},
		2493	);
		2494	}
		2495	};
531		2496
532	unshift @INC, $LIBDIR;	2497	unshift @INC, $LIBDIR;
533		2498
534	load_extensions;	2499	my $bug_warning = 0;
		2500
		2501	$TICK_WATCHER = Event->timer (
		2502	reentrant => 0,
		2503	parked => 1,
		2504	prio => 0,
		2505	at => $NEXT_TICK || $TICK,
		2506	data => WF_AUTOCANCEL,
		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
		2516	cf::server_tick; # one server iteration
		2517	$RUNTIME += $TICK;
		2518	$NEXT_TICK += $TICK;
		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
		2534	# if we are delayed by four ticks or more, skip them all
		2535	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
		2536
		2537	$TICK_WATCHER->at ($NEXT_TICK);
		2538	$TICK_WATCHER->start;
		2539	},
		2540	);
		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;
		2596	IO::AIO::max_poll_time $TICK * 0.1;
		2597	$AIO_POLL_WATCHER = Event->io (
		2598	reentrant => 0,
		2599	data => WF_AUTOCANCEL,
		2600	fd => IO::AIO::poll_fileno,
		2601	poll => 'r',
		2602	prio => 6,
		2603	cb => \&IO::AIO::poll_cb,
		2604	);
		2605	}
		2606
		2607	END { cf::emergency_save }
535		2608
536	1	2609	1
537		2610

Diff Legend

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