summaryrefslogtreecommitdiff
path: root/IkiWiki/CGI.pm
blob: 33e670eacbd7291b6cd1a30092b33f9b80e6bd93 (plain)
  1. #!/usr/bin/perl
  2. use warnings;
  3. use strict;
  4. use IkiWiki;
  5. use IkiWiki::UserInfo;
  6. use open qw{:utf8 :std};
  7. use Encode;
  8. package IkiWiki;
  9. sub printheader ($) { #{{{
  10. my $session=shift;
  11. if ($config{sslcookie}) {
  12. print $session->header(-charset => 'utf-8',
  13. -cookie => $session->cookie(-secure => 1));
  14. } else {
  15. print $session->header(-charset => 'utf-8');
  16. }
  17. } #}}}
  18. sub showform ($$$$) { #{{{
  19. my $form=shift;
  20. my $buttons=shift;
  21. my $session=shift;
  22. my $cgi=shift;
  23. if (exists $hooks{formbuilder}) {
  24. run_hooks(formbuilder => sub {
  25. shift->(form => $form, cgi => $cgi, session => $session,
  26. buttons => $buttons);
  27. });
  28. }
  29. printheader($session);
  30. print misctemplate($form->title, $form->render(submit => $buttons));
  31. }
  32. sub redirect ($$) { #{{{
  33. my $q=shift;
  34. my $url=shift;
  35. if (! $config{w3mmode}) {
  36. print $q->redirect($url);
  37. }
  38. else {
  39. print "Content-type: text/plain\n";
  40. print "W3m-control: GOTO $url\n\n";
  41. }
  42. } #}}}
  43. sub check_canedit ($$$;$) { #{{{
  44. my $page=shift;
  45. my $q=shift;
  46. my $session=shift;
  47. my $nonfatal=shift;
  48. my $canedit;
  49. run_hooks(canedit => sub {
  50. return if defined $canedit;
  51. my $ret=shift->($page, $q, $session);
  52. if (defined $ret && $ret eq "") {
  53. $canedit=1;
  54. }
  55. elsif (defined $ret) {
  56. $canedit=0;
  57. error($ret) unless $nonfatal;
  58. }
  59. });
  60. return $canedit;
  61. } #}}}
  62. sub decode_form_utf8 ($) { #{{{
  63. my $form = shift;
  64. foreach my $f ($form->field) {
  65. next if Encode::is_utf8(scalar $form->field($f));
  66. $form->field(name => $f,
  67. value => decode_utf8($form->field($f)),
  68. force => 1,
  69. );
  70. }
  71. } #}}}
  72. sub cgi_recentchanges ($) { #{{{
  73. my $q=shift;
  74. # Optimisation: building recentchanges means calculating lots of
  75. # links. Memoizing htmllink speeds it up a lot (can't be memoized
  76. # during page builds as the return values may change, but they
  77. # won't here.)
  78. eval q{use Memoize};
  79. error($@) if $@;
  80. memoize("htmllink");
  81. eval q{use Time::Duration};
  82. error($@) if $@;
  83. my $changelog=[rcs_recentchanges(100)];
  84. foreach my $change (@$changelog) {
  85. $change->{when} = concise(ago($change->{when}));
  86. $change->{user} = userlink($change->{user});
  87. my $is_excess = exists $change->{pages}[10]; # limit pages to first 10
  88. delete @{$change->{pages}}[10 .. @{$change->{pages}}] if $is_excess;
  89. $change->{pages} = [
  90. map {
  91. $_->{link} = htmllink("", "", $_->{page},
  92. noimageinline => 1,
  93. linktext => pagetitle($_->{page}));
  94. $_;
  95. } @{$change->{pages}}
  96. ];
  97. push @{$change->{pages}}, { link => '...' } if $is_excess;
  98. }
  99. my $template=template("recentchanges.tmpl");
  100. $template->param(
  101. title => "RecentChanges",
  102. indexlink => indexlink(),
  103. wikiname => $config{wikiname},
  104. changelog => $changelog,
  105. baseurl => baseurl(),
  106. );
  107. run_hooks(pagetemplate => sub {
  108. shift->(page => "", destpage => "", template => $template);
  109. });
  110. print $q->header(-charset => 'utf-8'), $template->output;
  111. } #}}}
  112. # Check if the user is signed in. If not, redirect to the signin form and
  113. # save their place to return to later.
  114. sub needsignin ($$) { #{{{
  115. my $q=shift;
  116. my $session=shift;
  117. if (! defined $session->param("name") ||
  118. ! userinfo_get($session->param("name"), "regdate")) {
  119. if (! defined $session->param("postsignin")) {
  120. $session->param(postsignin => $ENV{QUERY_STRING});
  121. }
  122. cgi_signin($q, $session);
  123. cgi_savesession($session);
  124. exit;
  125. }
  126. } #}}}
  127. sub cgi_signin ($$) { #{{{
  128. my $q=shift;
  129. my $session=shift;
  130. eval q{use CGI::FormBuilder};
  131. error($@) if $@;
  132. my $form = CGI::FormBuilder->new(
  133. title => "signin",
  134. name => "signin",
  135. charset => "utf-8",
  136. method => 'POST',
  137. required => 'NONE',
  138. javascript => 0,
  139. params => $q,
  140. action => $config{cgiurl},
  141. header => 0,
  142. template => {type => 'div'},
  143. stylesheet => baseurl()."style.css",
  144. );
  145. my $buttons=["Login"];
  146. if ($q->param("do") ne "signin" && !$form->submitted) {
  147. $form->text(gettext("You need to log in first."));
  148. }
  149. $form->field(name => "do", type => "hidden", value => "signin",
  150. force => 1);
  151. decode_form_utf8($form);
  152. run_hooks(formbuilder_setup => sub {
  153. shift->(form => $form, cgi => $q, session => $session,
  154. buttons => $buttons);
  155. });
  156. if ($form->submitted) {
  157. $form->validate;
  158. }
  159. showform($form, $buttons, $session, $q);
  160. } #}}}
  161. sub cgi_postsignin ($$) { #{{{
  162. my $q=shift;
  163. my $session=shift;
  164. # Continue with whatever was being done before the signin process.
  165. if (defined $session->param("postsignin")) {
  166. my $postsignin=CGI->new($session->param("postsignin"));
  167. $session->clear("postsignin");
  168. cgi($postsignin, $session);
  169. cgi_savesession($session);
  170. exit;
  171. }
  172. else {
  173. # This can occur, for example, if a user went to the signin
  174. # url via a bookmark.
  175. redirect($q, $config{url});
  176. }
  177. } #}}}
  178. sub cgi_prefs ($$) { #{{{
  179. my $q=shift;
  180. my $session=shift;
  181. needsignin($q, $session);
  182. eval q{use CGI::FormBuilder};
  183. error($@) if $@;
  184. my $form = CGI::FormBuilder->new(
  185. title => "preferences",
  186. name => "preferences",
  187. header => 0,
  188. charset => "utf-8",
  189. method => 'POST',
  190. validate => {
  191. email => 'EMAIL',
  192. },
  193. required => 'NONE',
  194. javascript => 0,
  195. params => $q,
  196. action => $config{cgiurl},
  197. template => {type => 'div'},
  198. stylesheet => baseurl()."style.css",
  199. fieldsets => [
  200. [login => gettext("Login")],
  201. [preferences => gettext("Preferences")],
  202. [admin => gettext("Admin")]
  203. ],
  204. );
  205. my $buttons=["Save Preferences", "Logout", "Cancel"];
  206. decode_form_utf8($form);
  207. run_hooks(formbuilder_setup => sub {
  208. shift->(form => $form, cgi => $q, session => $session,
  209. buttons => $buttons);
  210. });
  211. $form->field(name => "do", type => "hidden");
  212. $form->field(name => "email", size => 50, fieldset => "preferences");
  213. $form->field(name => "subscriptions", size => 50,
  214. fieldset => "preferences",
  215. comment => "(".htmllink("", "", "ikiwiki/PageSpec", noimageinline => 1).")");
  216. $form->field(name => "banned_users", size => 50,
  217. fieldset => "admin");
  218. my $user_name=$session->param("name");
  219. if (! is_admin($user_name)) {
  220. $form->field(name => "banned_users", type => "hidden");
  221. }
  222. if (! $form->submitted) {
  223. $form->field(name => "email", force => 1,
  224. value => userinfo_get($user_name, "email"));
  225. $form->field(name => "subscriptions", force => 1,
  226. value => userinfo_get($user_name, "subscriptions"));
  227. if (is_admin($user_name)) {
  228. $form->field(name => "banned_users", force => 1,
  229. value => join(" ", get_banned_users()));
  230. }
  231. }
  232. if ($form->submitted eq 'Logout') {
  233. $session->delete();
  234. redirect($q, $config{url});
  235. return;
  236. }
  237. elsif ($form->submitted eq 'Cancel') {
  238. redirect($q, $config{url});
  239. return;
  240. }
  241. elsif ($form->submitted eq 'Save Preferences' && $form->validate) {
  242. foreach my $field (qw(email subscriptions)) {
  243. if (defined $form->field($field) && length $form->field($field)) {
  244. userinfo_set($user_name, $field, $form->field($field)) ||
  245. error("failed to set $field");
  246. }
  247. }
  248. if (is_admin($user_name)) {
  249. set_banned_users(grep { ! is_admin($_) }
  250. split(' ',
  251. $form->field("banned_users"))) ||
  252. error("failed saving changes");
  253. }
  254. $form->text(gettext("Preferences saved."));
  255. }
  256. showform($form, $buttons, $session, $q);
  257. } #}}}
  258. sub cgi_editpage ($$) { #{{{
  259. my $q=shift;
  260. my $session=shift;
  261. my @fields=qw(do rcsinfo subpage from page type editcontent comments);
  262. my @buttons=("Save Page", "Preview", "Cancel");
  263. eval q{use CGI::FormBuilder};
  264. error($@) if $@;
  265. my $form = CGI::FormBuilder->new(
  266. title => "editpage",
  267. fields => \@fields,
  268. charset => "utf-8",
  269. method => 'POST',
  270. validate => {
  271. editcontent => '/.+/',
  272. },
  273. required => [qw{editcontent}],
  274. javascript => 0,
  275. params => $q,
  276. action => $config{cgiurl},
  277. header => 0,
  278. table => 0,
  279. template => scalar template_params("editpage.tmpl"),
  280. wikiname => $config{wikiname},
  281. );
  282. decode_form_utf8($form);
  283. run_hooks(formbuilder_setup => sub {
  284. shift->(form => $form, cgi => $q, session => $session,
  285. buttons => \@buttons);
  286. });
  287. # This untaint is safe because titlepage removes any problematic
  288. # characters.
  289. my ($page)=$form->field('page');
  290. $page=titlepage(possibly_foolish_untaint($page));
  291. if (! defined $page || ! length $page ||
  292. file_pruned($page, $config{srcdir}) || $page=~/^\//) {
  293. error("bad page name");
  294. }
  295. my $from;
  296. if (defined $form->field('from')) {
  297. ($from)=$form->field('from')=~/$config{wiki_file_regexp}/;
  298. }
  299. my $file;
  300. my $type;
  301. if (exists $pagesources{$page} && $form->field("do") ne "create") {
  302. $file=$pagesources{$page};
  303. $type=pagetype($file);
  304. if (! defined $type) {
  305. error(sprintf(gettext("%s is not an editable page"), $page));
  306. }
  307. if (! $form->submitted) {
  308. $form->field(name => "rcsinfo",
  309. value => rcs_prepedit($file), force => 1);
  310. }
  311. }
  312. else {
  313. $type=$form->param('type');
  314. if (defined $type && length $type && $hooks{htmlize}{$type}) {
  315. $type=possibly_foolish_untaint($type);
  316. }
  317. elsif (defined $from) {
  318. # favor the type of linking page
  319. $type=pagetype($pagesources{$from});
  320. }
  321. $type=$config{default_pageext} unless defined $type;
  322. $file=$page.".".$type;
  323. if (! $form->submitted) {
  324. $form->field(name => "rcsinfo", value => "", force => 1);
  325. }
  326. }
  327. $form->field(name => "do", type => 'hidden');
  328. $form->field(name => "from", type => 'hidden');
  329. $form->field(name => "rcsinfo", type => 'hidden');
  330. $form->field(name => "subpage", type => 'hidden');
  331. $form->field(name => "page", value => pagetitle($page, 1), force => 1);
  332. $form->field(name => "type", value => $type, force => 1);
  333. $form->field(name => "comments", type => "text", size => 80);
  334. $form->field(name => "editcontent", type => "textarea", rows => 20,
  335. cols => 80);
  336. $form->tmpl_param("can_commit", $config{rcs});
  337. $form->tmpl_param("indexlink", indexlink());
  338. $form->tmpl_param("helponformattinglink",
  339. htmllink("", "", "ikiwiki/formatting",
  340. noimageinline => 1,
  341. linktext => "FormattingHelp"));
  342. $form->tmpl_param("baseurl", baseurl());
  343. if ($form->submitted eq "Cancel") {
  344. if ($form->field("do") eq "create" && defined $from) {
  345. redirect($q, "$config{url}/".htmlpage($from));
  346. }
  347. elsif ($form->field("do") eq "create") {
  348. redirect($q, $config{url});
  349. }
  350. else {
  351. redirect($q, "$config{url}/".htmlpage($page));
  352. }
  353. return;
  354. }
  355. elsif ($form->submitted eq "Preview") {
  356. my $content=$form->field('editcontent');
  357. run_hooks(editcontent => sub {
  358. $content=shift->(
  359. content => $content,
  360. page => $page,
  361. cgi => $q,
  362. session => $session,
  363. );
  364. });
  365. $form->tmpl_param("page_preview",
  366. htmlize($page, $type,
  367. linkify($page, "",
  368. preprocess($page, $page,
  369. filter($page, $page, $content), 0, 1))));
  370. }
  371. elsif ($form->submitted eq "Save Page") {
  372. $form->tmpl_param("page_preview", "");
  373. }
  374. $form->tmpl_param("page_conflict", "");
  375. if ($form->submitted ne "Save Page" || ! $form->validate) {
  376. if ($form->field("do") eq "create") {
  377. my @page_locs;
  378. my $best_loc;
  379. if (! defined $from || ! length $from ||
  380. $from ne $form->field('from') ||
  381. file_pruned($from, $config{srcdir}) ||
  382. $from=~/^\// ||
  383. $form->submitted eq "Preview") {
  384. @page_locs=$best_loc=$page;
  385. }
  386. else {
  387. my $dir=$from."/";
  388. $dir=~s![^/]+/+$!!;
  389. if ((defined $form->field('subpage') && length $form->field('subpage')) ||
  390. $page eq gettext('discussion')) {
  391. $best_loc="$from/$page";
  392. }
  393. else {
  394. $best_loc=$dir.$page;
  395. }
  396. push @page_locs, $dir.$page;
  397. push @page_locs, "$from/$page";
  398. while (length $dir) {
  399. $dir=~s![^/]+/+$!!;
  400. push @page_locs, $dir.$page;
  401. }
  402. }
  403. push @page_locs, "$config{userdir}/$page"
  404. if length $config{userdir};
  405. @page_locs = grep {
  406. ! exists $pagecase{lc $_}
  407. } @page_locs;
  408. if (! @page_locs) {
  409. # hmm, someone else made the page in the
  410. # meantime?
  411. redirect($q, "$config{url}/".htmlpage($page));
  412. return;
  413. }
  414. my @editable_locs = grep {
  415. check_canedit($_, $q, $session, 1)
  416. } @page_locs;
  417. if (! @editable_locs) {
  418. # let it throw an error this time
  419. map { check_canedit($_, $q, $session) } @page_locs;
  420. }
  421. my @page_types;
  422. if (exists $hooks{htmlize}) {
  423. @page_types=keys %{$hooks{htmlize}};
  424. }
  425. $form->tmpl_param("page_select", 1);
  426. $form->field(name => "page", type => 'select',
  427. options => [ map { pagetitle($_, 1) } @editable_locs ],
  428. value => pagetitle($best_loc, 1));
  429. $form->field(name => "type", type => 'select',
  430. options => \@page_types);
  431. $form->title(sprintf(gettext("creating %s"), pagetitle($page)));
  432. }
  433. elsif ($form->field("do") eq "edit") {
  434. check_canedit($page, $q, $session);
  435. if (! defined $form->field('editcontent') ||
  436. ! length $form->field('editcontent')) {
  437. my $content="";
  438. if (exists $pagesources{$page}) {
  439. $content=readfile(srcfile($pagesources{$page}));
  440. $content=~s/\n/\r\n/g;
  441. }
  442. $form->field(name => "editcontent", value => $content,
  443. force => 1);
  444. }
  445. $form->tmpl_param("page_select", 0);
  446. $form->field(name => "page", type => 'hidden');
  447. $form->field(name => "type", type => 'hidden');
  448. $form->title(sprintf(gettext("editing %s"), pagetitle($page)));
  449. }
  450. showform($form, \@buttons, $session, $q);
  451. saveindex();
  452. }
  453. else {
  454. # save page
  455. check_canedit($page, $q, $session);
  456. my $exists=-e "$config{srcdir}/$file";
  457. if ($form->field("do") ne "create" && ! $exists &&
  458. ! eval { srcfile($file) }) {
  459. $form->tmpl_param("page_gone", 1);
  460. $form->field(name => "do", value => "create", force => 1);
  461. $form->tmpl_param("page_select", 0);
  462. $form->field(name => "page", type => 'hidden');
  463. $form->field(name => "type", type => 'hidden');
  464. $form->title(sprintf(gettext("editing %s"), $page));
  465. showform($form, \@buttons, $session, $q);
  466. return;
  467. }
  468. elsif ($form->field("do") eq "create" && $exists) {
  469. $form->tmpl_param("creation_conflict", 1);
  470. $form->field(name => "do", value => "edit", force => 1);
  471. $form->tmpl_param("page_select", 0);
  472. $form->field(name => "page", type => 'hidden');
  473. $form->field(name => "type", type => 'hidden');
  474. $form->title(sprintf(gettext("editing %s"), $page));
  475. $form->field("editcontent",
  476. value => readfile("$config{srcdir}/$file").
  477. "\n\n\n".$form->field("editcontent"),
  478. force => 1);
  479. showform($form, \@buttons, $session, $q);
  480. return;
  481. }
  482. my $content=$form->field('editcontent');
  483. run_hooks(editcontent => sub {
  484. $content=shift->(
  485. content => $content,
  486. page => $page,
  487. cgi => $q,
  488. session => $session,
  489. );
  490. });
  491. $content=~s/\r\n/\n/g;
  492. $content=~s/\r/\n/g;
  493. $content.="\n" if $content !~ /\n$/;
  494. $config{cgi}=0; # avoid cgi error message
  495. eval { writefile($file, $config{srcdir}, $content) };
  496. $config{cgi}=1;
  497. if ($@) {
  498. $form->field(name => "rcsinfo", value => rcs_prepedit($file),
  499. force => 1);
  500. $form->tmpl_param("failed_save", 1);
  501. $form->tmpl_param("error_message", $@);
  502. $form->field("editcontent", value => $content, force => 1);
  503. $form->tmpl_param("page_select", 0);
  504. $form->field(name => "page", type => 'hidden');
  505. $form->field(name => "type", type => 'hidden');
  506. $form->title(sprintf(gettext("editing %s"), $page));
  507. showform($form, \@buttons, $session, $q);
  508. return;
  509. }
  510. my $conflict;
  511. if ($config{rcs}) {
  512. my $message="";
  513. if (defined $form->field('comments') &&
  514. length $form->field('comments')) {
  515. $message=$form->field('comments');
  516. }
  517. if (! $exists) {
  518. rcs_add($file);
  519. }
  520. # Prevent deadlock with post-commit hook by
  521. # signaling to it that it should not try to
  522. # do anything (except send commit mails).
  523. disable_commit_hook();
  524. $conflict=rcs_commit($file, $message,
  525. $form->field("rcsinfo"),
  526. $session->param("name"), $ENV{REMOTE_ADDR});
  527. enable_commit_hook();
  528. rcs_update();
  529. }
  530. # Refresh even if there was a conflict, since other changes
  531. # may have been committed while the post-commit hook was
  532. # disabled.
  533. require IkiWiki::Render;
  534. # Reload index, since the first time it's loaded is before
  535. # the wiki is locked, and things may have changed in the
  536. # meantime.
  537. loadindex();
  538. refresh();
  539. saveindex();
  540. if (defined $conflict) {
  541. $form->field(name => "rcsinfo", value => rcs_prepedit($file),
  542. force => 1);
  543. $form->tmpl_param("page_conflict", 1);
  544. $form->field("editcontent", value => $conflict, force => 1);
  545. $form->field("do", "edit", force => 1);
  546. $form->tmpl_param("page_select", 0);
  547. $form->field(name => "page", type => 'hidden');
  548. $form->field(name => "type", type => 'hidden');
  549. $form->title(sprintf(gettext("editing %s"), $page));
  550. showform($form, \@buttons, $session, $q);
  551. return;
  552. }
  553. else {
  554. # The trailing question mark tries to avoid broken
  555. # caches and get the most recent version of the page.
  556. redirect($q, "$config{url}/".htmlpage($page)."?updated");
  557. }
  558. }
  559. } #}}}
  560. sub cgi_getsession ($) { #{{{
  561. my $q=shift;
  562. eval q{use CGI::Session};
  563. CGI::Session->name("ikiwiki_session_".encode_utf8($config{wikiname}));
  564. my $oldmask=umask(077);
  565. my $session = CGI::Session->new("driver:DB_File", $q,
  566. { FileName => "$config{wikistatedir}/sessions.db" });
  567. umask($oldmask);
  568. return $session;
  569. } #}}}
  570. sub cgi_savesession ($) { #{{{
  571. my $session=shift;
  572. # Force session flush with safe umask.
  573. my $oldmask=umask(077);
  574. $session->flush;
  575. umask($oldmask);
  576. } #}}}
  577. sub cgi (;$$) { #{{{
  578. my $q=shift;
  579. my $session=shift;
  580. if (! $q) {
  581. eval q{use CGI};
  582. error($@) if $@;
  583. $q=CGI->new;
  584. run_hooks(cgi => sub { shift->($q) });
  585. }
  586. my $do=$q->param('do');
  587. if (! defined $do || ! length $do) {
  588. my $error = $q->cgi_error;
  589. if ($error) {
  590. error("Request not processed: $error");
  591. }
  592. else {
  593. error("\"do\" parameter missing");
  594. }
  595. }
  596. # Things that do not need a session.
  597. if ($do eq 'recentchanges') {
  598. cgi_recentchanges($q);
  599. return;
  600. }
  601. # Need to lock the wiki before getting a session.
  602. lockwiki();
  603. if (! $session) {
  604. $session=cgi_getsession($q);
  605. }
  606. # Auth hooks can sign a user in.
  607. if ($do ne 'signin' && ! defined $session->param("name")) {
  608. run_hooks(auth => sub {
  609. shift->($q, $session)
  610. });
  611. if (defined $session->param("name")) {
  612. # Make sure whatever user was authed is in the
  613. # userinfo db.
  614. if (! userinfo_get($session->param("name"), "regdate")) {
  615. userinfo_setall($session->param("name"), {
  616. email => "",
  617. password => "",
  618. regdate => time,
  619. }) || error("failed adding user");
  620. }
  621. }
  622. }
  623. if (defined $session->param("name") &&
  624. userinfo_get($session->param("name"), "banned")) {
  625. print $q->header(-status => "403 Forbidden");
  626. $session->delete();
  627. print gettext("You are banned.");
  628. cgi_savesession($session);
  629. }
  630. run_hooks(sessioncgi => sub { shift->($q, $session) });
  631. if ($do eq 'signin') {
  632. cgi_signin($q, $session);
  633. cgi_savesession($session);
  634. }
  635. elsif (defined $session->param("postsignin")) {
  636. cgi_postsignin($q, $session);
  637. }
  638. elsif ($do eq 'prefs') {
  639. cgi_prefs($q, $session);
  640. }
  641. elsif ($do eq 'create' || $do eq 'edit') {
  642. cgi_editpage($q, $session);
  643. }
  644. elsif ($do eq 'postsignin') {
  645. error(gettext("login failed, perhaps you need to turn on cookies?"));
  646. }
  647. else {
  648. error("unknown do parameter");
  649. }
  650. } #}}}
  651. sub userlink ($) { #{{{
  652. my $user=shift;
  653. eval q{use CGI 'escapeHTML'};
  654. error($@) if $@;
  655. if ($user =~ m!^https?://! &&
  656. eval q{use Net::OpenID::VerifiedIdentity; 1} && !$@) {
  657. # Munge user-urls, as used by eg, OpenID.
  658. my $oid=Net::OpenID::VerifiedIdentity->new(identity => $user);
  659. my $display=$oid->display;
  660. # Convert "user.somehost.com" to "user [somehost.com]".
  661. if ($display !~ /\[/) {
  662. $display=~s/^(.*?)\.([^.]+\.[a-z]+)$/$1 [$2]/;
  663. }
  664. # Convert "http://somehost.com/user" to "user [somehost.com]".
  665. if ($display !~ /\[/) {
  666. $display=~s/^https?:\/\/(.+)\/([^\/]+)$/$2 [$1]/;
  667. }
  668. $display=~s!^https?://!!; # make sure this is removed
  669. return "<a href=\"$user\">".escapeHTML($display)."</a>";
  670. }
  671. else {
  672. return htmllink("", "", escapeHTML(
  673. length $config{userdir} ? $config{userdir}."/".$user : $user
  674. ), noimageinline => 1);
  675. }
  676. } #}}}
  677. 1