src/be/nikiroo/fanfix/library/WebLibraryServer.java

   1 package be.nikiroo.fanfix.library;
   2
   3 import java.io.ByteArrayInputStream;
   4 import java.io.File;
   5 import java.io.FileInputStream;
   6 import java.io.IOException;
   7 import java.io.InputStream;
   8 import java.security.KeyStore;
   9 import java.util.ArrayList;
  10 import java.util.HashMap;
  11 import java.util.LinkedList;
  12 import java.util.List;
  13 import java.util.Map;
  14
  15 import javax.net.ssl.KeyManagerFactory;
  16 import javax.net.ssl.SSLServerSocketFactory;
  17
  18 import org.json.JSONArray;
  19 import org.json.JSONObject;
  20
  21 import be.nikiroo.fanfix.Instance;
  22 import be.nikiroo.fanfix.bundles.Config;
  23 import be.nikiroo.fanfix.bundles.UiConfig;
  24 import be.nikiroo.fanfix.data.Chapter;
  25 import be.nikiroo.fanfix.data.JsonIO;
  26 import be.nikiroo.fanfix.data.MetaData;
  27 import be.nikiroo.fanfix.data.Paragraph;
  28 import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
  29 import be.nikiroo.fanfix.data.Story;
  30 import be.nikiroo.fanfix.library.web.WebLibraryServerIndex;
  31 import be.nikiroo.fanfix.reader.TextOutput;
  32 import be.nikiroo.utils.CookieUtils;
  33 import be.nikiroo.utils.IOUtils;
  34 import be.nikiroo.utils.Image;
  35 import be.nikiroo.utils.NanoHTTPD;
  36 import be.nikiroo.utils.NanoHTTPD.IHTTPSession;
  37 import be.nikiroo.utils.NanoHTTPD.Response;
  38 import be.nikiroo.utils.NanoHTTPD.Response.Status;
  39 import be.nikiroo.utils.TraceHandler;
  40 import be.nikiroo.utils.Version;
  41
  42 public class WebLibraryServer implements Runnable {
  43         static private String VIEWER_URL_BASE = "/view/story/";
  44         static private String VIEWER_URL = VIEWER_URL_BASE + "{luid}/{chap}/{para}";
  45         static private String STORY_URL_BASE = "/story/";
  46         static private String STORY_URL = STORY_URL_BASE + "{luid}/{chap}/{para}";
  47         static private String STORY_URL_COVER = STORY_URL_BASE + "{luid}/cover";
  48         static private String LIST_URL = "/list/";
  49
  50         private class LoginResult {
  51                 private boolean success;
  52                 private boolean rw;
  53                 private boolean wl;
  54                 private String wookie;
  55                 private String token;
  56                 private boolean badLogin;
  57                 private boolean badToken;
  58
  59                 public LoginResult(String who, String key, String subkey,
  60                                 boolean success, boolean rw, boolean wl) {
  61                         this.success = success;
  62                         this.rw = rw;
  63                         this.wl = wl;
  64                         this.wookie = CookieUtils.generateCookie(who + key, 0);
  65
  66                         String opts = "";
  67                         if (rw)
  68                                 opts += "|rw";
  69                         if (!wl)
  70                                 opts += "|wl";
  71
  72                         this.token = wookie + "~"
  73                                         + CookieUtils.generateCookie(wookie + subkey + opts, 0)
  74                                         + "~" + opts;
  75                         this.badLogin = !success;
  76                 }
  77
  78                 public LoginResult(String token, String who, String key,
  79                                 List<String> subkeys) {
  80
  81                         if (token != null) {
  82                                 String hashes[] = token.split("~");
  83                                 if (hashes.length >= 2) {
  84                                         String wookie = hashes[0];
  85                                         String rehashed = hashes[1];
  86                                         String opts = hashes.length > 2 ? hashes[2] : "";
  87
  88                                         if (CookieUtils.validateCookie(who + key, wookie)) {
  89                                                 if (subkeys == null) {
  90                                                         subkeys = new ArrayList<String>();
  91                                                 }
  92                                                 subkeys = new ArrayList<String>(subkeys);
  93                                                 subkeys.add("");
  94
  95                                                 for (String subkey : subkeys) {
  96                                                         if (CookieUtils.validateCookie(
  97                                                                         wookie + subkey + opts, rehashed)) {
  98                                                                 this.wookie = wookie;
  99                                                                 this.token = token;
 100                                                                 this.success = true;
 101
 102                                                                 this.rw = opts.contains("|rw");
 103                                                                 this.wl = !opts.contains("|wl");
 104                                                         }
 105                                                 }
 106                                         }
 107                                 }
 108
 109                                 this.badToken = !success;
 110                         }
 111
 112                         // No token -> no bad token
 113                 }
 114
 115                 public boolean isSuccess() {
 116                         return success;
 117                 }
 118
 119                 public boolean isRw() {
 120                         return rw;
 121                 }
 122
 123                 public boolean isWl() {
 124                         return wl;
 125                 }
 126
 127                 public String getToken() {
 128                         return token;
 129                 }
 130
 131                 public boolean isBadLogin() {
 132                         return badLogin;
 133                 }
 134
 135                 public boolean isBadToken() {
 136                         return badToken;
 137                 }
 138         }
 139
 140         private NanoHTTPD server;
 141         private Map<String, Story> storyCache = new HashMap<String, Story>();
 142         private LinkedList<String> storyCacheOrder = new LinkedList<String>();
 143         private long storyCacheSize = 0;
 144         private long maxStoryCacheSize;
 145         private TraceHandler tracer = new TraceHandler();
 146
 147         public WebLibraryServer(boolean secure) throws IOException {
 148                 Integer port = Instance.getInstance().getConfig()
 149                                 .getInteger(Config.SERVER_PORT);
 150                 if (port == null) {
 151                         throw new IOException(
 152                                         "Cannot start web server: port not specified");
 153                 }
 154
 155                 int cacheMb = Instance.getInstance().getConfig()
 156                                 .getInteger(Config.SERVER_MAX_CACHE_MB, 100);
 157                 maxStoryCacheSize = cacheMb * 1024 * 1024;
 158
 159                 setTraceHandler(Instance.getInstance().getTraceHandler());
 160
 161                 SSLServerSocketFactory ssf = null;
 162                 if (secure) {
 163                         String keystorePath = Instance.getInstance().getConfig()
 164                                         .getString(Config.SERVER_SSL_KEYSTORE, "");
 165                         String keystorePass = Instance.getInstance().getConfig()
 166                                         .getString(Config.SERVER_SSL_KEYSTORE_PASS);
 167
 168                         if (secure && keystorePath.isEmpty()) {
 169                                 throw new IOException(
 170                                                 "Cannot start a secure web server: no keystore.jks file povided");
 171                         }
 172
 173                         if (!keystorePath.isEmpty()) {
 174                                 File keystoreFile = new File(keystorePath);
 175                                 try {
 176                                         KeyStore keystore = KeyStore
 177                                                         .getInstance(KeyStore.getDefaultType());
 178                                         InputStream keystoreStream = new FileInputStream(
 179                                                         keystoreFile);
 180                                         try {
 181                                                 keystore.load(keystoreStream,
 182                                                                 keystorePass.toCharArray());
 183                                                 KeyManagerFactory keyManagerFactory = KeyManagerFactory
 184                                                                 .getInstance(KeyManagerFactory
 185                                                                                 .getDefaultAlgorithm());
 186                                                 keyManagerFactory.init(keystore,
 187                                                                 keystorePass.toCharArray());
 188                                                 ssf = NanoHTTPD.makeSSLSocketFactory(keystore,
 189                                                                 keyManagerFactory);
 190                                         } finally {
 191                                                 keystoreStream.close();
 192                                         }
 193                                 } catch (Exception e) {
 194                                         throw new IOException(e.getMessage());
 195                                 }
 196                         }
 197                 }
 198
 199                 server = new NanoHTTPD(port) {
 200                         @Override
 201                         public Response serve(final IHTTPSession session) {
 202                                 super.serve(session);
 203
 204                                 String query = session.getQueryParameterString(); // a=a%20b&dd=2
 205                                 Method method = session.getMethod(); // GET, POST..
 206                                 String uri = session.getUri(); // /home.html
 207
 208                                 // need them in real time (not just those sent by the UA)
 209                                 Map<String, String> cookies = new HashMap<String, String>();
 210                                 for (String cookie : session.getCookies()) {
 211                                         cookies.put(cookie, session.getCookies().read(cookie));
 212                                 }
 213
 214                                 List<String> whitelist = Instance.getInstance().getConfig()
 215                                                 .getList(Config.SERVER_WHITELIST);
 216                                 if (whitelist == null) {
 217                                         whitelist = new ArrayList<String>();
 218                                 }
 219
 220                                 LoginResult login = null;
 221                                 Map<String, String> params = session.getParms();
 222                                 String who = session.getRemoteHostName()
 223                                                 + session.getRemoteIpAddress();
 224                                 if (params.get("login") != null) {
 225                                         login = login(who, params.get("password"),
 226                                                         params.get("login"), whitelist);
 227                                 } else {
 228                                         String token = cookies.get("token");
 229                                         login = login(who, token, Instance.getInstance().getConfig()
 230                                                         .getList(Config.SERVER_ALLOWED_SUBKEYS));
 231                                 }
 232
 233                                 if (login.isSuccess()) {
 234                                         if (!login.isWl()) {
 235                                                 whitelist.clear();
 236                                         }
 237
 238                                         // refresh token
 239                                         session.getCookies().set(new Cookie("token",
 240                                                         login.getToken(), "30; path=/"));
 241
 242                                         // set options
 243                                         String optionName = params.get("optionName");
 244                                         if (optionName != null && !optionName.isEmpty()) {
 245                                                 String optionNo = params.get("optionNo");
 246                                                 String optionValue = params.get("optionValue");
 247                                                 if (optionNo != null || optionValue == null
 248                                                                 || optionValue.isEmpty()) {
 249                                                         session.getCookies().delete(optionName);
 250                                                         cookies.remove(optionName);
 251                                                 } else {
 252                                                         session.getCookies().set(new Cookie(optionName,
 253                                                                         optionValue, "; path=/"));
 254                                                         cookies.put(optionName, optionValue);
 255                                                 }
 256                                         }
 257                                 }
 258
 259                                 Response rep = null;
 260                                 if (!login.isSuccess() && (uri.equals("/") //
 261                                                 || uri.startsWith(STORY_URL_BASE) //
 262                                                 || uri.startsWith(VIEWER_URL_BASE) //
 263                                                 || uri.startsWith(LIST_URL))) {
 264                                         rep = loginPage(login, uri);
 265                                 }
 266
 267                                 if (rep == null) {
 268                                         try {
 269                                                 if (uri.equals("/")) {
 270                                                         rep = root(session, cookies, whitelist);
 271                                                 } else if (uri.startsWith(LIST_URL)) {
 272                                                         rep = getList(uri, whitelist);
 273                                                 } else if (uri.startsWith(STORY_URL_BASE)) {
 274                                                         rep = getStoryPart(uri, whitelist);
 275                                                 } else if (uri.startsWith(VIEWER_URL_BASE)) {
 276                                                         rep = getViewer(cookies, uri, whitelist);
 277                                                 } else if (uri.equals("/logout")) {
 278                                                         session.getCookies().delete("token");
 279                                                         cookies.remove("token");
 280                                                         rep = loginPage(login, uri);
 281                                                 } else {
 282                                                         if (uri.startsWith("/"))
 283                                                                 uri = uri.substring(1);
 284                                                         InputStream in = IOUtils.openResource(
 285                                                                         WebLibraryServerIndex.class, uri);
 286                                                         if (in != null) {
 287                                                                 String mimeType = MIME_PLAINTEXT;
 288                                                                 if (uri.endsWith(".css")) {
 289                                                                         mimeType = "text/css";
 290                                                                 } else if (uri.endsWith(".html")) {
 291                                                                         mimeType = "text/html";
 292                                                                 } else if (uri.endsWith(".js")) {
 293                                                                         mimeType = "text/javascript";
 294                                                                 }
 295                                                                 rep = newChunkedResponse(Status.OK, mimeType,
 296                                                                                 in);
 297                                                         } else {
 298                                                                 getTraceHandler().trace("404: " + uri);
 299                                                         }
 300                                                 }
 301
 302                                                 if (rep == null) {
 303                                                         rep = newFixedLengthResponse(Status.NOT_FOUND,
 304                                                                         NanoHTTPD.MIME_PLAINTEXT, "Not Found");
 305                                                 }
 306                                         } catch (Exception e) {
 307                                                 Instance.getInstance().getTraceHandler().error(
 308                                                                 new IOException("Cannot process web request",
 309                                                                                 e));
 310                                                 rep = newFixedLengthResponse(Status.INTERNAL_ERROR,
 311                                                                 NanoHTTPD.MIME_PLAINTEXT, "An error occured");
 312                                         }
 313                                 }
 314
 315                                 return rep;
 316
 317                                 // Get status: for story, use "luid" + active map of current
 318                                 // luids
 319                                 // map must use a addRef/removeRef and delete at 0
 320
 321                                 // http://localhost:2000/?token=ok
 322
 323                                 //
 324                                 // MetaData meta = new MetaData();
 325                                 // meta.setTitle("Title");
 326                                 // meta.setLuid("000");
 327                                 //
 328                                 // JSONObject json = new JSONObject();
 329                                 // json.put("", MetaData.class.getName());
 330                                 // json.put("title", meta.getTitle());
 331                                 // json.put("luid", meta.getLuid());
 332                                 //
 333                                 // return newFixedLengthResponse(json.toString());
 334                         }
 335                 };
 336
 337                 if (ssf != null) {
 338                         getTraceHandler().trace("Install SSL on the web server...");
 339                         server.makeSecure(ssf, null);
 340                         getTraceHandler().trace("Done.");
 341                 }
 342         }
 343
 344         @Override
 345         public void run() {
 346                 try {
 347                         server.start(NanoHTTPD.SOCKET_READ_TIMEOUT, false);
 348                 } catch (IOException e) {
 349                         tracer.error(new IOException("Cannot start the web server", e));
 350                 }
 351         }
 352
 353         /**
 354          * Start the server (listen on the network for new connections).
 355          * <p>
 356          * Can only be called once.
 357          * <p>
 358          * This call is asynchronous, and will just start a new {@link Thread} on
 359          * itself (see {@link WebLibraryServer#run()}).
 360          */
 361         public void start() {
 362                 new Thread(this).start();
 363         }
 364
 365         /**
 366          * The traces handler for this {@link WebLibraryServer}.
 367          *
 368          * @return the traces handler
 369          */
 370         public TraceHandler getTraceHandler() {
 371                 return tracer;
 372         }
 373
 374         /**
 375          * The traces handler for this {@link WebLibraryServer}.
 376          *
 377          * @param tracer
 378          *            the new traces handler
 379          */
 380         public void setTraceHandler(TraceHandler tracer) {
 381                 if (tracer == null) {
 382                         tracer = new TraceHandler(false, false, false);
 383                 }
 384
 385                 this.tracer = tracer;
 386         }
 387
 388         private LoginResult login(String who, String token, List<String> subkeys) {
 389                 String realKey = Instance.getInstance().getConfig()
 390                                 .getString(Config.SERVER_KEY);
 391                 realKey = realKey == null ? "" : realKey;
 392                 return new LoginResult(token, who, realKey, subkeys);
 393         }
 394
 395         // allow rw/wl
 396         private LoginResult login(String who, String key, String subkey,
 397                         List<String> whitelist) {
 398                 String realKey = Instance.getInstance().getConfig()
 399                                 .getString(Config.SERVER_KEY);
 400
 401                 // I don't like NULLs...
 402                 realKey = realKey == null ? "" : realKey;
 403                 key = key == null ? "" : key;
 404                 subkey = subkey == null ? "" : subkey;
 405
 406                 if (!realKey.equals(key)) {
 407                         return new LoginResult(null, null, null, false, false, false);
 408                 }
 409
 410                 // defaults are positive (as previous versions without the feature)
 411                 boolean rw = true;
 412                 boolean wl = true;
 413
 414                 if (whitelist.isEmpty()) {
 415                         wl = false;
 416                 }
 417
 418                 rw = Instance.getInstance().getConfig().getBoolean(Config.SERVER_RW,
 419                                 rw);
 420                 if (!subkey.isEmpty()) {
 421                         List<String> allowed = Instance.getInstance().getConfig()
 422                                         .getList(Config.SERVER_ALLOWED_SUBKEYS);
 423                         if (allowed != null && allowed.contains(subkey)) {
 424                                 if ((subkey + "|").contains("|rw|")) {
 425                                         rw = true;
 426                                 }
 427                                 if ((subkey + "|").contains("|wl|")) {
 428                                         wl = false; // |wl| = bypass whitelist
 429                                 }
 430                         } else {
 431                                 return new LoginResult(null, null, null, false, false, false);
 432                         }
 433                 }
 434
 435                 return new LoginResult(who, key, subkey, true, rw, wl);
 436         }
 437
 438         private Response loginPage(LoginResult login, String uri) {
 439                 StringBuilder builder = new StringBuilder();
 440
 441                 appendPreHtml(builder, true);
 442
 443                 if (login.isBadLogin()) {
 444                         builder.append("<div class='error'>Bad login or password</div>");
 445                 } else if (login.isBadToken()) {
 446                         builder.append("<div class='error'>Your session timed out</div>");
 447                 }
 448
 449                 if (uri.equals("/logout")) {
 450                         uri = "/";
 451                 }
 452
 453                 builder.append(
 454                                 "<form method='POST' action='" + uri + "' class='login'>\n");
 455                 builder.append(
 456                                 "<p>You must be logged into the system to see the stories.</p>");
 457                 builder.append("\t<input type='text' name='login' />\n");
 458                 builder.append("\t<input type='password' name='password' />\n");
 459                 builder.append("\t<input type='submit' value='Login' />\n");
 460                 builder.append("</form>\n");
 461
 462                 appendPostHtml(builder);
 463
 464                 return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
 465                                 NanoHTTPD.MIME_HTML, builder.toString());
 466         }
 467
 468         protected Response getList(String uri, List<String> whitelist)
 469                         throws IOException {
 470                 if (uri.equals("/list/luids")) {
 471                         BasicLibrary lib = Instance.getInstance().getLibrary();
 472                         List<MetaData> metas = lib.getList().filter(whitelist, null, null);
 473                         List<JSONObject> jsons = new ArrayList<JSONObject>();
 474                         for (MetaData meta : metas) {
 475                                 jsons.add(JsonIO.toJson(meta));
 476                         }
 477
 478                         return newInputStreamResponse("application/json",
 479                                         new ByteArrayInputStream(
 480                                                         new JSONArray(jsons).toString().getBytes()));
 481                 }
 482
 483                 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 484                                 NanoHTTPD.MIME_PLAINTEXT, null);
 485         }
 486
 487         private Response root(IHTTPSession session, Map<String, String> cookies,
 488                         List<String> whitelist) throws IOException {
 489                 BasicLibrary lib = Instance.getInstance().getLibrary();
 490                 MetaResultList result = lib.getList();
 491                 result = new MetaResultList(result.filter(whitelist, null, null));
 492                 StringBuilder builder = new StringBuilder();
 493
 494                 appendPreHtml(builder, true);
 495
 496                 Map<String, String> params = session.getParms();
 497
 498                 String filter = cookies.get("filter");
 499                 if (params.get("optionNo") != null)
 500                         filter = null;
 501                 if (filter == null) {
 502                         filter = "";
 503                 }
 504
 505                 String browser = params.get("browser") == null ? ""
 506                                 : params.get("browser");
 507                 String browser2 = params.get("browser2") == null ? ""
 508                                 : params.get("browser2");
 509                 String browser3 = params.get("browser3") == null ? ""
 510                                 : params.get("browser3");
 511
 512                 String filterSource = null;
 513                 String filterAuthor = null;
 514                 String filterTag = null;
 515
 516                 // TODO: javascript in realtime, using visible=false + hide [submit]
 517
 518                 builder.append("<form class='browser'>\n");
 519                 builder.append("<div class='breadcrumbs'>\n");
 520
 521                 builder.append("\t<select name='browser'>");
 522                 appendOption(builder, 2, "", "", browser);
 523                 appendOption(builder, 2, "Sources", "sources", browser);
 524                 appendOption(builder, 2, "Authors", "authors", browser);
 525                 appendOption(builder, 2, "Tags", "tags", browser);
 526                 builder.append("\t</select>\n");
 527
 528                 if (!browser.isEmpty()) {
 529                         builder.append("\t<select name='browser2'>");
 530                         if (browser.equals("sources")) {
 531                                 filterSource = browser2.isEmpty() ? filterSource : browser2;
 532                                 // TODO: if 1 group -> no group
 533                                 appendOption(builder, 2, "", "", browser2);
 534                                 Map<String, List<String>> sources = result.getSourcesGrouped();
 535                                 for (String source : sources.keySet()) {
 536                                         appendOption(builder, 2, source, source, browser2);
 537                                 }
 538                         } else if (browser.equals("authors")) {
 539                                 filterAuthor = browser2.isEmpty() ? filterAuthor : browser2;
 540                                 // TODO: if 1 group -> no group
 541                                 appendOption(builder, 2, "", "", browser2);
 542                                 Map<String, List<String>> authors = result.getAuthorsGrouped();
 543                                 for (String author : authors.keySet()) {
 544                                         appendOption(builder, 2, author, author, browser2);
 545                                 }
 546                         } else if (browser.equals("tags")) {
 547                                 filterTag = browser2.isEmpty() ? filterTag : browser2;
 548                                 appendOption(builder, 2, "", "", browser2);
 549                                 for (String tag : result.getTags()) {
 550                                         appendOption(builder, 2, tag, tag, browser2);
 551                                 }
 552                         }
 553                         builder.append("\t</select>\n");
 554                 }
 555
 556                 if (!browser2.isEmpty()) {
 557                         if (browser.equals("sources")) {
 558                                 filterSource = browser3.isEmpty() ? filterSource : browser3;
 559                                 Map<String, List<String>> sourcesGrouped = result
 560                                                 .getSourcesGrouped();
 561                                 List<String> sources = sourcesGrouped.get(browser2);
 562                                 if (sources != null && !sources.isEmpty()) {
 563                                         // TODO: single empty value
 564                                         builder.append("\t<select name='browser3'>");
 565                                         appendOption(builder, 2, "", "", browser3);
 566                                         for (String source : sources) {
 567                                                 appendOption(builder, 2, source, source, browser3);
 568                                         }
 569                                         builder.append("\t</select>\n");
 570                                 }
 571                         } else if (browser.equals("authors")) {
 572                                 filterAuthor = browser3.isEmpty() ? filterAuthor : browser3;
 573                                 Map<String, List<String>> authorsGrouped = result
 574                                                 .getAuthorsGrouped();
 575                                 List<String> authors = authorsGrouped.get(browser2);
 576                                 if (authors != null && !authors.isEmpty()) {
 577                                         // TODO: single empty value
 578                                         builder.append("\t<select name='browser3'>");
 579                                         appendOption(builder, 2, "", "", browser3);
 580                                         for (String author : authors) {
 581                                                 appendOption(builder, 2, author, author, browser3);
 582                                         }
 583                                         builder.append("\t</select>\n");
 584                                 }
 585                         }
 586                 }
 587
 588                 builder.append("\t<input type='submit' value='Select'/>\n");
 589                 builder.append("</div>\n");
 590
 591                 // TODO: javascript in realtime, using visible=false + hide [submit]
 592                 builder.append("<div class='filter'>\n");
 593                 builder.append("\t<span class='label'>Filter: </span>\n");
 594                 builder.append(
 595                                 "\t<input name='optionName'  type='hidden' value='filter' />\n");
 596                 builder.append("\t<input name='optionValue' type='text'   value='"
 597                                 + filter + "' place-holder='...' />\n");
 598                 builder.append("\t<input name='optionNo'  type='submit' value='x' />");
 599                 builder.append(
 600                                 "\t<input name='submit' type='submit' value='Filter' />\n");
 601                 builder.append("</div>\n");
 602                 builder.append("</form>\n");
 603
 604                 builder.append("\t<div class='books'>");
 605                 for (MetaData meta : result.getMetas()) {
 606                         if (!filter.isEmpty() && !meta.getTitle().toLowerCase()
 607                                         .contains(filter.toLowerCase())) {
 608                                 continue;
 609                         }
 610
 611                         // TODO Sub sources
 612                         if (filterSource != null
 613                                         && !filterSource.equals(meta.getSource())) {
 614                                 continue;
 615                         }
 616
 617                         // TODO: sub authors
 618                         if (filterAuthor != null
 619                                         && !filterAuthor.equals(meta.getAuthor())) {
 620                                 continue;
 621                         }
 622
 623                         if (filterTag != null && !meta.getTags().contains(filterTag)) {
 624                                 continue;
 625                         }
 626
 627                         builder.append("<div class='book_line'>");
 628                         builder.append("<a href='");
 629                         builder.append(getViewUrl(meta.getLuid(), 0, null));
 630                         builder.append("'");
 631                         builder.append(" class='link'>");
 632
 633                         if (lib.isCached(meta.getLuid())) {
 634                                 // ◉ = &#9673;
 635                                 builder.append(
 636                                                 "<span class='cache_icon cached'>&#9673;</span>");
 637                         } else {
 638                                 // ○ = &#9675;
 639                                 builder.append(
 640                                                 "<span class='cache_icon uncached'>&#9675;</span>");
 641                         }
 642                         builder.append("<span class='luid'>");
 643                         builder.append(meta.getLuid());
 644                         builder.append("</span>");
 645                         builder.append("<span class='title'>");
 646                         builder.append(meta.getTitle());
 647                         builder.append("</span>");
 648                         builder.append("<span class='author'>");
 649                         if (meta.getAuthor() != null && !meta.getAuthor().isEmpty()) {
 650                                 builder.append("(").append(meta.getAuthor()).append(")");
 651                         }
 652                         builder.append("</span>");
 653                         builder.append("</a></div>\n");
 654                 }
 655                 builder.append("</div>");
 656
 657                 appendPostHtml(builder);
 658                 return NanoHTTPD.newFixedLengthResponse(builder.toString());
 659         }
 660
 661         // /story/luid/chapter/para <-- text/image
 662         // /story/luid/cover <-- image
 663         // /story/luid/metadata <-- json
 664         // /story/luid/json <-- json, whole chapter (no images)
 665         private Response getStoryPart(String uri, List<String> whitelist) {
 666                 String[] cover = uri.split("/");
 667                 int off = 2;
 668
 669                 if (cover.length < off + 2) {
 670                         return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 671                                         NanoHTTPD.MIME_PLAINTEXT, null);
 672                 }
 673
 674                 String luid = cover[off + 0];
 675                 String chapterStr = cover[off + 1];
 676                 String imageStr = cover.length < off + 3 ? null : cover[off + 2];
 677
 678                 // 1-based (0 = desc)
 679                 int chapter = 0;
 680                 if (chapterStr != null && !"cover".equals(chapterStr)
 681                                 && !"metadata".equals(chapterStr)
 682                                 && !"json".equals(chapterStr)) {
 683                         try {
 684                                 chapter = Integer.parseInt(chapterStr);
 685                                 if (chapter < 0) {
 686                                         throw new NumberFormatException();
 687                                 }
 688                         } catch (NumberFormatException e) {
 689                                 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 690                                                 NanoHTTPD.MIME_PLAINTEXT, "Chapter is not valid");
 691                         }
 692                 }
 693
 694                 // 1-based
 695                 int paragraph = 1;
 696                 if (imageStr != null) {
 697                         try {
 698                                 paragraph = Integer.parseInt(imageStr);
 699                                 if (paragraph < 0) {
 700                                         throw new NumberFormatException();
 701                                 }
 702                         } catch (NumberFormatException e) {
 703                                 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 704                                                 NanoHTTPD.MIME_PLAINTEXT, "Paragraph is not valid");
 705                         }
 706                 }
 707
 708                 String mimeType = NanoHTTPD.MIME_PLAINTEXT;
 709                 InputStream in = null;
 710                 try {
 711                         if ("cover".equals(chapterStr)) {
 712                                 Image img = getCover(luid, whitelist);
 713                                 if (img != null) {
 714                                         in = img.newInputStream();
 715                                 }
 716                         } else if ("metadata".equals(chapterStr)) {
 717                                 MetaData meta = meta(luid, whitelist);
 718                                 JSONObject json = JsonIO.toJson(meta);
 719                                 mimeType = "application/json";
 720                                 in = new ByteArrayInputStream(json.toString().getBytes());
 721                         } else if ("json".equals(chapterStr)) {
 722                                 Story story = story(luid, whitelist);
 723                                 JSONObject json = JsonIO.toJson(story);
 724                                 mimeType = "application/json";
 725                                 in = new ByteArrayInputStream(json.toString().getBytes());
 726                         } else {
 727                                 Story story = story(luid, whitelist);
 728                                 if (story != null) {
 729                                         if (chapter == 0) {
 730                                                 StringBuilder builder = new StringBuilder();
 731                                                 for (Paragraph p : story.getMeta().getResume()) {
 732                                                         if (builder.length() == 0) {
 733                                                                 builder.append("\n");
 734                                                         }
 735                                                         builder.append(p.getContent());
 736                                                 }
 737
 738                                                 in = new ByteArrayInputStream(
 739                                                                 builder.toString().getBytes("utf-8"));
 740                                         } else {
 741                                                 Paragraph para = story.getChapters().get(chapter - 1)
 742                                                                 .getParagraphs().get(paragraph - 1);
 743                                                 Image img = para.getContentImage();
 744                                                 if (para.getType() == ParagraphType.IMAGE) {
 745                                                         // TODO: get correct image type
 746                                                         mimeType = "image/png";
 747                                                         in = img.newInputStream();
 748                                                 } else {
 749                                                         in = new ByteArrayInputStream(
 750                                                                         para.getContent().getBytes("utf-8"));
 751                                                 }
 752                                         }
 753                                 }
 754                         }
 755                 } catch (IndexOutOfBoundsException e) {
 756                         return NanoHTTPD.newFixedLengthResponse(Status.NOT_FOUND,
 757                                         NanoHTTPD.MIME_PLAINTEXT,
 758                                         "Chapter or paragraph does not exist");
 759                 } catch (IOException e) {
 760                         Instance.getInstance().getTraceHandler()
 761                                         .error(new IOException("Cannot get image: " + uri, e));
 762                         return NanoHTTPD.newFixedLengthResponse(Status.INTERNAL_ERROR,
 763                                         NanoHTTPD.MIME_PLAINTEXT, "Error when processing request");
 764                 }
 765
 766                 return newInputStreamResponse(mimeType, in);
 767         }
 768
 769         private Response getViewer(Map<String, String> cookies, String uri,
 770                         List<String> whitelist) {
 771                 String[] cover = uri.split("/");
 772                 int off = 2;
 773
 774                 if (cover.length < off + 2) {
 775                         return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 776                                         NanoHTTPD.MIME_PLAINTEXT, null);
 777                 }
 778
 779                 String type = cover[off + 0];
 780                 String luid = cover[off + 1];
 781                 String chapterStr = cover.length < off + 3 ? null : cover[off + 2];
 782                 String paragraphStr = cover.length < off + 4 ? null : cover[off + 3];
 783
 784                 // 1-based (0 = desc)
 785                 int chapter = -1;
 786                 if (chapterStr != null) {
 787                         try {
 788                                 chapter = Integer.parseInt(chapterStr);
 789                                 if (chapter < 0) {
 790                                         throw new NumberFormatException();
 791                                 }
 792                         } catch (NumberFormatException e) {
 793                                 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 794                                                 NanoHTTPD.MIME_PLAINTEXT, "Chapter is not valid");
 795                         }
 796                 }
 797
 798                 // 1-based
 799                 int paragraph = 0;
 800                 if (paragraphStr != null) {
 801                         try {
 802                                 paragraph = Integer.parseInt(paragraphStr);
 803                                 if (paragraph <= 0) {
 804                                         throw new NumberFormatException();
 805                                 }
 806                         } catch (NumberFormatException e) {
 807                                 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 808                                                 NanoHTTPD.MIME_PLAINTEXT, "Paragraph is not valid");
 809                         }
 810                 }
 811
 812                 try {
 813                         Story story = story(luid, whitelist);
 814                         if (story == null) {
 815                                 return NanoHTTPD.newFixedLengthResponse(Status.NOT_FOUND,
 816                                                 NanoHTTPD.MIME_PLAINTEXT, "Story not found");
 817                         }
 818
 819                         StringBuilder builder = new StringBuilder();
 820                         appendPreHtml(builder, false);
 821
 822                         // For images documents, always go to the images if not chap 0 desc
 823                         if (story.getMeta().isImageDocument()) {
 824                                 if (chapter > 0 && paragraph <= 0)
 825                                         paragraph = 1;
 826                         }
 827
 828                         Chapter chap = null;
 829                         if (chapter <= 0) {
 830                                 chap = story.getMeta().getResume();
 831                         } else {
 832                                 try {
 833                                         chap = story.getChapters().get(chapter - 1);
 834                                 } catch (IndexOutOfBoundsException e) {
 835                                         return NanoHTTPD.newFixedLengthResponse(Status.NOT_FOUND,
 836                                                         NanoHTTPD.MIME_PLAINTEXT, "Chapter not found");
 837                                 }
 838                         }
 839
 840                         String first, previous, next, last;
 841
 842                         StringBuilder content = new StringBuilder();
 843
 844                         String disabledLeft = "";
 845                         String disabledRight = "";
 846                         String disabledZoomReal = "";
 847                         String disabledZoomWidth = "";
 848                         String disabledZoomHeight = "";
 849
 850                         if (paragraph <= 0) {
 851                                 first = getViewUrl(luid, 0, null);
 852                                 previous = getViewUrl(luid, (Math.max(chapter - 1, 0)), null);
 853                                 next = getViewUrl(luid,
 854                                                 (Math.min(chapter + 1, story.getChapters().size())),
 855                                                 null);
 856                                 last = getViewUrl(luid, story.getChapters().size(), null);
 857
 858                                 StringBuilder desc = new StringBuilder();
 859
 860                                 if (chapter <= 0) {
 861                                         desc.append("<div class='desc'>\n");
 862                                         desc.append("\t<div class='cover'>\n");
 863                                         desc.append("\t\t<img src='/story/" + luid + "/cover'/>\n");
 864                                         desc.append("\t</div>\n");
 865                                         desc.append("\t<table class='details'>\n");
 866                                         Map<String, String> details = BasicLibrary
 867                                                         .getMetaDesc(story.getMeta());
 868                                         for (String key : details.keySet()) {
 869                                                 appendTableRow(desc, 2, key, details.get(key));
 870                                         }
 871                                         desc.append("\t</table>\n");
 872                                         desc.append("</div>\n");
 873                                         desc.append("<h1 class='title'>Description</h1>\n");
 874                                 }
 875
 876                                 content.append("<div class='viewer text'>\n");
 877                                 content.append(desc);
 878                                 String description = new TextOutput(false).convert(chap,
 879                                                 chapter > 0);
 880                                 content.append(
 881                                                 description.isEmpty() ? "No description provided."
 882                                                                 : description);
 883                                 content.append("</div>\n");
 884
 885                                 if (chapter <= 0)
 886                                         disabledLeft = " disabled='disbaled'";
 887                                 if (chapter >= story.getChapters().size())
 888                                         disabledRight = " disabled='disbaled'";
 889                         } else {
 890                                 first = getViewUrl(luid, chapter, 1);
 891                                 previous = getViewUrl(luid, chapter,
 892                                                 (Math.max(paragraph - 1, 1)));
 893                                 next = getViewUrl(luid, chapter,
 894                                                 (Math.min(paragraph + 1, chap.getParagraphs().size())));
 895                                 last = getViewUrl(luid, chapter, chap.getParagraphs().size());
 896
 897                                 if (paragraph <= 1)
 898                                         disabledLeft = " disabled='disbaled'";
 899                                 if (paragraph >= chap.getParagraphs().size())
 900                                         disabledRight = " disabled='disbaled'";
 901
 902                                 // First -> previous *chapter*
 903                                 if (chapter > 0)
 904                                         disabledLeft = "";
 905                                 first = getViewUrl(luid, (Math.max(chapter - 1, 0)), null);
 906                                 if (paragraph <= 1) {
 907                                         previous = first;
 908                                 }
 909
 910                                 Paragraph para = null;
 911                                 try {
 912                                         para = chap.getParagraphs().get(paragraph - 1);
 913                                 } catch (IndexOutOfBoundsException e) {
 914                                         return NanoHTTPD.newFixedLengthResponse(Status.NOT_FOUND,
 915                                                         NanoHTTPD.MIME_PLAINTEXT,
 916                                                         "Paragraph " + paragraph + " not found");
 917                                 }
 918
 919                                 if (para.getType() == ParagraphType.IMAGE) {
 920                                         String zoomStyle = "max-width: 100%;";
 921                                         disabledZoomWidth = " disabled='disabled'";
 922                                         String zoomOption = cookies.get("zoom");
 923                                         if (zoomOption != null && !zoomOption.isEmpty()) {
 924                                                 if (zoomOption.equals("real")) {
 925                                                         zoomStyle = "";
 926                                                         disabledZoomWidth = "";
 927                                                         disabledZoomReal = " disabled='disabled'";
 928                                                 } else if (zoomOption.equals("width")) {
 929                                                         zoomStyle = "max-width: 100%;";
 930                                                 } else if (zoomOption.equals("height")) {
 931                                                         // see height of navbar + optionbar
 932                                                         zoomStyle = "max-height: calc(100% - 128px);";
 933                                                         disabledZoomWidth = "";
 934                                                         disabledZoomHeight = " disabled='disabled'";
 935                                                 }
 936                                         }
 937
 938                                         content.append(String.format("" //
 939                                                         + "<a class='viewer link' href='%s'>"
 940                                                         + "<img class='viewer img' style='%s' src='%s'/>"
 941                                                         + "</a>", //
 942                                                         next, //
 943                                                         zoomStyle, //
 944                                                         getStoryUrl(luid, chapter, paragraph)));
 945                                 } else {
 946                                         content.append(String.format("" //
 947                                                         + "<div class='viewer text'>%s</div>", //
 948                                                         para.getContent()));
 949                                 }
 950                         }
 951
 952                         builder.append(String.format("" //
 953                                         + "<div class='bar navbar'>\n" //
 954                                         + "\t<a%s class='button first' href='%s'>&lt;&lt;</a>\n"//
 955                                         + "\t<a%s class='button previous' href='%s'>&lt;</a>\n" //
 956                                         + "\t<div class='gotobox itemsbox'>\n" //
 957                                         + "\t\t<div class='button goto'>%d</div>\n" //
 958                                         + "\t\t<div class='items goto'>\n", //
 959                                         disabledLeft, first, //
 960                                         disabledLeft, previous, //
 961                                         paragraph > 0 ? paragraph : chapter //
 962                         ));
 963
 964                         // List of chap/para links
 965
 966                         String blink = "/view/story/" + luid + "/";
 967                         appendItemA(builder, 3, blink + "0", "Description",
 968                                         paragraph == 0 && chapter == 0);
 969
 970                         if (paragraph > 0) {
 971                                 blink = blink + chapter + "/";
 972                                 for (int i = 1; i <= chap.getParagraphs().size(); i++) {
 973                                         appendItemA(builder, 3, blink + i, "Image " + i,
 974                                                         paragraph == i);
 975                                 }
 976                         } else {
 977                                 int i = 1;
 978                                 for (Chapter c : story.getChapters()) {
 979                                         String chapName = "Chapter " + c.getNumber();
 980                                         if (c.getName() != null && !c.getName().isEmpty()) {
 981                                                 chapName += ": " + c.getName();
 982                                         }
 983
 984                                         appendItemA(builder, 3, blink + i, chapName, chapter == i);
 985
 986                                         i++;
 987                                 }
 988                         }
 989
 990                         builder.append(String.format("" //
 991                                         + "\t\t</div>\n" //
 992                                         + "\t</div>\n" //
 993                                         + "\t<a%s class='button next' href='%s'>&gt;</a>\n" //
 994                                         + "\t<a%s class='button last' href='%s'>&gt;&gt;</a>\n"//
 995                                         + "</div>\n", //
 996                                         disabledRight, next, //
 997                                         disabledRight, last //
 998                         ));
 999
1000                         builder.append(content);
1001
1002                         builder.append("<div class='bar optionbar ");
1003                         if (paragraph > 0) {
1004                                 builder.append("s4");
1005                         } else {
1006                                 builder.append("s1");
1007                         }
1008                         builder.append("'>\n");
1009                         builder.append("        <a class='button back' href='/'>BACK</a>\n");
1010
1011                         if (paragraph > 0) {
1012                                 builder.append(String.format("" //
1013                                                 + "\t<a%s class='button zoomreal'   href='%s'>REAL</a>\n"//
1014                                                 + "\t<a%s class='button zoomwidth'  href='%s'>WIDTH</a>\n"//
1015                                                 + "\t<a%s class='button zoomheight' href='%s'>HEIGHT</a>\n"//
1016                                                 + "</div>\n", //
1017                                                 disabledZoomReal,
1018                                                 uri + "?optionName=zoom&optionValue=real", //
1019                                                 disabledZoomWidth,
1020                                                 uri + "?optionName=zoom&optionValue=width", //
1021                                                 disabledZoomHeight,
1022                                                 uri + "?optionName=zoom&optionValue=height" //
1023                                 ));
1024                         }
1025
1026                         appendPostHtml(builder);
1027                         return NanoHTTPD.newFixedLengthResponse(Status.OK,
1028                                         NanoHTTPD.MIME_HTML, builder.toString());
1029                 } catch (IOException e) {
1030                         Instance.getInstance().getTraceHandler()
1031                                         .error(new IOException("Cannot get image: " + uri, e));
1032                         return NanoHTTPD.newFixedLengthResponse(Status.INTERNAL_ERROR,
1033                                         NanoHTTPD.MIME_PLAINTEXT, "Error when processing request");
1034                 }
1035         }
1036
1037         private Response newInputStreamResponse(String mimeType, InputStream in) {
1038                 if (in == null) {
1039                         return NanoHTTPD.newFixedLengthResponse(Status.NO_CONTENT, "",
1040                                         null);
1041                 }
1042                 return NanoHTTPD.newChunkedResponse(Status.OK, mimeType, in);
1043         }
1044
1045         private String getContentOf(String file) {
1046                 InputStream in = IOUtils.openResource(WebLibraryServerIndex.class,
1047                                 file);
1048                 if (in != null) {
1049                         try {
1050                                 return IOUtils.readSmallStream(in);
1051                         } catch (IOException e) {
1052                                 Instance.getInstance().getTraceHandler().error(
1053                                                 new IOException("Cannot get file: index.pre.html", e));
1054                         }
1055                 }
1056
1057                 return "";
1058         }
1059
1060         private String getViewUrl(String luid, int chap, Integer para) {
1061                 return VIEWER_URL //
1062                                 .replace("{luid}", luid) //
1063                                 .replace("{chap}", Integer.toString(chap)) //
1064                                 .replace("/{para}",
1065                                                 para == null ? "" : "/" + Integer.toString(para));
1066         }
1067
1068         private String getStoryUrl(String luid, int chap, Integer para) {
1069                 return STORY_URL //
1070                                 .replace("{luid}", luid) //
1071                                 .replace("{chap}", Integer.toString(chap)) //
1072                                 .replace("{para}", para == null ? "" : Integer.toString(para));
1073         }
1074
1075         private String getStoryUrlCover(String luid) {
1076                 return STORY_URL_COVER //
1077                                 .replace("{luid}", luid);
1078         }
1079
1080         private MetaData meta(String luid, List<String> whitelist)
1081                         throws IOException {
1082                 BasicLibrary lib = Instance.getInstance().getLibrary();
1083                 MetaData meta = lib.getInfo(luid);
1084                 if (!whitelist.isEmpty() && !whitelist.contains(meta.getSource())) {
1085                         return null;
1086                 }
1087
1088                 return meta;
1089         }
1090
1091         private Image getCover(String luid, List<String> whitelist)
1092                         throws IOException {
1093                 MetaData meta = meta(luid, whitelist);
1094                 if (meta != null) {
1095                         BasicLibrary lib = Instance.getInstance().getLibrary();
1096                         return lib.getCover(meta.getLuid());
1097                 }
1098
1099                 return null;
1100         }
1101
1102         // NULL if not whitelist OK or if not found
1103         private Story story(String luid, List<String> whitelist)
1104                         throws IOException {
1105                 synchronized (storyCache) {
1106                         if (storyCache.containsKey(luid)) {
1107                                 Story story = storyCache.get(luid);
1108                                 if (!whitelist.isEmpty()
1109                                                 && !whitelist.contains(story.getMeta().getSource())) {
1110                                         return null;
1111                                 }
1112
1113                                 return story;
1114                         }
1115                 }
1116
1117                 Story story = null;
1118                 MetaData meta = meta(luid, whitelist);
1119                 if (meta != null) {
1120                         BasicLibrary lib = Instance.getInstance().getLibrary();
1121                         story = lib.getStory(luid, null);
1122                         long size = sizeOf(story);
1123
1124                         synchronized (storyCache) {
1125                                 // Could have been added by another request
1126                                 if (!storyCache.containsKey(luid)) {
1127                                         while (!storyCacheOrder.isEmpty()
1128                                                         && storyCacheSize + size > maxStoryCacheSize) {
1129                                                 String oldestLuid = storyCacheOrder.removeFirst();
1130                                                 Story oldestStory = storyCache.remove(oldestLuid);
1131                                                 maxStoryCacheSize -= sizeOf(oldestStory);
1132                                         }
1133
1134                                         storyCacheOrder.add(luid);
1135                                         storyCache.put(luid, story);
1136                                 }
1137                         }
1138                 }
1139
1140                 return story;
1141         }
1142
1143         private long sizeOf(Story story) {
1144                 long size = 0;
1145                 for (Chapter chap : story) {
1146                         for (Paragraph para : chap) {
1147                                 if (para.getType() == ParagraphType.IMAGE) {
1148                                         size += para.getContentImage().getSize();
1149                                 } else {
1150                                         size += para.getContent().length();
1151                                 }
1152                         }
1153                 }
1154
1155                 return size;
1156         }
1157
1158         private void appendPreHtml(StringBuilder builder, boolean banner) {
1159                 String favicon = "favicon.ico";
1160                 String icon = Instance.getInstance().getUiConfig()
1161                                 .getString(UiConfig.PROGRAM_ICON);
1162                 if (icon != null) {
1163                         favicon = "icon_" + icon.replace("-", "_") + ".png";
1164                 }
1165
1166                 builder.append(
1167                                 getContentOf("index.pre.html").replace("favicon.ico", favicon));
1168
1169                 if (banner) {
1170                         builder.append("<div class='banner'>\n");
1171                         builder.append("\t<img class='ico' src='/") //
1172                                         .append(favicon) //
1173                                         .append("'/>\n");
1174                         builder.append("\t<h1>Fanfix</h1>\n");
1175                         builder.append("\t<h2>") //
1176                                         .append(Version.getCurrentVersion()) //
1177                                         .append("</h2>\n");
1178                         builder.append("</div>\n");
1179                 }
1180         }
1181
1182         private void appendPostHtml(StringBuilder builder) {
1183                 builder.append(getContentOf("index.post.html"));
1184         }
1185
1186         private void appendOption(StringBuilder builder, int depth, String name,
1187                         String value, String selected) {
1188                 for (int i = 0; i < depth; i++) {
1189                         builder.append("\t");
1190                 }
1191                 builder.append("<option value='").append(value).append("'");
1192                 if (value.equals(selected)) {
1193                         builder.append(" selected='selected'");
1194                 }
1195                 builder.append(">").append(name).append("</option>\n");
1196         }
1197
1198         private void appendTableRow(StringBuilder builder, int depth,
1199                         String... tds) {
1200                 for (int i = 0; i < depth; i++) {
1201                         builder.append("\t");
1202                 }
1203
1204                 int col = 1;
1205                 builder.append("<tr>");
1206                 for (String td : tds) {
1207                         builder.append("<td class='col");
1208                         builder.append(col++);
1209                         builder.append("'>");
1210                         builder.append(td);
1211                         builder.append("</td>");
1212                 }
1213                 builder.append("</tr>\n");
1214         }
1215
1216         private void appendItemA(StringBuilder builder, int depth, String link,
1217                         String name, boolean selected) {
1218                 for (int i = 0; i < depth; i++) {
1219                         builder.append("\t");
1220                 }
1221
1222                 builder.append("<a href='");
1223                 builder.append(link);
1224                 builder.append("' class='item goto");
1225                 if (selected) {
1226                         builder.append(" selected");
1227                 }
1228                 builder.append("'>");
1229                 builder.append(name);
1230                 builder.append("</a>\n");
1231         }
1232
1233         public static void main(String[] args) throws IOException {
1234                 Instance.init();
1235                 WebLibraryServer web = new WebLibraryServer(false);
1236                 web.run();
1237         }
1238 }