git.oblomov.eu Git - ikiwiki/blob - IkiWiki/Plugin/inline.pm

   1 #!/usr/bin/perl
   2 # Page inlining and blogging.
   3 package IkiWiki::Plugin::inline;
   4
   5 use warnings;
   6 use strict;
   7 use Encode;
   8 use IkiWiki 3.00;
   9 use URI;
  10
  11 my %knownfeeds;
  12 my %page_numfeeds;
  13 my @inline;
  14 my $nested=0;
  15
  16 sub import {
  17         hook(type => "getopt", id => "inline", call => \&getopt);
  18         hook(type => "getsetup", id => "inline", call => \&getsetup);
  19         hook(type => "checkconfig", id => "inline", call => \&checkconfig);
  20         hook(type => "sessioncgi", id => "inline", call => \&sessioncgi);
  21         hook(type => "preprocess", id => "inline",
  22                 call => \&IkiWiki::preprocess_inline);
  23         hook(type => "pagetemplate", id => "inline",
  24                 call => \&IkiWiki::pagetemplate_inline);
  25         hook(type => "format", id => "inline", call => \&format, first => 1);
  26         # Hook to change to do pinging since it's called late.
  27         # This ensures each page only pings once and prevents slow
  28         # pings interrupting page builds.
  29         hook(type => "change", id => "inline", call => \&IkiWiki::pingurl);
  30 }
  31
  32 sub getopt () {
  33         eval q{use Getopt::Long};
  34         error($@) if $@;
  35         Getopt::Long::Configure('pass_through');
  36         GetOptions(
  37                 "rss!" => \$config{rss},
  38                 "atom!" => \$config{atom},
  39                 "allowrss!" => \$config{allowrss},
  40                 "allowatom!" => \$config{allowatom},
  41                 "pingurl=s" => sub {
  42                         push @{$config{pingurl}}, $_[1];
  43                 },
  44         );
  45 }
  46
  47 sub getsetup () {
  48         return
  49                 plugin => {
  50                         safe => 1,
  51                         rebuild => undef,
  52                         section => "core",
  53                 },
  54                 rss => {
  55                         type => "boolean",
  56                         example => 0,
  57                         description => "enable rss feeds by default?",
  58                         safe => 1,
  59                         rebuild => 1,
  60                 },
  61                 atom => {
  62                         type => "boolean",
  63                         example => 0,
  64                         description => "enable atom feeds by default?",
  65                         safe => 1,
  66                         rebuild => 1,
  67                 },
  68                 allowrss => {
  69                         type => "boolean",
  70                         example => 0,
  71                         description => "allow rss feeds to be used?",
  72                         safe => 1,
  73                         rebuild => 1,
  74                 },
  75                 allowatom => {
  76                         type => "boolean",
  77                         example => 0,
  78                         description => "allow atom feeds to be used?",
  79                         safe => 1,
  80                         rebuild => 1,
  81                 },
  82                 pingurl => {
  83                         type => "string",
  84                         example => "http://rpc.technorati.com/rpc/ping",
  85                         description => "urls to ping (using XML-RPC) on feed update",
  86                         safe => 1,
  87                         rebuild => 0,
  88                 },
  89                 feed_desc_fmt => {
  90                         type => "string",
  91                         example => '%1$s\'s %2$s',
  92                         description => "format string for the default feed description, using the wiki name and page title as parameters",
  93                         safe => 0,
  94                         rebuild => 1,
  95                 }
  96 }
  97
  98 sub checkconfig () {
  99         if (($config{rss} || $config{atom}) && ! length $config{url}) {
 100                 error(gettext("Must specify url to wiki with --url when using --rss or --atom"));
 101         }
 102         if ($config{rss}) {
 103                 push @{$config{wiki_file_prune_regexps}}, qr/\.rss$/;
 104         }
 105         if ($config{atom}) {
 106                 push @{$config{wiki_file_prune_regexps}}, qr/\.atom$/;
 107         }
 108         if (! exists $config{pingurl}) {
 109                 $config{pingurl}=[];
 110         }
 111 }
 112
 113 sub format (@) {
 114         my %params=@_;
 115
 116         # Fill in the inline content generated earlier. This is actually an
 117         # optimisation.
 118         $params{content}=~s{<div class="inline" id="([^"]+)"></div>}{
 119                 delete @inline[$1,]
 120         }eg;
 121         return $params{content};
 122 }
 123
 124 sub sessioncgi ($$) {
 125         my $q=shift;
 126         my $session=shift;
 127
 128         if ($q->param('do') eq 'blog') {
 129                 my $page=titlepage(decode_utf8($q->param('title')));
 130                 $page=~s/(\/)/"__".ord($1)."__"/eg; # don't create subdirs
 131                 # if the page already exists, munge it to be unique
 132                 my $from=$q->param('from');
 133                 my $add="";
 134                 while (exists $IkiWiki::pagecase{lc($from."/".$page.$add)}) {
 135                         $add=1 unless length $add;
 136                         $add++;
 137                 }
 138                 $q->param('page', "/$from/$page$add");
 139                 # now go create the page
 140                 $q->param('do', 'create');
 141                 # make sure the editpage plugin is loaded
 142                 if (IkiWiki->can("cgi_editpage")) {
 143                         IkiWiki::cgi_editpage($q, $session);
 144                 }
 145                 else {
 146                         error(gettext("page editing not allowed"));
 147                 }
 148                 exit;
 149         }
 150 }
 151
 152 # Back to ikiwiki namespace for the rest, this code is very much
 153 # internal to ikiwiki even though it's separated into a plugin.
 154 package IkiWiki;
 155
 156 my %toping;
 157 my %feedlinks;
 158
 159 sub preprocess_inline (@) {
 160         my %params=@_;
 161
 162         if (! exists $params{pages} && ! exists $params{pagenames}) {
 163                 error gettext("missing pages parameter");
 164         }
 165         my $raw=yesno($params{raw});
 166         my $archive=yesno($params{archive});
 167         my $rss=(($config{rss} || $config{allowrss}) && exists $params{rss}) ? yesno($params{rss}) : $config{rss};
 168         my $atom=(($config{atom} || $config{allowatom}) && exists $params{atom}) ? yesno($params{atom}) : $config{atom};
 169         my $quick=exists $params{quick} ? yesno($params{quick}) : 0;
 170         my $feeds=exists $params{feeds} ? yesno($params{feeds}) : !$quick && ! $raw;
 171         my $emptyfeeds=exists $params{emptyfeeds} ? yesno($params{emptyfeeds}) : 1;
 172         my $feedonly=yesno($params{feedonly});
 173
 174         # where to put the feed links: head (1), body (2), both (3)
 175         my $feedlinkloc = 3;
 176         if (exists $params{feedlinks}) {
 177                 if ($params{feedlinks} eq 'both') {
 178                         $feedlinkloc = 3;
 179                 } elsif ($params{feedlinks} eq 'body') {
 180                         $feedlinkloc = 2;
 181                 } elsif ($params{feedlinks} eq 'head') {
 182                         $feedlinkloc = 1;
 183                 } elsif ($params{feedlinks} eq 'none') {
 184                         $feedlinkloc = 0;
 185                 } else {
 186                         print STDERR sprintf(gettext("warning: unknown feedlinks location %s"),
 187                                 $params{feedlinks})."\n";
 188                 }
 189         }
 190
 191         if (! exists $params{show} && ! $archive) {
 192                 $params{show}=10;
 193         }
 194         if (! exists $params{feedshow} && exists $params{show}) {
 195                 $params{feedshow}=$params{show};
 196         }
 197
 198         my ($page, $desc, $feedtitle);
 199         $page = $params{page};
 200         if ($pagestate{$page}{meta} && $pagestate{$page}{meta}{title}) {
 201                 $feedtitle = $pagestate{$page}{meta}{title};
 202         } else {
 203                 $feedtitle = pagetitle(basename($page));
 204         }
 205         if (exists $params{description}) {
 206                 $desc = $params{description}
 207         } elsif ($pagestate{$page}{meta} && $pagestate{$page}{meta}{description}) {
 208                 $desc = $pagestate{$page}{meta}{description};
 209         } else {
 210                 if ($page =~ m!^/?index(?:$|\.)!) {
 211                         $desc = $config{wikiname};
 212                 } else {
 213                         my $descfmt = defined $config{feed_desc_fmt} ? $config{feed_desc_fmt} : '%1$s\'s %2$s';
 214                         $desc = sprintf($descfmt, $config{wikiname}, $feedtitle);
 215                 }
 216         }
 217         my $actions=yesno($params{actions});
 218         if (exists $params{template}) {
 219                 $params{template}=~s/[^-_a-zA-Z0-9]+//g;
 220         }
 221         else {
 222                 $params{template} = $archive ? "archivepage" : "inlinepage";
 223         }
 224
 225         my @list;
 226
 227         if (exists $params{pagenames}) {
 228                 foreach my $p (qw(sort pages)) {
 229                         if (exists $params{$p}) {
 230                                 error sprintf(gettext("the %s and %s parameters cannot be used together"),
 231                                         "pagenames", $p);
 232                         }
 233                 }
 234
 235                 @list = map { bestlink($params{page}, $_) }
 236                         split ' ', $params{pagenames};
 237
 238                 if (yesno($params{reverse})) {
 239                         @list=reverse(@list);
 240                 }
 241
 242                 foreach my $p (@list) {
 243                         add_depends($params{page}, $p, deptype($quick ? "presence" : "content"));
 244                 }
 245         }
 246         else {
 247                 my $num=0;
 248                 if ($params{show}) {
 249                         $num=$params{show};
 250                 }
 251                 if ($params{feedshow} && $num < $params{feedshow} && $num > 0) {
 252                         $num=$params{feedshow};
 253                 }
 254                 if ($params{skip} && $num) {
 255                         $num+=$params{skip};
 256                 }
 257
 258                 @list = pagespec_match_list($params{page}, $params{pages},
 259                         deptype => deptype($quick ? "presence" : "content"),
 260                         filter => sub { $_[0] eq $params{page} },
 261                         sort => exists $params{sort} ? $params{sort} : "age",
 262                         reverse => yesno($params{reverse}),
 263                         ($num ? (num => $num) : ()),
 264                 );
 265         }
 266
 267         if (exists $params{skip}) {
 268                 @list=@list[$params{skip} .. $#list];
 269         }
 270
 271         my @feedlist;
 272         if ($feeds) {
 273                 if (exists $params{feedshow} &&
 274                     $params{feedshow} && @list > $params{feedshow}) {
 275                         @feedlist=@list[0..$params{feedshow} - 1];
 276                 }
 277                 else {
 278                         @feedlist=@list;
 279                 }
 280         }
 281
 282         if ($params{show} && @list > $params{show}) {
 283                 @list=@list[0..$params{show} - 1];
 284         }
 285
 286         if ($feeds && exists $params{feedpages}) {
 287                 @feedlist = pagespec_match_list(
 288                         $params{page}, "($params{pages}) and ($params{feedpages})",
 289                         deptype => deptype($quick ? "presence" : "content"),
 290                         list => \@feedlist,
 291                 );
 292         }
 293
 294         my ($feedbase, $feednum);
 295         if ($feeds) {
 296                 # Ensure that multiple feeds on a page go to unique files.
 297
 298                 # Feedfile can lead to conflicts if usedirs is not enabled,
 299                 # so avoid supporting it in that case.
 300                 delete $params{feedfile} if ! $config{usedirs};
 301                 # Tight limits on legal feedfiles, to avoid security issues
 302                 # and conflicts.
 303                 if (defined $params{feedfile}) {
 304                         if ($params{feedfile} =~ /\// ||
 305                             $params{feedfile} !~ /$config{wiki_file_regexp}/) {
 306                                 error("illegal feedfile");
 307                         }
 308                         $params{feedfile}=possibly_foolish_untaint($params{feedfile});
 309                 }
 310                 $feedbase=targetpage($params{page}, "", $params{feedfile});
 311
 312                 my $feedid=join("\0", $feedbase, map { $_."\0".$params{$_} } sort keys %params);
 313                 if (exists $knownfeeds{$feedid}) {
 314                         $feednum=$knownfeeds{$feedid};
 315                 }
 316                 else {
 317                         if (exists $page_numfeeds{$params{destpage}}{$feedbase}) {
 318                                 if ($feeds) {
 319                                         $feednum=$knownfeeds{$feedid}=++$page_numfeeds{$params{destpage}}{$feedbase};
 320                                 }
 321                         }
 322                         else {
 323                                 $feednum=$knownfeeds{$feedid}="";
 324                                 if ($feeds) {
 325                                         $page_numfeeds{$params{destpage}}{$feedbase}=1;
 326                                 }
 327                         }
 328                 }
 329         }
 330
 331         my ($rssurl, $atomurl, $rssdesc, $atomdesc);
 332         if ($feeds) {
 333                 if ($rss) {
 334                         $rssurl=abs2rel($feedbase."rss".$feednum, dirname(htmlpage($params{destpage})));
 335                         $rssdesc = gettext("%s (RSS feed)", $desc);
 336                 }
 337                 if ($atom) {
 338                         $atomurl=abs2rel($feedbase."atom".$feednum, dirname(htmlpage($params{destpage})));
 339                         $atomdesc = gettext("%s (Atom feed)", $desc);
 340                 }
 341         }
 342
 343         my $ret="";
 344
 345         if (length $config{cgiurl} && ! $params{preview} && (exists $params{rootpage} ||
 346             (exists $params{postform} && yesno($params{postform}))) &&
 347             IkiWiki->can("cgi_editpage")) {
 348                 # Add a blog post form, with feed buttons.
 349                 my $formtemplate=template_depends("blogpost.tmpl", $params{page}, blind_cache => 1);
 350                 $formtemplate->param(cgiurl => IkiWiki::cgiurl());
 351                 $formtemplate->param(rootpage => rootpage(%params));
 352                 if ($feeds) {
 353                         if ($rss) {
 354                                 $formtemplate->param(rssurl => $rssurl);
 355                                 $formtemplate->param(rssdesc => $rssdesc);
 356                         }
 357                         if ($atom) {
 358                                 $formtemplate->param(atomurl => $atomurl);
 359                                 $formtemplate->param(atomdesc => $atomdesc);
 360                         }
 361                 }
 362                 if (exists $params{postformtext}) {
 363                         $formtemplate->param(postformtext =>
 364                                 $params{postformtext});
 365                 }
 366                 else {
 367                         $formtemplate->param(postformtext =>
 368                                 gettext("Add a new post titled:"));
 369                 }
 370                 $ret.=$formtemplate->output;
 371
 372                 # The post form includes the feed buttons, so
 373                 # emptyfeeds cannot be hidden.
 374                 $emptyfeeds=1;
 375         }
 376         elsif ($feeds && !$params{preview} && ($emptyfeeds || @feedlist)
 377                 && ($feedlinkloc & 2)) {
 378                 # Add feed buttons.
 379                 my $linktemplate=template_depends("feedlink.tmpl", $params{page}, blind_cache => 1);
 380                 if ($rss) {
 381                         $linktemplate->param(rssurl => $rssurl);
 382                         $linktemplate->param(rssdesc => $rssdesc);
 383                 }
 384                 if ($atom) {
 385                         $linktemplate->param(atomurl => $atomurl);
 386                         $linktemplate->param(atomdesc => $atomdesc);
 387                 }
 388                 $ret.=$linktemplate->output;
 389         }
 390
 391         if (! $feedonly) {
 392                 my $template;
 393                 if (! $raw) {
 394                         # cannot use wiki pages as templates; template not sanitized due to
 395                         # format hook hack
 396                         eval {
 397                                 $template=template_depends($params{template}.".tmpl", $params{page},
 398                                         blind_cache => 1);
 399                         };
 400                         if ($@) {
 401                                 error sprintf(gettext("failed to process template %s"), $params{template}.".tmpl").": $@";
 402                         }
 403                 }
 404                 my $needcontent=$raw || (!($archive && $quick) && $template->query(name => 'content'));
 405
 406                 foreach my $page (@list) {
 407                         my $file = $pagesources{$page};
 408                         my $type = pagetype($file);
 409                         if (! $raw) {
 410                                 if ($needcontent) {
 411                                         # Get the content before populating the
 412                                         # template, since getting the content uses
 413                                         # the same template if inlines are nested.
 414                                         my $content=get_inline_content($page, $params{destpage});
 415                                         $template->param(content => $content);
 416                                 }
 417                                 $template->param(pageurl => urlto($page, $params{destpage}));
 418                                 $template->param(inlinepage => $page);
 419                                 $template->param(title => pagetitle(basename($page)));
 420                                 $template->param(ctime => displaytime($pagectime{$page}, $params{timeformat}, 1));
 421                                 $template->param(mtime => displaytime($pagemtime{$page}, $params{timeformat}));
 422                                 $template->param(first => 1) if $page eq $list[0];
 423                                 $template->param(last => 1) if $page eq $list[$#list];
 424                                 $template->param(html5 => $config{html5});
 425
 426                                 if ($actions) {
 427                                         my $file = $pagesources{$page};
 428                                         my $type = pagetype($file);
 429                                         if ($config{discussion}) {
 430                                                 if ($page !~ /.*\/\Q$config{discussionpage}\E$/i &&
 431                                                     (length $config{cgiurl} ||
 432                                                      exists $pagesources{$page."/".lc($config{discussionpage})})) {
 433                                                         $template->param(have_actions => 1);
 434                                                         $template->param(discussionlink =>
 435                                                                 htmllink($page,
 436                                                                         $params{destpage},
 437                                                                         $config{discussionpage},
 438                                                                         noimageinline => 1,
 439                                                                         forcesubpage => 1));
 440                                                 }
 441                                         }
 442                                         if (length $config{cgiurl} &&
 443                                             defined $type &&
 444                                             IkiWiki->can("cgi_editpage")) {
 445                                                 $template->param(have_actions => 1);
 446                                                 $template->param(editurl => cgiurl(do => "edit", page => $page));
 447
 448                                         }
 449                                 }
 450
 451                                 run_hooks(pagetemplate => sub {
 452                                         shift->(page => $page, destpage => $params{destpage},
 453                                                 template => $template,);
 454                                 });
 455
 456                                 $ret.=$template->output;
 457                                 $template->clear_params;
 458                         }
 459                         else {
 460                                 if (defined $type) {
 461                                         $ret.="\n".
 462                                               linkify($page, $params{destpage},
 463                                               preprocess($page, $params{destpage},
 464                                               filter($page, $params{destpage},
 465                                               readfile(srcfile($file)))));
 466                                 }
 467                                 else {
 468                                         $ret.="\n".
 469                                               readfile(srcfile($file));
 470                                 }
 471                         }
 472                 }
 473         }
 474
 475         if ($feeds && ($emptyfeeds || @feedlist)) {
 476                 if ($rss) {
 477                         my $rssp=$feedbase."rss".$feednum;
 478                         will_render($params{destpage}, $rssp);
 479                         if (! $params{preview}) {
 480                                 writefile($rssp, $config{destdir},
 481                                         genfeed("rss",
 482                                                 $config{url}."/".$rssp, $feedtitle, $desc, $params{guid}, $params{page}, @feedlist));
 483                                 $toping{$params{destpage}}=1 unless $config{rebuild};
 484                                 $feedlinks{$params{destpage}}.=qq{<link rel="alternate" type="application/rss+xml" title="$rssdesc" href="$rssurl" />} if ($feedlinkloc & 1);
 485                         }
 486                 }
 487                 if ($atom) {
 488                         my $atomp=$feedbase."atom".$feednum;
 489                         will_render($params{destpage}, $atomp);
 490                         if (! $params{preview}) {
 491                                 writefile($atomp, $config{destdir},
 492                                         genfeed("atom", $config{url}."/".$atomp, $feedtitle, $desc, $params{guid}, $params{page}, @feedlist));
 493                                 $toping{$params{destpage}}=1 unless $config{rebuild};
 494                                 $feedlinks{$params{destpage}}.=qq{<link rel="alternate" type="application/atom+xml" title="$atomdesc" href="$atomurl" />} if ($feedlinkloc & 1);
 495                         }
 496                 }
 497         }
 498
 499         clear_inline_content_cache();
 500
 501         return $ret if $raw || $nested;
 502         push @inline, $ret;
 503         return "<div class=\"inline\" id=\"$#inline\"></div>\n\n";
 504 }
 505
 506 sub pagetemplate_inline (@) {
 507         my %params=@_;
 508         my $page=$params{page};
 509         my $template=$params{template};
 510
 511         $template->param(feedlinks => $feedlinks{$page})
 512                 if exists $feedlinks{$page} && $template->query(name => "feedlinks");
 513 }
 514
 515 {
 516 my %inline_content;
 517 my $cached_destpage="";
 518
 519 sub get_inline_content ($$) {
 520         my $page=shift;
 521         my $destpage=shift;
 522
 523         if (exists $inline_content{$page} && $cached_destpage eq $destpage) {
 524                 return $inline_content{$page};
 525         }
 526
 527         my $file=$pagesources{$page};
 528         my $type=pagetype($file);
 529         my $ret="";
 530         if (defined $type) {
 531                 $nested++;
 532                 $ret=htmlize($page, $destpage, $type,
 533                        linkify($page, $destpage,
 534                        preprocess($page, $destpage,
 535                        filter($page, $destpage,
 536                        readfile(srcfile($file))))));
 537                 $nested--;
 538                 if (isinternal($page)) {
 539                         # make inlined text of internal pages searchable
 540                         run_hooks(indexhtml => sub {
 541                                 shift->(page => $page, destpage => $page,
 542                                         content => $ret);
 543                         });
 544                 }
 545         }
 546
 547         if ($cached_destpage ne $destpage) {
 548                 clear_inline_content_cache();
 549                 $cached_destpage=$destpage;
 550         }
 551         return $inline_content{$page}=$ret;
 552 }
 553
 554 sub clear_inline_content_cache () {
 555         %inline_content=();
 556 }
 557
 558 }
 559
 560 sub date_822 ($) {
 561         my $time=shift;
 562
 563         my $lc_time=POSIX::setlocale(&POSIX::LC_TIME);
 564         POSIX::setlocale(&POSIX::LC_TIME, "C");
 565         my $ret=POSIX::strftime("%a, %d %b %Y %H:%M:%S %z", localtime($time));
 566         POSIX::setlocale(&POSIX::LC_TIME, $lc_time);
 567         return $ret;
 568 }
 569
 570 sub absolute_urls ($$) {
 571         # needed because rss sucks
 572         my $html=shift;
 573         my $baseurl=shift;
 574
 575         my $url=$baseurl;
 576         $url=~s/[^\/]+$//;
 577         my $urltop; # calculated if needed
 578
 579         my $ret="";
 580
 581         eval q{use HTML::Parser; use HTML::Tagset};
 582         die $@ if $@;
 583         my $p = HTML::Parser->new(api_version => 3);
 584         $p->handler(default => sub { $ret.=join("", @_) }, "text");
 585         $p->handler(start => sub {
 586                 my ($tagname, $pos, $text) = @_;
 587                 if (ref $HTML::Tagset::linkElements{$tagname}) {
 588                         while (4 <= @$pos) {
 589                                 # use attribute sets from right to left
 590                                 # to avoid invalidating the offsets
 591                                 # when replacing the values
 592                                 my ($k_offset, $k_len, $v_offset, $v_len) =
 593                                         splice(@$pos, -4);
 594                                 my $attrname = lc(substr($text, $k_offset, $k_len));
 595                                 next unless grep { $_ eq $attrname } @{$HTML::Tagset::linkElements{$tagname}};
 596                                 next unless $v_offset; # 0 v_offset means no value
 597                                 my $v = substr($text, $v_offset, $v_len);
 598                                 $v =~ s/^([\'\"])(.*)\1$/$2/;
 599                                 if ($v=~/^#/) {
 600                                         $v=$baseurl.$v; # anchor
 601                                 }
 602                                 elsif ($v=~/^(?!\w+:)[^\/]/) {
 603                                         $v=$url.$v; # relative url
 604                                 }
 605                                 elsif ($v=~/^\//) {
 606                                         if (! defined $urltop) {
 607                                                 # what is the non path part of the url?
 608                                                 my $top_uri = URI->new($url);
 609                                                 $top_uri->path_query(""); # reset the path
 610                                                 $urltop = $top_uri->as_string;
 611                                         }
 612                                         $v=$urltop.$v; # url relative to top of site
 613                                 }
 614                                 $v =~ s/\"/&quot;/g; # since we quote with ""
 615                                 substr($text, $v_offset, $v_len) = qq("$v");
 616                         }
 617                 }
 618                 $ret.=$text;
 619         }, "tagname, tokenpos, text");
 620         $p->parse($html);
 621         $p->eof;
 622
 623         return $ret;
 624 }
 625
 626 sub genfeed ($$$$$@) {
 627         my $feedtype=shift;
 628         my $feedurl=shift;
 629         my $feedtitle=shift;
 630         my $feeddesc=shift;
 631         my $guid=shift;
 632         my $page=shift;
 633         my @pages=@_;
 634
 635         my $url=URI->new(encode_utf8(urlto($page,"",1)));
 636
 637         my $itemtemplate=template_depends($feedtype."item.tmpl", $page, blind_cache => 1);
 638         my $content="";
 639         my $lasttime = 0;
 640         foreach my $p (@pages) {
 641                 my $u=URI->new(encode_utf8(urlto($p, "", 1)));
 642                 my $pcontent = absolute_urls(get_inline_content($p, $page), $url);
 643
 644                 $itemtemplate->param(
 645                         title => pagetitle(basename($p)),
 646                         url => $u,
 647                         permalink => $u,
 648                         cdate_822 => date_822($pagectime{$p}),
 649                         mdate_822 => date_822($pagemtime{$p}),
 650                         cdate_3339 => date_3339($pagectime{$p}),
 651                         mdate_3339 => date_3339($pagemtime{$p}),
 652                 );
 653
 654                 if (exists $pagestate{$p}) {
 655                         if (exists $pagestate{$p}{meta}{guid}) {
 656                                 eval q{use HTML::Entities};
 657                                 $itemtemplate->param(guid => HTML::Entities::encode_numeric($pagestate{$p}{meta}{guid}));
 658                         }
 659
 660                         if (exists $pagestate{$p}{meta}{updated}) {
 661                                 $itemtemplate->param(mdate_822 => date_822($pagestate{$p}{meta}{updated}));
 662                                 $itemtemplate->param(mdate_3339 => date_3339($pagestate{$p}{meta}{updated}));
 663                         }
 664                 }
 665
 666                 if ($itemtemplate->query(name => "enclosure")) {
 667                         my $file=$pagesources{$p};
 668                         my $type=pagetype($file);
 669                         if (defined $type) {
 670                                 $itemtemplate->param(content => $pcontent);
 671                         }
 672                         else {
 673                                 my $size=(srcfile_stat($file))[8];
 674                                 my $mime="unknown";
 675                                 eval q{use File::MimeInfo};
 676                                 if (! $@) {
 677                                         $mime = mimetype($file);
 678                                 }
 679                                 $itemtemplate->param(
 680                                         enclosure => $u,
 681                                         type => $mime,
 682                                         length => $size,
 683                                 );
 684                         }
 685                 }
 686                 else {
 687                         $itemtemplate->param(content => $pcontent);
 688                 }
 689
 690                 run_hooks(pagetemplate => sub {
 691                         shift->(page => $p, destpage => $page,
 692                                 template => $itemtemplate);
 693                 });
 694
 695                 $content.=$itemtemplate->output;
 696                 $itemtemplate->clear_params;
 697
 698                 $lasttime = $pagemtime{$p} if $pagemtime{$p} > $lasttime;
 699         }
 700
 701         my $template=template_depends($feedtype."page.tmpl", $page, blind_cache => 1);
 702         $template->param(
 703                 title => $feedtitle,
 704                 wikiname => $config{wikiname},
 705                 pageurl => $url,
 706                 content => $content,
 707                 feeddesc => $feeddesc,
 708                 guid => $guid,
 709                 feeddate => date_3339($lasttime),
 710                 feedurl => $feedurl,
 711                 version => $IkiWiki::version,
 712         );
 713         run_hooks(pagetemplate => sub {
 714                 shift->(page => $page, destpage => $page,
 715                         template => $template);
 716         });
 717
 718         return $template->output;
 719 }
 720
 721 sub pingurl (@) {
 722         return unless @{$config{pingurl}} && %toping;
 723
 724         eval q{require RPC::XML::Client};
 725         if ($@) {
 726                 debug(gettext("RPC::XML::Client not found, not pinging"));
 727                 return;
 728         }
 729
 730         # daemonize here so slow pings don't slow down wiki updates
 731         defined(my $pid = fork) or error("Can't fork: $!");
 732         return if $pid;
 733         chdir '/';
 734         POSIX::setsid() or error("Can't start a new session: $!");
 735         open STDIN, '/dev/null';
 736         open STDOUT, '>/dev/null';
 737         open STDERR, '>&STDOUT' or error("Can't dup stdout: $!");
 738
 739         # Don't need to keep a lock on the wiki as a daemon.
 740         IkiWiki::unlockwiki();
 741
 742         foreach my $page (keys %toping) {
 743                 my $title=pagetitle(basename($page), 0);
 744                 my $url=urlto($page, "", 1);
 745                 foreach my $pingurl (@{$config{pingurl}}) {
 746                         debug("Pinging $pingurl for $page");
 747                         eval {
 748                                 my $client = RPC::XML::Client->new($pingurl);
 749                                 my $req = RPC::XML::request->new('weblogUpdates.ping',
 750                                         $title, $url);
 751                                 my $res = $client->send_request($req);
 752                                 if (! ref $res) {
 753                                         error("Did not receive response to ping");
 754                                 }
 755                                 my $r=$res->value;
 756                                 if (! exists $r->{flerror} || $r->{flerror}) {
 757                                         error("Ping rejected: ".(exists $r->{message} ? $r->{message} : "[unknown reason]"));
 758                                 }
 759                         };
 760                         if ($@) {
 761                                 error "Ping failed: $@";
 762                         }
 763                 }
 764         }
 765
 766         exit 0; # daemon done
 767 }
 768
 769
 770 sub rootpage (@) {
 771         my %params=@_;
 772
 773         my $rootpage;
 774         if (exists $params{rootpage}) {
 775                 $rootpage=bestlink($params{page}, $params{rootpage});
 776                 if (!length $rootpage) {
 777                         $rootpage=$params{rootpage};
 778                 }
 779         }
 780         else {
 781                 $rootpage=$params{page};
 782         }
 783         return $rootpage;
 784 }
 785
 786 1