--- deliantra/server/lib/cf.pm 2006/08/25 17:11:53 1.43 +++ deliantra/server/lib/cf.pm 2006/12/31 17:29:22 1.106 @@ -1,5 +1,8 @@ package cf; +use utf8; +use strict; + use Symbol; use List::Util; use Storable; @@ -7,78 +10,130 @@ use Safe; use Safe::Hole; +use Coro 3.3; +use Coro::Event; +use Coro::Timer; +use Coro::Signal; +use Coro::Semaphore; +use Coro::AIO; + +use Fcntl; +use IO::AIO 2.31 (); +use YAML::Syck (); use Time::HiRes; -use Event; -$Event::Eval = 1; # no idea why this is required, but it is -use strict; +use Event; $Event::Eval = 1; # no idea why this is required, but it is + +# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode? +$YAML::Syck::ImplicitUnicode = 1; + +$Coro::main->prio (2); # run main coroutine ("the server") with very high priority + +sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload + +our %COMMAND = (); +our %COMMAND_TIME = (); +our %EXTCMD = (); -our %COMMAND = (); our @EVENT; -our @PLUGIN_EVENT; -our %PROP_TYPE; -our %PROP_IDX; -our $LIBDIR = maps_directory "perl"; +our $LIBDIR = datadir . "/ext"; our $TICK = MAX_TIME * 1e-6; our $TICK_WATCHER; our $NEXT_TICK; +our $NOW; -BEGIN { - @PLUGIN_EVENT = map lc, @PLUGIN_EVENT; +our %CFG; - *CORE::GLOBAL::warn = sub { - my $msg = join "", @_; - $msg .= "\n" - unless $msg =~ /\n$/; +our $UPTIME; $UPTIME ||= time; +our $RUNTIME; - print STDERR "cfperl: $msg"; - LOG llevError, "cfperl: $msg"; - }; +our %MAP; # all maps +our $LINK_MAP; # the special {link} map +our $FREEZE; + +binmode STDOUT; +binmode STDERR; + +# read virtual server time, if available +unless ($RUNTIME || !-e cf::localdir . "/runtime") { + open my $fh, "<", cf::localdir . "/runtime" + or die "unable to read runtime file: $!"; + $RUNTIME = <$fh> + 0.; } -my %ignore_set = (MAP_PROP_PATH => 1); # I hate the plug-in api. Deeply! +mkdir cf::localdir; +mkdir cf::localdir . "/" . cf::playerdir; +mkdir cf::localdir . "/" . cf::tmpdir; +mkdir cf::localdir . "/" . cf::uniquedir; -# generate property mutators -sub prop_gen { - my ($prefix, $class) = @_; +our %EXT_CORO; - no strict 'refs'; +############################################################################# - for my $prop (keys %PROP_TYPE) { - $prop =~ /^\Q$prefix\E_(.*$)/ or next; - my $sub = lc $1; +=head2 GLOBAL VARIABLES - my $type = $PROP_TYPE{$prop}; - my $idx = $PROP_IDX {$prop}; +=over 4 - *{"$class\::get_$sub"} = *{"$class\::$sub"} = sub { - $_[0]->get_property ($type, $idx) - }; +=item $cf::UPTIME - *{"$class\::set_$sub"} = sub { - $_[0]->set_property ($type, $idx, $_[1]); - } unless $ignore_set{$prop}; - } -} +The timestamp of the server start (so not actually an uptime). + +=item $cf::RUNTIME + +The time this server has run, starts at 0 and is increased by $cf::TICK on +every server tick. + +=item $cf::LIBDIR + +The perl library directory, where extensions and cf-specific modules can +be found. It will be added to C<@INC> automatically. + +=item $cf::NOW + +The time of the last (current) server tick. -# auto-generate most of the API +=item $cf::TICK -prop_gen OBJECT_PROP => "cf::object"; -# CFAPI_OBJECT_ANIMATION? -prop_gen PLAYER_PROP => "cf::object::player"; +The interval between server ticks, in seconds. + +=item %cf::CFG + +Configuration for the server, loaded from C, or +from wherever your confdir points to. + +=back + +=cut + +BEGIN { + *CORE::GLOBAL::warn = sub { + my $msg = join "", @_; + utf8::encode $msg; -prop_gen MAP_PROP => "cf::map"; -prop_gen ARCH_PROP => "cf::arch"; + $msg .= "\n" + unless $msg =~ /\n$/; -# guessed hierarchies + LOG llevError, "cfperl: $msg"; + }; +} +@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable'; +@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable'; +@safe::cf::player::ISA = @cf::player::ISA = 'cf::attachable'; +@safe::cf::client::ISA = @cf::client::ISA = 'cf::attachable'; +@safe::cf::map::ISA = @cf::map::ISA = 'cf::attachable'; @safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object'; -@safe::cf::object::map::ISA = @cf::object::map::ISA = 'cf::object'; # we bless all objects into (empty) derived classes to force a method lookup # within the Safe compartment. -for my $pkg (qw(cf::object cf::object::map cf::object::player cf::player cf::map cf::party cf::region cf::arch)) { +for my $pkg (qw( + cf::global cf::attachable + cf::object cf::object::player + cf::client cf::player + cf::arch cf::living + cf::map cf::party cf::region +)) { no strict 'refs'; @{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg; } @@ -90,39 +145,243 @@ my %ext_pkg; my @exts; my @hook; -my %command; -my %extcmd; + +=head2 UTILITY FUNCTIONS + +=over 4 + +=cut + +use JSON::Syck (); # TODO# replace by JSON::PC once working + +=item $ref = cf::from_json $json + +Converts a JSON string into the corresponding perl data structure. + +=cut + +sub from_json($) { + $JSON::Syck::ImplicitUnicode = 1; # work around JSON::Syck bugs + JSON::Syck::Load $_[0] +} + +=item $json = cf::to_json $ref + +Converts a perl data structure into its JSON representation. + +=cut + +sub to_json($) { + $JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs + JSON::Syck::Dump $_[0] +} + +=item cf::sync_job { BLOCK } + +The design of crossfire+ requires that the main coro ($Coro::main) is +always able to handle events or runnable, as crossfire+ is only partly +reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable. + +If it must be done, put the blocking parts into C. This will run +the given BLOCK in another coroutine while waiting for the result. The +server will be frozen during this time, so the block should either finish +fast or be very important. + +=cut + +sub sync_job(&) { + my ($job) = @_; + + my $busy = 1; + my @res; + + # TODO: use suspend/resume instead + local $FREEZE = 1; + + my $coro = Coro::async { + @res = eval { $job->() }; + warn $@ if $@; + undef $busy; + }; + + if ($Coro::current == $Coro::main) { + $coro->prio (Coro::PRIO_MAX); + while ($busy) { + Coro::cede_notself; + Event::one_event unless Coro::nready; + } + } else { + $coro->join; + } + + wantarray ? @res : $res[0] +} + +=item $coro = cf::coro { BLOCK } + +Creates and returns a new coro. This coro is automcatially being canceled +when the extension calling this is being unloaded. + +=cut + +sub coro(&) { + my $cb = shift; + + my $coro; $coro = async { + eval { + $cb->(); + }; + warn $@ if $@; + }; + + $coro->on_destroy (sub { + delete $EXT_CORO{$coro+0}; + }); + $EXT_CORO{$coro+0} = $coro; + + $coro +} + +=back + +=cut ############################################################################# -# "new" plug-in system -=item cf::object::attach ... # NYI +=head2 ATTACHABLE OBJECTS + +Many objects in crossfire are so-called attachable objects. That means you can +attach callbacks/event handlers (a collection of which is called an "attachment") +to it. All such attachable objects support the following methods. + +In the following description, CLASS can be any of C, C +C, C or C (i.e. the attachable objects in +crossfire+). + +=over 4 + +=item $attachable->attach ($attachment, key => $value...) + +=item $attachable->detach ($attachment) + +Attach/detach a pre-registered attachment to a specific object and give it +the specified key/value pairs as arguments. + +Example, attach a minesweeper attachment to the given object, making it a +10x10 minesweeper game: + + $obj->attach (minesweeper => width => 10, height => 10); + +=item $bool = $attachable->attached ($name) -=item cf::attach_global ... +Checks wether the named attachment is currently attached to the object. -=item cf::attach_to_type ... +=item cf::CLASS->attach ... -=item cf::attach_to_objects ... +=item cf::CLASS->detach ... -=item cf::attach_to_players ... +Define an anonymous attachment and attach it to all objects of the given +CLASS. See the next function for an explanation of its arguments. -=item cf::attach_to_maps ... +You can attach to global events by using the C class. - prio => $number, # lower is earlier - on_xxx => \&cb, - package => package::, +Example, log all player logins: + + cf::player->attach ( + on_login => sub { + my ($pl) = @_; + ... + }, + ); + +Example, attach to the jeweler skill: + + cf::object->attach ( + type => cf::SKILL, + subtype => cf::SK_JEWELER, + on_use_skill => sub { + my ($sk, $ob, $part, $dir, $msg) = @_; + ... + }, + ); + +=item cf::CLASS::attachment $name, ... + +Register an attachment by C<$name> through which attachable objects of the +given CLASS can refer to this attachment. + +Some classes such as crossfire maps and objects can specify attachments +that are attached at load/instantiate time, thus the need for a name. + +These calls expect any number of the following handler/hook descriptions: + +=over 4 + +=item prio => $number + +Set the priority for all following handlers/hooks (unless overwritten +by another C setting). Lower priority handlers get executed +earlier. The default priority is C<0>, and many built-in handlers are +registered at priority C<-1000>, so lower priorities should not be used +unless you know what you are doing. + +=item type => $type + +(Only for C<< cf::object->attach >> calls), limits the attachment to the +given type of objects only (the additional parameter C can be +used to further limit to the given subtype). + +=item on_I => \&cb + +Call the given code reference whenever the named event happens (event is +something like C, C, C and so on, and which +handlers are recognised generally depends on the type of object these +handlers attach to). + +See F for the full list of events supported, and their +class. + +=item package => package:: + +Look for sub functions of the name C<< on_I >> in the given +package and register them. Only handlers for eevents supported by the +object/class are recognised. + +=back + +Example, define an attachment called "sockpuppet" that calls the given +event handler when a monster attacks: + + cf::object::attachment sockpuppet => + on_skill_attack => sub { + my ($self, $victim) = @_; + ... + } + } + +=item $attachable->valid + +Just because you have a perl object does not mean that the corresponding +C-level object still exists. If you try to access an object that has no +valid C counterpart anymore you get an exception at runtime. This method +can be used to test for existence of the C object part without causing an +exception. =cut # the following variables are defined in .xs and must not be re-created -our @CB_GLOBAL = (); # registry for all global events -our @CB_OBJECT = (); -our @CB_PLAYER = (); -our @CB_TYPE = (); # registry for type (cf-object class) based events -our @CB_MAP = (); +our @CB_GLOBAL = (); # registry for all global events +our @CB_ATTACHABLE = (); # registry for all attachables +our @CB_OBJECT = (); # all objects (should not be used except in emergency) +our @CB_PLAYER = (); +our @CB_CLIENT = (); +our @CB_TYPE = (); # registry for type (cf-object class) based events +our @CB_MAP = (); + +my %attachment; -sub _attach_cb($\%$$$) { - my ($registry, $undo, $event, $prio, $cb) = @_; +sub _attach_cb($$$$) { + my ($registry, $event, $prio, $cb) = @_; use sort 'stable'; @@ -131,90 +390,139 @@ @{$registry->[$event]} = sort { $a->[0] cmp $b->[0] } @{$registry->[$event] || []}, $cb; - - push @{$undo->{cb}}, [$event, $cb]; } +# hack +my %attachable_klass = map +($_ => 1), KLASS_OBJECT, KLASS_CLIENT, KLASS_PLAYER, KLASS_MAP; + # attach handles attaching event callbacks # the only thing the caller has to do is pass the correct # registry (== where the callback attaches to). -sub _attach(\@$\@) { - my ($registry, $klass, $arg) = @_; +sub _attach { + my ($registry, $klass, @arg) = @_; + my $object_type; my $prio = 0; - - my %undo = ( - registry => $registry, - cb => [], - ); - my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT; - while (@$arg) { - my $type = shift @$arg; + #TODO: get rid of this hack + if ($attachable_klass{$klass}) { + %cb_id = (%cb_id, map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == KLASS_ATTACHABLE, 0 .. $#EVENT); + } + + while (@arg) { + my $type = shift @arg; if ($type eq "prio") { - $prio = shift @$arg; + $prio = shift @arg; + + } elsif ($type eq "type") { + $object_type = shift @arg; + $registry = $CB_TYPE[$object_type] ||= []; + + } elsif ($type eq "subtype") { + defined $object_type or Carp::croak "subtype specified without type"; + my $object_subtype = shift @arg; + $registry = $CB_TYPE[$object_type + $object_subtype * NUM_SUBTYPES] ||= []; } elsif ($type eq "package") { - my $pkg = shift @$arg; + my $pkg = shift @arg; while (my ($name, $id) = each %cb_id) { if (my $cb = $pkg->can ($name)) { - _attach_cb $registry, %undo, $id, $prio, $cb; + _attach_cb $registry, $id, $prio, $cb; } } } elsif (exists $cb_id{$type}) { - _attach_cb $registry, %undo, $cb_id{$type}, $prio, shift @$arg; + _attach_cb $registry, $cb_id{$type}, $prio, shift @arg; } elsif (ref $type) { warn "attaching objects not supported, ignoring.\n"; } else { - shift @$arg; + shift @arg; warn "attach argument '$type' not supported, ignoring.\n"; } } - - \%undo } -sub cf::object::attach { - die; -} +sub _object_attach { + my ($obj, $name, %arg) = @_; -sub attach_global { - _attach @CB_GLOBAL, KLASS_GLOBAL, @_ -} + return if exists $obj->{_attachment}{$name}; -sub attach_to_type { - my $type = shift; - _attach @{$CB_TYPE[$type]}, KLASS_OBJECT, @_ -} + if (my $attach = $attachment{$name}) { + my $registry = $obj->registry; + + for (@$attach) { + my ($klass, @attach) = @$_; + _attach $registry, $klass, @attach; + } + + $obj->{$name} = \%arg; + } else { + warn "object uses attachment '$name' that is not available, postponing.\n"; + } -sub attach_to_objects { - _attach @CB_OBJECT, KLASS_OBJECT, @_ + $obj->{_attachment}{$name} = undef; } -sub attach_to_players { - _attach @CB_PLAYER, KLASS_PLAYER, @_ +sub cf::attachable::attach { + if (ref $_[0]) { + _object_attach @_; + } else { + _attach shift->_attach_registry, @_; + } +}; + +# all those should be optimised +sub cf::attachable::detach { + my ($obj, $name) = @_; + + if (ref $obj) { + delete $obj->{_attachment}{$name}; + reattach ($obj); + } else { + Carp::croak "cannot, currently, detach class attachments"; + } +}; + +sub cf::attachable::attached { + my ($obj, $name) = @_; + + exists $obj->{_attachment}{$name} } -sub attach_to_maps { - _attach @CB_MAP, KLASS_MAP, @_ +for my $klass (qw(ATTACHABLE GLOBAL OBJECT PLAYER CLIENT MAP)) { + eval "#line " . __LINE__ . " 'cf.pm' + sub cf::\L$klass\E::_attach_registry { + (\\\@CB_$klass, KLASS_$klass) + } + + sub cf::\L$klass\E::attachment { + my \$name = shift; + + \$attachment{\$name} = [[KLASS_$klass, \@_]]; + } + "; + die if $@; } our $override; +our @invoke_results = (); # referenced from .xs code. TODO: play tricks with reify and mortals? -sub override() { - $override = 1 +sub override { + $override = 1; + @invoke_results = (); } -sub invoke { +sub do_invoke { my $event = shift; my $callbacks = shift; + @invoke_results = (); + local $override; for (@$callbacks) { @@ -222,7 +530,7 @@ if ($@) { warn "$@"; - warn "... while processing $EVENT[$event][0] event, skipping processing altogether.\n"; + warn "... while processing $EVENT[$event][0](@_) event, skipping processing altogether.\n"; override; } @@ -232,66 +540,207 @@ 0 } +=item $bool = cf::global::invoke (EVENT_CLASS_XXX, ...) + +=item $bool = $attachable->invoke (EVENT_CLASS_XXX, ...) + +Generate an object-specific event with the given arguments. + +This API is preliminary (most likely, the EVENT_CLASS_xxx prefix will be +removed in future versions), and there is no public API to access override +results (if you must, access C<@cf::invoke_results> directly). + +=back + +=cut + ############################################################################# -# old plug-in events +# object support -sub inject_event { - my $extension = shift; - my $event_code = shift; +sub reattach { + # basically do the same as instantiate, without calling instantiate + my ($obj) = @_; - my $cb = $hook[$event_code]{$extension} - or return; + my $registry = $obj->registry; + + @$registry = (); + + delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} || {} }; + + for my $name (keys %{ $obj->{_attachment} || {} }) { + if (my $attach = $attachment{$name}) { + for (@$attach) { + my ($klass, @attach) = @$_; + _attach $registry, $klass, @attach; + } + } else { + warn "object uses attachment '$name' that is not available, postponing.\n"; + } + } +} + +cf::attachable->attach ( + prio => -1000000, + on_instantiate => sub { + my ($obj, $data) = @_; + + $data = from_json $data; + + for (@$data) { + my ($name, $args) = @$_; + + $obj->attach ($name, %{$args || {} }); + } + }, + on_reattach => \&reattach, + on_clone => sub { + my ($src, $dst) = @_; + + @{$dst->registry} = @{$src->registry}; + + %$dst = %$src; + + %{$dst->{_attachment}} = %{$src->{_attachment}} + if exists $src->{_attachment}; + }, +); + +sub object_freezer_save { + my ($filename, $rdata, $objs) = @_; + + sync_job { + if (length $$rdata) { + warn sprintf "saving %s (%d,%d)\n", + $filename, length $$rdata, scalar @$objs; + + if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) { + chmod SAVE_MODE, $fh; + aio_write $fh, 0, (length $$rdata), $$rdata, 0; + aio_fsync $fh; + close $fh; + + if (@$objs) { + if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) { + chmod SAVE_MODE, $fh; + my $data = Storable::nfreeze { version => 1, objs => $objs }; + aio_write $fh, 0, (length $data), $data, 0; + aio_fsync $fh; + close $fh; + aio_rename "$filename.pst~", "$filename.pst"; + } + } else { + aio_unlink "$filename.pst"; + } - &$cb + aio_rename "$filename~", $filename; + } else { + warn "FATAL: $filename~: $!\n"; + } + } else { + aio_unlink $filename; + aio_unlink "$filename.pst"; + } + } } -sub inject_global_event { - my $event = shift; +sub object_freezer_as_string { + my ($rdata, $objs) = @_; - my $cb = $hook[$event] - or return; + use Data::Dumper; - List::Util::max map &$_, values %$cb + $$rdata . Dumper $objs } -sub inject_command { - my ($name, $obj, $params) = @_; +sub object_thawer_load { + my ($filename) = @_; + + my ($data, $av); + + (aio_load $filename, $data) >= 0 + or return; - for my $cmd (@{ $command{$name} }) { - $cmd->[1]->($obj, $params); + unless (aio_stat "$filename.pst") { + (aio_load "$filename.pst", $av) >= 0 + or return; + $av = eval { (Storable::thaw <$av>)->{objs} }; } - -1 + return ($data, $av); } +############################################################################# +# command handling &c + +=item cf::register_command $name => \&callback($ob,$args); + +Register a callback for execution when the client sends the user command +$name. + +=cut + sub register_command { - my ($name, $time, $cb) = @_; + my ($name, $cb) = @_; my $caller = caller; #warn "registering command '$name/$time' to '$caller'"; - push @{ $command{$name} }, [$time, $cb, $caller]; - $COMMAND{"$name\000"} = List::Util::max map $_->[0], @{ $command{$name} }; + push @{ $COMMAND{$name} }, [$caller, $cb]; } +=item cf::register_extcmd $name => \&callback($pl,$packet); + +Register a callbackf ro execution when the client sends an extcmd packet. + +If the callback returns something, it is sent back as if reply was being +called. + +=cut + sub register_extcmd { my ($name, $cb) = @_; my $caller = caller; #warn "registering extcmd '$name' to '$caller'"; - $extcmd{$name} = [$cb, $caller]; + $EXTCMD{$name} = [$cb, $caller]; } +cf::player->attach ( + on_command => sub { + my ($pl, $name, $params) = @_; + + my $cb = $COMMAND{$name} + or return; + + for my $cmd (@$cb) { + $cmd->[1]->($pl->ob, $params); + } + + cf::override; + }, + on_extcmd => sub { + my ($pl, $buf) = @_; + + my $msg = eval { from_json $buf }; + + if (ref $msg) { + if (my $cb = $EXTCMD{$msg->{msgtype}}) { + if (my %reply = $cb->[0]->($pl, $msg)) { + $pl->ext_reply ($msg->{msgid}, %reply); + } + } + } else { + warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n"; + } + + cf::override; + }, +); + sub register { my ($base, $pkg) = @_; - for my $idx (0 .. $#PLUGIN_EVENT) { - if (my $ref = $pkg->can ("on_$PLUGIN_EVENT[$idx]")) { - #warn "registering $PLUGIN_EVENT[$idx] hook to '$pkg'\n"; - $hook[$idx]{$base} = $ref; - } - } + #TODO } sub load_extension { @@ -315,7 +764,8 @@ . "\n};\n1"; eval $source - or die "$path: $@"; + or die $@ ? "$path: $@\n" + : "extension disabled.\n"; push @exts, $pkg; $ext_pkg{$base} = $pkg; @@ -332,26 +782,25 @@ warn "removing extension $pkg\n"; # remove hooks - for my $idx (0 .. $#PLUGIN_EVENT) { - delete $hook[$idx]{$pkg}; - } + #TODO +# for my $idx (0 .. $#PLUGIN_EVENT) { +# delete $hook[$idx]{$pkg}; +# } # remove commands - for my $name (keys %command) { - my @cb = grep $_->[2] ne $pkg, @{ $command{$name} }; + for my $name (keys %COMMAND) { + my @cb = grep $_->[0] ne $pkg, @{ $COMMAND{$name} }; if (@cb) { - $command{$name} = \@cb; - $COMMAND{"$name\000"} = List::Util::max map $_->[0], @cb; + $COMMAND{$name} = \@cb; } else { - delete $command{$name}; - delete $COMMAND{"$name\000"}; + delete $COMMAND{$name}; } } # remove extcmds - for my $name (grep $extcmd{$_}[1] eq $pkg, keys %extcmd) { - delete $extcmd{$name}; + for my $name (grep $EXTCMD{$_}[1] eq $pkg, keys %EXTCMD) { + delete $EXTCMD{$name}; } if (my $cb = $pkg->can ("unload")) { @@ -365,8 +814,6 @@ } sub load_extensions { - my $LIBDIR = maps_directory "perl"; - for my $ext (<$LIBDIR/*.ext>) { next unless -r $ext; eval { @@ -376,118 +823,6 @@ } } -sub _perl_reload(&) { - my ($msg) = @_; - - $msg->("reloading..."); - - eval { - # 1. cancel all watchers - $_->cancel for Event::all_watchers; - - # 2. unload all extensions - for (@exts) { - $msg->("unloading <$_>"); - unload_extension $_; - } - - # 3. unload all modules loaded from $LIBDIR - while (my ($k, $v) = each %INC) { - next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/; - - $msg->("removing <$k>"); - delete $INC{$k}; - - $k =~ s/\.pm$//; - $k =~ s/\//::/g; - - if (my $cb = $k->can ("unload_module")) { - $cb->(); - } - - Symbol::delete_package $k; - } - - # 4. get rid of safe::, as good as possible - Symbol::delete_package "safe::$_" - for qw(cf::object cf::object::map cf::object::player cf::player cf::map cf::party cf::region); - - # 5. remove register_script_function callbacks - # TODO - - # 6. unload cf.pm "a bit" - delete $INC{"cf.pm"}; - - # don't, removes xs symbols, too, - # and global variables created in xs - #Symbol::delete_package __PACKAGE__; - - # 7. reload cf.pm - $msg->("reloading cf.pm"); - require cf; - }; - $msg->($@) if $@; - - $msg->("reloaded"); -}; - -sub perl_reload() { - _perl_reload { - warn $_[0]; - print "$_[0]\n"; - }; -} - -register_command "perl-reload", 0, sub { - my ($who, $arg) = @_; - - if ($who->flag (FLAG_WIZ)) { - _perl_reload { - warn $_[0]; - $who->message ($_[0]); - }; - } -}; - -############################################################################# -# utility functions - -use JSON::Syck (); # TODO# replace by JSON::PC once working - -sub from_json($) { - $JSON::Syck::ImplicitUnicode = 1; # work around JSON::Syck bugs - JSON::Syck::Load $_[0] -} - -sub to_json($) { - $JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs - JSON::Syck::Dump $_[0] -} - -############################################################################# -# extcmd framework, basically convert ext -# into pkg::->on_extcmd_arg1 (...) while shortcutting a few - -attach_global - on_extcmd => sub { - my ($pl, $buf) = @_; - - my $msg = eval { from_json $buf }; - - if (ref $msg) { - if (my $cb = $extcmd{$msg->{msgtype}}) { - if (my %reply = $cb->[0]->($pl, $msg)) { - $pl->ext_reply ($msg->{msgid}, %reply); - } - } - } else { - warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n"; - } - - cf::override; - }, -; - ############################################################################# # load/save/clean perl data associated with a map @@ -497,55 +832,10 @@ my $path = $map->tmpname; defined $path or return; - unlink "$path.cfperl"; + unlink "$path.pst"; }; -*cf::mapsupport::on_swapin = -*cf::mapsupport::on_load = sub { - my ($map) = @_; - - my $path = $map->tmpname; - $path = $map->path unless defined $path; - - open my $fh, "<:raw", "$path.cfperl" - or return; # no perl data - - my $data = Storable::thaw do { local $/; <$fh> }; - - $data->{version} <= 1 - or return; # too new - - $map->_set_obs ($data->{obs}); -}; - -*cf::mapsupport::on_swapout = sub { - my ($map) = @_; - - my $path = $map->tmpname; - $path = $map->path unless defined $path; - - my $obs = $map->_get_obs; - - if (defined $obs) { - open my $fh, ">:raw", "$path.cfperl" - or die "$path.cfperl: $!"; - - stat $path; - - print $fh Storable::nfreeze { - size => (stat _)[7], - time => (stat _)[9], - version => 1, - obs => $obs, - }; - - chmod SAVE_MODE, "$path.cfperl"; # very racy, but cf-compatible *g* - } else { - unlink "$path.cfperl"; - } -}; - -attach_to_maps prio => -10000, package => cf::mapsupport::; +cf::map->attach (prio => -10000, package => cf::mapsupport::); ############################################################################# # load/save perl data associated with player->ob objects @@ -554,7 +844,8 @@ @_, map all_objects ($_->inv), @_ } -attach_to_players +# TODO: compatibility cruft, remove when no longer needed +cf::player->attach ( on_load => sub { my ($pl, $path) = @_; @@ -566,16 +857,17 @@ } } }, - on_save => sub { - my ($pl, $path) = @_; - - $_->set_ob_key_value (_perl_data => unpack "H*", Storable::nfreeze $_) - for grep %$_, all_objects $pl->ob; - }, -; +); ############################################################################# -# core extensions - in perl + +=head2 CORE EXTENSIONS + +Functions and methods that extend core crossfire objects. + +=head3 cf::player + +=over 4 =item cf::player::exists $login @@ -588,7 +880,27 @@ or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2; } -=item $player->reply ($npc, $msg[, $flags]) +=item $player->ext_reply ($msgid, $msgtype, %msg) + +Sends an ext reply to the player. + +=cut + +sub cf::player::ext_reply($$$%) { + my ($self, $id, %msg) = @_; + + $msg{msgid} = $id; + + $self->send ("ext " . to_json \%msg); +} + +=back + +=head3 cf::object::player + +=over 4 + +=item $player_object->reply ($npc, $msg[, $flags]) Sends a message to the player, as if the npc C<$npc> replied. C<$npc> can be C. Does the right thing when the player is currently in a @@ -598,6 +910,7 @@ # rough implementation of a future "reply" method that works # with dialog boxes. +#TODO: the first argument must go, split into a $npc->reply_to ( method sub cf::object::player::reply($$$;$) { my ($self, $npc, $msg, $flags) = @_; @@ -611,22 +924,137 @@ } } -=item $player->ext_reply ($msgid, $msgtype, %msg) +=item $player_object->may ("access") -Sends an ext reply to the player. +Returns wether the given player is authorized to access resource "access" +(e.g. "command_wizcast"). =cut -sub cf::player::ext_reply($$$%) { - my ($self, $id, %msg) = @_; +sub cf::object::player::may { + my ($self, $access) = @_; - $msg{msgid} = $id; + $self->flag (cf::FLAG_WIZ) || + (ref $cf::CFG{"may_$access"} + ? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}} + : $cf::CFG{"may_$access"}) +} - $self->send ("ext " . to_json \%msg); +=head3 cf::client + +=over 4 + +=item $client->send_drawinfo ($text, $flags) + +Sends a drawinfo packet to the client. Circumvents output buffering so +should not be used under normal circumstances. + +=cut + +sub cf::client::send_drawinfo { + my ($self, $text, $flags) = @_; + + utf8::encode $text; + $self->send_packet (sprintf "drawinfo %d %s", $flags, $text); } -############################################################################# -# map scripting support + +=item $success = $client->query ($flags, "text", \&cb) + +Queues a query to the client, calling the given callback with +the reply text on a reply. flags can be C, +C or C or C<0>. + +Queries can fail, so check the return code. Or don't, as queries will become +reliable at some point in the future. + +=cut + +sub cf::client::query { + my ($self, $flags, $text, $cb) = @_; + + return unless $self->state == ST_PLAYING + || $self->state == ST_SETUP + || $self->state == ST_CUSTOM; + + $self->state (ST_CUSTOM); + + utf8::encode $text; + push @{ $self->{query_queue} }, [(sprintf "query %d %s", $flags, $text), $cb]; + + $self->send_packet ($self->{query_queue}[0][0]) + if @{ $self->{query_queue} } == 1; +} + +cf::client->attach ( + on_reply => sub { + my ($ns, $msg) = @_; + + # this weird shuffling is so that direct followup queries + # get handled first + my $queue = delete $ns->{query_queue}; + + (shift @$queue)->[1]->($msg); + + push @{ $ns->{query_queue} }, @$queue; + + if (@{ $ns->{query_queue} } == @$queue) { + if (@$queue) { + $ns->send_packet ($ns->{query_queue}[0][0]); + } else { + $ns->state (ST_PLAYING) if $ns->state == ST_CUSTOM; + } + } + }, +); + +=item $client->coro (\&cb) + +Create a new coroutine, running the specified callback. The coroutine will +be automatically cancelled when the client gets destroyed (e.g. on logout, +or loss of connection). + +=cut + +sub cf::client::coro { + my ($self, $cb) = @_; + + my $coro; $coro = async { + eval { + $cb->(); + }; + warn $@ if $@; + }; + + $coro->on_destroy (sub { + delete $self->{_coro}{$coro+0}; + }); + + $self->{_coro}{$coro+0} = $coro; + + $coro +} + +cf::client->attach ( + on_destroy => sub { + my ($ns) = @_; + + $_->cancel for values %{ (delete $ns->{_coro}) || {} }; + }, +); + +=back + + +=head2 SAFE SCRIPTING + +Functions that provide a safe environment to compile and execute +snippets of perl code without them endangering the safety of the server +itself. Looping constructs, I/O operators and other built-in functionality +is not available in the safe scripting environment, and the number of +functions and methods that can be called is greatly reduced. + +=cut our $safe = new Safe "safe"; our $safe_hole = new Safe::Hole; @@ -637,10 +1065,22 @@ # here we export the classes and methods available to script code +=pod + +The following fucntions and emthods are available within a safe environment: + + cf::object contr pay_amount pay_player map + cf::object::player player + cf::player peaceful + cf::map trigger + +=cut + for ( - ["cf::object" => qw(contr pay_amount pay_player)], + ["cf::object" => qw(contr pay_amount pay_player map)], ["cf::object::player" => qw(player)], ["cf::player" => qw(peaceful)], + ["cf::map" => qw(trigger)], ) { no strict 'refs'; my ($pkg, @funs) = @$_; @@ -648,6 +1088,18 @@ for @funs; } +=over 4 + +=item @retval = safe_eval $code, [var => value, ...] + +Compiled and executes the given perl code snippet. additional var/value +pairs result in temporary local (my) scalar variables of the given name +that are available in the code snippet. Example: + + my $five = safe_eval '$first + $second', first => 1, second => 4; + +=cut + sub safe_eval($;@) { my ($code, %vars) = @_; @@ -679,6 +1131,21 @@ wantarray ? @res : $res[0] } +=item cf::register_script_function $function => $cb + +Register a function that can be called from within map/npc scripts. The +function should be reasonably secure and should be put into a package name +like the extension. + +Example: register a function that gets called whenever a map script calls +C, as used by the C extension. + + cf::register_script_function "rent::overview" => sub { + ... + }; + +=cut + sub register_script_function { my ($fun, $cb) = @_; @@ -686,38 +1153,282 @@ *{"safe::$fun"} = $safe_hole->wrap ($cb); } +=back + +=cut + +############################################################################# + +=head2 EXTENSION DATABASE SUPPORT + +Crossfire maintains a very simple database for extension use. It can +currently store anything that can be serialised using Storable, which +excludes objects. + +The parameter C<$family> should best start with the name of the extension +using it, it should be unique. + +=over 4 + +=item $hashref = cf::db_get $family + +Return a hashref for use by the extension C<$family>, which can be +modified. After modifications, you have to call C or +C. + +=item $value = cf::db_get $family => $key + +Returns a single value from the database + +=item cf::db_put $family => $hashref + +Stores the given family hashref into the database. Updates are delayed, if +you want the data to be synced to disk immediately, use C. + +=item cf::db_put $family => $key => $value + +Stores the given C<$value> in the family hash. Updates are delayed, if you +want the data to be synced to disk immediately, use C. + +=item cf::db_dirty + +Marks the database as dirty, to be updated at a later time. + +=item cf::db_sync + +Immediately write the database to disk I. + +=cut + +our $DB; + +{ + my $path = cf::localdir . "/database.pst"; + + sub db_load() { + warn "loading database $path\n";#d# remove later + $DB = stat $path ? Storable::retrieve $path : { }; + } + + my $pid; + + sub db_save() { + warn "saving database $path\n";#d# remove later + waitpid $pid, 0 if $pid; + if (0 == ($pid = fork)) { + $DB->{_meta}{version} = 1; + Storable::nstore $DB, "$path~"; + rename "$path~", $path; + cf::_exit 0 if defined $pid; + } + } + + my $dirty; + + sub db_sync() { + db_save if $dirty; + undef $dirty; + } + + my $idle = Event->idle (min => $TICK * 2.8, max => 10, repeat => 0, data => WF_AUTOCANCEL, cb => sub { + db_sync; + }); + + sub db_dirty() { + $dirty = 1; + $idle->start; + } + + sub db_get($;$) { + @_ >= 2 + ? $DB->{$_[0]}{$_[1]} + : ($DB->{$_[0]} ||= { }) + } + + sub db_put($$;$) { + if (@_ >= 3) { + $DB->{$_[0]}{$_[1]} = $_[2]; + } else { + $DB->{$_[0]} = $_[1]; + } + db_dirty; + } + + cf::global->attach ( + prio => 10000, + on_cleanup => sub { + db_sync; + }, + ); +} + ############################################################################# # the server's main() +sub cfg_load { + open my $fh, "<:utf8", cf::confdir . "/config" + or return; + + local $/; + *CFG = YAML::Syck::Load <$fh>; +} + sub main { + cfg_load; + db_load; + load_extensions; Event::loop; } ############################################################################# # initialisation +sub _perl_reload() { + # can/must only be called in main + if ($Coro::current != $Coro::main) { + warn "can only reload from main coroutine\n"; + return; + } + + warn "reloading..."; + + local $FREEZE = 1; + cf::emergency_save; + + eval { + # if anything goes wrong in here, we should simply crash as we already saved + + # cancel all watchers + for (Event::all_watchers) { + $_->cancel if $_->data & WF_AUTOCANCEL; + } + + # cancel all extension coros + $_->cancel for values %EXT_CORO; + %EXT_CORO = (); + + # unload all extensions + for (@exts) { + warn "unloading <$_>"; + unload_extension $_; + } + + # unload all modules loaded from $LIBDIR + while (my ($k, $v) = each %INC) { + next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/; + + warn "removing <$k>"; + delete $INC{$k}; + + $k =~ s/\.pm$//; + $k =~ s/\//::/g; + + if (my $cb = $k->can ("unload_module")) { + $cb->(); + } + + Symbol::delete_package $k; + } + + # sync database to disk + cf::db_sync; + IO::AIO::flush; + + # get rid of safe::, as good as possible + Symbol::delete_package "safe::$_" + for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region); + + # remove register_script_function callbacks + # TODO + + # unload cf.pm "a bit" + delete $INC{"cf.pm"}; + + # don't, removes xs symbols, too, + # and global variables created in xs + #Symbol::delete_package __PACKAGE__; + + # reload cf.pm + warn "reloading cf.pm"; + require cf; + cf::_connect_to_perl; # nominally unnecessary, but cannot hurt + + # load config and database again + cf::cfg_load; + cf::db_load; + + # load extensions + warn "load extensions"; + cf::load_extensions; + + # reattach attachments to objects + warn "reattach"; + _global_reattach; + }; + + if ($@) { + warn $@; + warn "error while reloading, exiting."; + exit 1; + } + + warn "reloaded successfully"; +}; + +sub perl_reload() { + _perl_reload; +} + register "", __PACKAGE__; -unshift @INC, $LIBDIR; +register_command "perl-reload" => sub { + my ($who, $arg) = @_; -load_extensions; + if ($who->flag (FLAG_WIZ)) { + $who->message ("reloading..."); + _perl_reload; + } +}; + +unshift @INC, $LIBDIR; $TICK_WATCHER = Event->timer ( - prio => 1, - at => $NEXT_TICK || 1, - cb => sub { - cf::server_tick; # one server iteration + reentrant => 0, + prio => 0, + at => $NEXT_TICK || $TICK, + data => WF_AUTOCANCEL, + cb => sub { + unless ($FREEZE) { + cf::server_tick; # one server iteration + $RUNTIME += $TICK; + } - my $NOW = Event::time; $NEXT_TICK += $TICK; - # if we are delayed by four ticks, skip them all - $NEXT_TICK = $NOW if $NOW >= $NEXT_TICK + $TICK * 4; + # if we are delayed by four ticks or more, skip them all + $NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4; $TICK_WATCHER->at ($NEXT_TICK); $TICK_WATCHER->start; }, ); +IO::AIO::max_poll_time $TICK * 0.2; + +Event->io (fd => IO::AIO::poll_fileno, + poll => 'r', + prio => 5, + data => WF_AUTOCANCEL, + cb => \&IO::AIO::poll_cb); + +# we must not ever block the main coroutine +$Coro::idle = sub { + #Carp::cluck "FATAL: Coro::idle was called, major BUG\n";#d# + warn "FATAL: Coro::idle was called, major BUG\n"; + (Coro::unblock_sub { + Event::one_event; + })->(); +}; + 1