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(wookie + subkey
  97                                                                         + 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("Cannot start web server: port not specified");
 152                 }
 153
 154                 int cacheMb = Instance.getInstance().getConfig()
 155                                 .getInteger(Config.SERVER_MAX_CACHE_MB, 100);
 156                 maxStoryCacheSize = cacheMb * 1024 * 1024;
 157
 158                 setTraceHandler(Instance.getInstance().getTraceHandler());
 159
 160                 SSLServerSocketFactory ssf = null;
 161                 if (secure) {
 162                         String keystorePath = Instance.getInstance().getConfig()
 163                                         .getString(Config.SERVER_SSL_KEYSTORE, "");
 164                         String keystorePass = Instance.getInstance().getConfig()
 165                                         .getString(Config.SERVER_SSL_KEYSTORE_PASS);
 166
 167                         if (secure && keystorePath.isEmpty()) {
 168                                 throw new IOException(
 169                                                 "Cannot start a secure web server: no keystore.jks file povided");
 170                         }
 171
 172                         if (!keystorePath.isEmpty()) {
 173                                 File keystoreFile = new File(keystorePath);
 174                                 try {
 175                                         KeyStore keystore = KeyStore.getInstance(KeyStore
 176                                                         .getDefaultType());
 177                                         InputStream keystoreStream = new FileInputStream(
 178                                                         keystoreFile);
 179                                         try {
 180                                                 keystore.load(keystoreStream,
 181                                                                 keystorePass.toCharArray());
 182                                                 KeyManagerFactory keyManagerFactory = KeyManagerFactory
 183                                                                 .getInstance(KeyManagerFactory
 184                                                                                 .getDefaultAlgorithm());
 185                                                 keyManagerFactory.init(keystore,
 186                                                                 keystorePass.toCharArray());
 187                                                 ssf = NanoHTTPD.makeSSLSocketFactory(keystore,
 188                                                                 keyManagerFactory);
 189                                         } finally {
 190                                                 keystoreStream.close();
 191                                         }
 192                                 } catch (Exception e) {
 193                                         throw new IOException(e.getMessage());
 194                                 }
 195                         }
 196                 }
 197
 198                 server = new NanoHTTPD(port) {
 199                         @Override
 200                         public Response serve(final IHTTPSession session) {
 201                                 super.serve(session);
 202
 203                                 String query = session.getQueryParameterString(); // a=a%20b&dd=2
 204                                 Method method = session.getMethod(); // GET, POST..
 205                                 String uri = session.getUri(); // /home.html
 206
 207                                 // need them in real time (not just those sent by the UA)
 208                                 Map<String, String> cookies = new HashMap<String, String>();
 209                                 for (String cookie : session.getCookies()) {
 210                                         cookies.put(cookie, session.getCookies().read(cookie));
 211                                 }
 212
 213                                 List<String> whitelist = Instance.getInstance().getConfig()
 214                                                 .getList(Config.SERVER_WHITELIST);
 215                                 if (whitelist == null) {
 216                                         whitelist = new ArrayList<String>();
 217                                 }
 218
 219                                 LoginResult login = null;
 220                                 Map<String, String> params = session.getParms();
 221                                 String who = session.getRemoteHostName()
 222                                                 + session.getRemoteIpAddress();
 223                                 if (params.get("login") != null) {
 224                                         login = login(who, params.get("password"),
 225                                                         params.get("login"), whitelist);
 226                                 } else {
 227                                         String token = cookies.get("token");
 228                                         login = login(who, token, Instance.getInstance()
 229                                                         .getConfig().getList(Config.SERVER_ALLOWED_SUBKEYS));
 230                                 }
 231
 232                                 if (login.isSuccess()) {
 233                                         if (!login.isWl()) {
 234                                                 whitelist.clear();
 235                                         }
 236
 237                                         // refresh token
 238                                         session.getCookies()
 239                                                         .set(new Cookie("token", login.getToken(),
 240                                                                         "30; path=/"));
 241
 242                                         // set options
 243                                         String optionName = params.get("optionName");
 244                                         if (optionName != null && !optionName.isEmpty()) {
 245                                                 String optionValue = params.get("optionValue");
 246                                                 if (optionValue == null || optionValue.isEmpty()) {
 247                                                         session.getCookies().delete(optionName);
 248                                                         cookies.remove(optionName);
 249                                                 } else {
 250                                                         session.getCookies().set(
 251                                                                         new Cookie(optionName, optionValue,
 252                                                                                         "; path=/"));
 253                                                         cookies.put(optionName, optionValue);
 254                                                 }
 255                                         }
 256                                 }
 257
 258                                 Response rep = null;
 259                                 if (!login.isSuccess() && (uri.equals("/") //
 260                                                 || uri.startsWith(STORY_URL_BASE) //
 261                                                 || uri.startsWith(VIEWER_URL_BASE) //
 262                                 || uri.startsWith(LIST_URL))) {
 263                                         rep = loginPage(login, uri);
 264                                 }
 265
 266                                 if (rep == null) {
 267                                         try {
 268                                                 if (uri.equals("/")) {
 269                                                         rep = root(session, cookies, whitelist);
 270                                                 } else if (uri.startsWith(LIST_URL)) {
 271                                                         rep = getList(uri, whitelist);
 272                                                 } else if (uri.startsWith(STORY_URL_BASE)) {
 273                                                         rep = getStoryPart(uri, whitelist);
 274                                                 } else if (uri.startsWith(VIEWER_URL_BASE)) {
 275                                                         rep = getViewer(cookies, uri, whitelist);
 276                                                 } else if (uri.equals("/logout")) {
 277                                                         session.getCookies().delete("token");
 278                                                         cookies.remove("token");
 279                                                         rep = loginPage(login, uri);
 280                                                 } else {
 281                                                         if (uri.startsWith("/"))
 282                                                                 uri = uri.substring(1);
 283                                                         InputStream in = IOUtils.openResource(
 284                                                                         WebLibraryServerIndex.class, uri);
 285                                                         if (in != null) {
 286                                                                 String mimeType = MIME_PLAINTEXT;
 287                                                                 if (uri.endsWith(".css")) {
 288                                                                         mimeType = "text/css";
 289                                                                 } else if (uri.endsWith(".html")) {
 290                                                                         mimeType = "text/html";
 291                                                                 } else if (uri.endsWith(".js")) {
 292                                                                         mimeType = "text/javascript";
 293                                                                 }
 294                                                                 rep = newChunkedResponse(Status.OK, mimeType,
 295                                                                                 in);
 296                                                         } else {
 297                                                                 getTraceHandler().trace("404: " + uri);
 298                                                         }
 299                                                 }
 300
 301                                                 if (rep == null) {
 302                                                         rep = newFixedLengthResponse(Status.NOT_FOUND,
 303                                                                         NanoHTTPD.MIME_PLAINTEXT, "Not Found");
 304                                                 }
 305                                         } catch (Exception e) {
 306                                                 Instance.getInstance()
 307                                                                 .getTraceHandler()
 308                                                                 .error(new IOException(
 309                                                                                 "Cannot process web request", 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()
 419                                 .getBoolean(Config.SERVER_RW, 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("<form method='POST' action='" + uri
 454                                 + "' class='login'>\n");
 455                 builder.append("<p>You must be logged into the system to see the stories.</p>");
 456                 builder.append("\t<input type='text' name='login' />\n");
 457                 builder.append("\t<input type='password' name='password' />\n");
 458                 builder.append("\t<input type='submit' value='Login' />\n");
 459                 builder.append("</form>\n");
 460
 461                 appendPostHtml(builder);
 462
 463                 return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
 464                                 NanoHTTPD.MIME_HTML, builder.toString());
 465         }
 466
 467         protected Response getList(String uri, List<String> whitelist)
 468                         throws IOException {
 469                 if (uri.equals("/list/luids")) {
 470                         BasicLibrary lib = Instance.getInstance().getLibrary();
 471                         List<MetaData> metas = lib.getList().filter(whitelist, null, null);
 472                         List<JSONObject> jsons = new ArrayList<JSONObject>();
 473                         for (MetaData meta : metas) {
 474                                 jsons.add(JsonIO.toJson(meta));
 475                         }
 476
 477                         return newInputStreamResponse("application/json",
 478                                         new ByteArrayInputStream(new JSONArray(jsons).toString()
 479                                                         .getBytes()));
 480                 }
 481
 482                 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 483                                 NanoHTTPD.MIME_PLAINTEXT, null);
 484         }
 485
 486         private Response root(IHTTPSession session, Map<String, String> cookies,
 487                         List<String> whitelist) throws IOException {
 488                 BasicLibrary lib = Instance.getInstance().getLibrary();
 489                 MetaResultList result = lib.getList();
 490                 result = new MetaResultList(result.filter(whitelist, null, null));
 491                 StringBuilder builder = new StringBuilder();
 492
 493
 494                 appendPreHtml(builder, true);
 495
 496                 Map<String, String> params = session.getParms();
 497
 498                 String filter = cookies.get("filter");
 499                 if (params.get("clear") != null)
 500                         filter = null;
 501                 if (filter == null) {
 502                         filter = "";
 503                 }
 504
 505                 String browser = params.get("browser") == null ? "" : params
 506                                 .get("browser");
 507                 String browser2 = params.get("browser2") == null ? "" : params
 508                                 .get("browser2");
 509                 String browser3 = params.get("browser3") == null ? "" : params
 510                                 .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("\tFilter: \n");
 594                 builder.append("\t<input name='optionName'  type='hidden' value='filter' />\n");
 595                 builder.append("\t<input name='optionValue' type='text'   value='"
 596                                 + filter + "' place-holder='...' />\n");
 597                 builder.append("\t<input name='clear'  type='submit' value='x' />");
 598                 builder.append("\t<input name='submit' type='submit' value='Filter' />\n");
 599                 builder.append("</div>\n");
 600                 builder.append("</form>\n");
 601
 602                 builder.append("\t<div class='books'>");
 603                 for (MetaData meta : result.getMetas()) {
 604                         if (!filter.isEmpty()
 605                                         && !meta.getTitle().toLowerCase()
 606                                                         .contains(filter.toLowerCase())) {
 607                                 continue;
 608                         }
 609
 610                         // TODO Sub sources
 611                         if (filterSource != null && !filterSource.equals(meta.getSource())) {
 612                                 continue;
 613                         }
 614
 615                         // TODO: sub authors
 616                         if (filterAuthor != null && !filterAuthor.equals(meta.getAuthor())) {
 617                                 continue;
 618                         }
 619
 620                         if (filterTag != null && !meta.getTags().contains(filterTag)) {
 621                                 continue;
 622                         }
 623
 624                         builder.append("<div class='book_line'>");
 625                         builder.append("<a href='");
 626                         builder.append(getViewUrl(meta.getLuid(), 0, null));
 627                         builder.append("'");
 628                         builder.append(" class='link'>");
 629
 630                         if (lib.isCached(meta.getLuid())) {
 631                                 // ◉ = &#9673;
 632                                 builder.append("<span class='cache_icon cached'>&#9673;</span>");
 633                         } else {
 634                                 // ○ = &#9675;
 635                                 builder.append("<span class='cache_icon uncached'>&#9675;</span>");
 636                         }
 637                         builder.append("<span class='luid'>");
 638                         builder.append(meta.getLuid());
 639                         builder.append("</span>");
 640                         builder.append("<span class='title'>");
 641                         builder.append(meta.getTitle());
 642                         builder.append("</span>");
 643                         builder.append("<span class='author'>");
 644                         if (meta.getAuthor() != null && !meta.getAuthor().isEmpty()) {
 645                                 builder.append("(").append(meta.getAuthor()).append(")");
 646                         }
 647                         builder.append("</span>");
 648                         builder.append("</a></div>\n");
 649                 }
 650                 builder.append("</div>");
 651
 652                 appendPostHtml(builder);
 653                 return NanoHTTPD.newFixedLengthResponse(builder.toString());
 654         }
 655
 656         // /story/luid/chapter/para <-- text/image
 657         // /story/luid/cover <-- image
 658         // /story/luid/metadata <-- json
 659         // /story/luid/json <-- json, whole chapter (no images)
 660         private Response getStoryPart(String uri, List<String> whitelist) {
 661                 String[] cover = uri.split("/");
 662                 int off = 2;
 663
 664                 if (cover.length < off + 2) {
 665                         return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 666                                         NanoHTTPD.MIME_PLAINTEXT, null);
 667                 }
 668
 669                 String luid = cover[off + 0];
 670                 String chapterStr = cover[off + 1];
 671                 String imageStr = cover.length < off + 3 ? null : cover[off + 2];
 672
 673                 // 1-based (0 = desc)
 674                 int chapter = 0;
 675                 if (chapterStr != null && !"cover".equals(chapterStr)
 676                                 && !"metadata".equals(chapterStr) && !"json".equals(chapterStr)) {
 677                         try {
 678                                 chapter = Integer.parseInt(chapterStr);
 679                                 if (chapter < 0) {
 680                                         throw new NumberFormatException();
 681                                 }
 682                         } catch (NumberFormatException e) {
 683                                 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 684                                                 NanoHTTPD.MIME_PLAINTEXT, "Chapter is not valid");
 685                         }
 686                 }
 687
 688                 // 1-based
 689                 int paragraph = 1;
 690                 if (imageStr != null) {
 691                         try {
 692                                 paragraph = Integer.parseInt(imageStr);
 693                                 if (paragraph < 0) {
 694                                         throw new NumberFormatException();
 695                                 }
 696                         } catch (NumberFormatException e) {
 697                                 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 698                                                 NanoHTTPD.MIME_PLAINTEXT, "Paragraph is not valid");
 699                         }
 700                 }
 701
 702                 String mimeType = NanoHTTPD.MIME_PLAINTEXT;
 703                 InputStream in = null;
 704                 try {
 705                         if ("cover".equals(chapterStr)) {
 706                                 Image img = getCover(luid, whitelist);
 707                                 if (img != null) {
 708                                         in = img.newInputStream();
 709                                 }
 710                         } else if ("metadata".equals(chapterStr)) {
 711                                 MetaData meta = meta(luid, whitelist);
 712                                 JSONObject json = JsonIO.toJson(meta);
 713                                 mimeType = "application/json";
 714                                 in = new ByteArrayInputStream(json.toString().getBytes());
 715                         } else if ("json".equals(chapterStr)) {
 716                                 Story story = story(luid, whitelist);
 717                                 JSONObject json = JsonIO.toJson(story);
 718                                 mimeType = "application/json";
 719                                 in = new ByteArrayInputStream(json.toString().getBytes());
 720                         } else {
 721                                 Story story = story(luid, whitelist);
 722                                 if (story != null) {
 723                                         if (chapter == 0) {
 724                                                 StringBuilder builder = new StringBuilder();
 725                                                 for (Paragraph p : story.getMeta().getResume()) {
 726                                                         if (builder.length() == 0) {
 727                                                                 builder.append("\n");
 728                                                         }
 729                                                         builder.append(p.getContent());
 730                                                 }
 731
 732                                                 in = new ByteArrayInputStream(builder.toString()
 733                                                                 .getBytes("utf-8"));
 734                                         } else {
 735                                                 Paragraph para = story.getChapters().get(chapter - 1)
 736                                                                 .getParagraphs().get(paragraph - 1);
 737                                                 Image img = para.getContentImage();
 738                                                 if (para.getType() == ParagraphType.IMAGE) {
 739                                                         // TODO: get correct image type
 740                                                         mimeType = "image/png";
 741                                                         in = img.newInputStream();
 742                                                 } else {
 743                                                         in = new ByteArrayInputStream(para.getContent()
 744                                                                         .getBytes("utf-8"));
 745                                                 }
 746                                         }
 747                                 }
 748                         }
 749                 } catch (IndexOutOfBoundsException e) {
 750                         return NanoHTTPD.newFixedLengthResponse(Status.NOT_FOUND,
 751                                         NanoHTTPD.MIME_PLAINTEXT,
 752                                         "Chapter or paragraph does not exist");
 753                 } catch (IOException e) {
 754                         Instance.getInstance().getTraceHandler()
 755                                         .error(new IOException("Cannot get image: " + uri, e));
 756                         return NanoHTTPD.newFixedLengthResponse(Status.INTERNAL_ERROR,
 757                                         NanoHTTPD.MIME_PLAINTEXT, "Error when processing request");
 758                 }
 759
 760                 return newInputStreamResponse(mimeType, in);
 761         }
 762
 763         private Response getViewer(Map<String, String> cookies, String uri,
 764                         List<String> whitelist) {
 765                 String[] cover = uri.split("/");
 766                 int off = 2;
 767
 768                 if (cover.length < off + 2) {
 769                         return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 770                                         NanoHTTPD.MIME_PLAINTEXT, null);
 771                 }
 772
 773                 String type = cover[off + 0];
 774                 String luid = cover[off + 1];
 775                 String chapterStr = cover.length < off + 3 ? null : cover[off + 2];
 776                 String paragraphStr = cover.length < off + 4 ? null : cover[off + 3];
 777
 778                 // 1-based (0 = desc)
 779                 int chapter = -1;
 780                 if (chapterStr != null) {
 781                         try {
 782                                 chapter = Integer.parseInt(chapterStr);
 783                                 if (chapter < 0) {
 784                                         throw new NumberFormatException();
 785                                 }
 786                         } catch (NumberFormatException e) {
 787                                 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 788                                                 NanoHTTPD.MIME_PLAINTEXT, "Chapter is not valid");
 789                         }
 790                 }
 791
 792                 // 1-based
 793                 int paragraph = 0;
 794                 if (paragraphStr != null) {
 795                         try {
 796                                 paragraph = Integer.parseInt(paragraphStr);
 797                                 if (paragraph <= 0) {
 798                                         throw new NumberFormatException();
 799                                 }
 800                         } catch (NumberFormatException e) {
 801                                 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
 802                                                 NanoHTTPD.MIME_PLAINTEXT, "Paragraph is not valid");
 803                         }
 804                 }
 805
 806                 try {
 807                         Story story = story(luid, whitelist);
 808                         if (story == null) {
 809                                 return NanoHTTPD.newFixedLengthResponse(Status.NOT_FOUND,
 810                                                 NanoHTTPD.MIME_PLAINTEXT, "Story not found");
 811                         }
 812
 813                         StringBuilder builder = new StringBuilder();
 814                         appendPreHtml(builder, false);
 815
 816                         // TODO: no desc page for images?
 817                         if (story.getMeta().isImageDocument()) {
 818                                 if (chapter <= 0)
 819                                         chapter = 1;
 820                                 if (paragraph <= 0)
 821                                         paragraph = 1;
 822                         }
 823
 824                         Chapter chap = null;
 825                         if (chapter <= 0) {
 826                                 chap = story.getMeta().getResume();
 827                         } else {
 828                                 try {
 829                                         chap = story.getChapters().get(chapter - 1);
 830                                 } catch (IndexOutOfBoundsException e) {
 831                                         return NanoHTTPD.newFixedLengthResponse(Status.NOT_FOUND,
 832                                                         NanoHTTPD.MIME_PLAINTEXT, "Chapter not found");
 833                                 }
 834                         }
 835
 836                         String first, previous, next, last;
 837
 838                         StringBuilder content = new StringBuilder();
 839
 840                         String disabledLeft = "";
 841                         String disabledRight = "";
 842                         String disabledZoomReal = "";
 843                         String disabledZoomWidth = "";
 844                         String disabledZoomHeight = "";
 845
 846                         if (paragraph <= 0) {
 847                                 first = getViewUrl(luid, 1, null);
 848                                 previous = getViewUrl(luid, (Math.max(chapter - 1, 1)), null);
 849                                 next = getViewUrl(luid,
 850                                                 (Math.min(chapter + 1, story.getChapters().size())),
 851                                                 null);
 852                                 last = getViewUrl(luid, story.getChapters().size(), null);
 853
 854                                 // TODO
 855                                 StringBuilder desc = new StringBuilder();
 856
 857                                 if (chapter <= 0) {
 858                                         desc.append("<div class='desc'>\n");
 859                                         desc.append("\t<div class='cover'>\n");
 860                                         desc.append("\t\t<img src='/story/" + luid + "/cover'/>\n");
 861                                         desc.append("\t</div>\n");
 862                                         desc.append("\t<table>\n");
 863                                         desc.append("\t\t<tr><th>HEAD 1</th><th>HEAD 2</th></tr>\n");
 864                                         desc.append("\t\t<tr><td>KEY 1</td><td>VAL 1</td></tr>\n");
 865                                         desc.append("\t\t<tr><td>KEY 2</td><td>VAL 2</td></tr>\n");
 866                                         desc.append("\t</table>\n");
 867                                         desc.append("</div>\n");
 868                                         desc.append("<h1 class='title'>Description</h1>\n");
 869                                 }
 870
 871                                 content.append("<div class='viewer text'>\n");
 872                                 content.append(desc);
 873                                 content.append(new TextOutput(false).convert(chap, chapter > 0));
 874                                 content.append("</div>\n");
 875
 876                                 if (chapter <= 1)
 877                                         disabledLeft = " disabled='disbaled'";
 878                                 if (chapter >= story.getChapters().size())
 879                                         disabledRight = " disabled='disbaled'";
 880                         } else {
 881                                 first = getViewUrl(luid, chapter, 1);
 882                                 previous = getViewUrl(luid, chapter,
 883                                                 (Math.max(paragraph - 1, 1)));
 884                                 next = getViewUrl(luid, chapter,
 885                                                 (Math.min(paragraph + 1, chap.getParagraphs().size())));
 886                                 last = getViewUrl(luid, chapter, chap.getParagraphs().size());
 887
 888                                 if (paragraph <= 1)
 889                                         disabledLeft = " disabled='disbaled'";
 890                                 if (paragraph >= chap.getParagraphs().size())
 891                                         disabledRight = " disabled='disbaled'";
 892
 893                                 Paragraph para = null;
 894                                 try {
 895                                         para = chap.getParagraphs().get(paragraph - 1);
 896                                 } catch (IndexOutOfBoundsException e) {
 897                                         return NanoHTTPD.newFixedLengthResponse(Status.NOT_FOUND,
 898                                                         NanoHTTPD.MIME_PLAINTEXT, "Paragraph " + paragraph
 899                                                                         + " not found");
 900                                 }
 901
 902                                 if (para.getType() == ParagraphType.IMAGE) {
 903                                         String zoomStyle = "max-width: 100%;";
 904                                         disabledZoomWidth = " disabled='disabled'";
 905                                         String zoomOption = cookies.get("zoom");
 906                                         if (zoomOption != null && !zoomOption.isEmpty()) {
 907                                                 if (zoomOption.equals("real")) {
 908                                                         zoomStyle = "";
 909                                                         disabledZoomWidth = "";
 910                                                         disabledZoomReal = " disabled='disabled'";
 911                                                 } else if (zoomOption.equals("width")) {
 912                                                         zoomStyle = "max-width: 100%;";
 913                                                 } else if (zoomOption.equals("height")) {
 914                                                         // see height of navbar + optionbar
 915                                                         zoomStyle = "max-height: calc(100% - 128px);";
 916                                                         disabledZoomWidth = "";
 917                                                         disabledZoomHeight = " disabled='disabled'";
 918                                                 }
 919                                         }
 920
 921                                         content.append(String.format("" //
 922                                                         + "<a class='viewer link' href='%s'>"
 923                                                         + "<img class='viewer img' style='%s' src='%s'/>"
 924                                                         + "</a>", //
 925                                                         next, //
 926                                                         zoomStyle, //
 927                                                         getStoryUrl(luid, chapter, paragraph)));
 928                                 } else {
 929                                         content.append(para.getContent());
 930                                 }
 931                         }
 932
 933                         builder.append(String.format("" //
 934                                         + "<div class='bar navbar'>\n" //
 935                                         + "\t<a%s class='button first' href='%s'>&lt;&lt;</a>\n"//
 936                                         + "\t<a%s class='button previous' href='%s'>&lt;</a>\n"//
 937                                         + "\t<a%s class='button next' href='%s'>&gt;</a>\n"//
 938                                         + "\t<a%s class='button last' href='%s'>&gt;&gt;</a>\n"//
 939                                         + "</div>\n", //
 940                                         disabledLeft, first, //
 941                                         disabledLeft, previous, //
 942                                         disabledRight, next, //
 943                                         disabledRight, last //
 944                                         ));
 945
 946                         builder.append(content);
 947
 948                         builder.append("<div class='bar optionbar ");
 949                         if (paragraph > 0) {
 950                                 builder.append("s4");
 951                         } else {
 952                                 builder.append("s1");
 953                         }
 954                         builder.append("'>\n");
 955                         builder.append("        <a class='button back' href='/'>BACK</a>\n");
 956
 957                         if (paragraph > 0) {
 958                                 builder.append(String
 959                                                 .format("" //
 960                                                                 + "\t<a%s class='button zoomreal'   href='%s'>REAL</a>\n"//
 961                                                                 + "\t<a%s class='button zoomwidth'  href='%s'>WIDTH</a>\n"//
 962                                                                 + "\t<a%s class='button zoomheight' href='%s'>HEIGHT</a>\n"//
 963                                                                 + "</div>\n", //
 964                                                                 disabledZoomReal, uri
 965                                                                                 + "?optionName=zoom&optionValue=real", //
 966                                                                 disabledZoomWidth, uri
 967                                                                                 + "?optionName=zoom&optionValue=width", //
 968                                                                 disabledZoomHeight, uri
 969                                                                                 + "?optionName=zoom&optionValue=height" //
 970                                                 ));
 971                         }
 972
 973                         appendPostHtml(builder);
 974                         return NanoHTTPD.newFixedLengthResponse(Status.OK,
 975                                         NanoHTTPD.MIME_HTML, builder.toString());
 976                 } catch (IOException e) {
 977                         Instance.getInstance().getTraceHandler()
 978                                         .error(new IOException("Cannot get image: " + uri, e));
 979                         return NanoHTTPD.newFixedLengthResponse(Status.INTERNAL_ERROR,
 980                                         NanoHTTPD.MIME_PLAINTEXT, "Error when processing request");
 981                 }
 982         }
 983
 984         private Response newInputStreamResponse(String mimeType, InputStream in) {
 985                 if (in == null) {
 986                         return NanoHTTPD
 987                                         .newFixedLengthResponse(Status.NO_CONTENT, "", null);
 988                 }
 989                 return NanoHTTPD.newChunkedResponse(Status.OK, mimeType, in);
 990         }
 991
 992         private String getContentOf(String file) {
 993                 InputStream in = IOUtils
 994                                 .openResource(WebLibraryServerIndex.class, file);
 995                 if (in != null) {
 996                         try {
 997                                 return IOUtils.readSmallStream(in);
 998                         } catch (IOException e) {
 999                                 Instance.getInstance()
1000                                                 .getTraceHandler()
1001                                                 .error(new IOException(
1002                                                                 "Cannot get file: index.pre.html", e));
1003                         }
1004                 }
1005
1006                 return "";
1007         }
1008
1009         private String getViewUrl(String luid, int chap, Integer para) {
1010                 return VIEWER_URL //
1011                                 .replace("{luid}", luid) //
1012                                 .replace("{chap}", Integer.toString(chap)) //
1013                                 .replace("/{para}",
1014                                                 para == null ? "" : "/" + Integer.toString(para));
1015         }
1016
1017         private String getStoryUrl(String luid, int chap, Integer para) {
1018                 return STORY_URL //
1019                                 .replace("{luid}", luid) //
1020                                 .replace("{chap}", Integer.toString(chap)) //
1021                                 .replace("{para}", para == null ? "" : Integer.toString(para));
1022         }
1023
1024         private String getStoryUrlCover(String luid) {
1025                 return STORY_URL_COVER //
1026                                 .replace("{luid}", luid);
1027         }
1028
1029         private MetaData meta(String luid, List<String> whitelist)
1030                         throws IOException {
1031                 BasicLibrary lib = Instance.getInstance().getLibrary();
1032                 MetaData meta = lib.getInfo(luid);
1033                 if (!whitelist.isEmpty() && !whitelist.contains(meta.getSource())) {
1034                         return null;
1035                 }
1036
1037                 return meta;
1038         }
1039
1040         private Image getCover(String luid, List<String> whitelist)
1041                         throws IOException {
1042                 MetaData meta = meta(luid, whitelist);
1043                 if (meta != null) {
1044                         BasicLibrary lib = Instance.getInstance().getLibrary();
1045                         return lib.getCover(meta.getLuid());
1046                 }
1047
1048                 return null;
1049         }
1050
1051         // NULL if not whitelist OK or if not found
1052         private Story story(String luid, List<String> whitelist) throws IOException {
1053                 synchronized (storyCache) {
1054                         if (storyCache.containsKey(luid)) {
1055                                 Story story = storyCache.get(luid);
1056                                 if (!whitelist.isEmpty()
1057                                                 && !whitelist.contains(story.getMeta().getSource())) {
1058                                         return null;
1059                                 }
1060
1061                                 return story;
1062                         }
1063                 }
1064
1065                 Story story = null;
1066                 MetaData meta = meta(luid, whitelist);
1067                 if (meta != null) {
1068                         BasicLibrary lib = Instance.getInstance().getLibrary();
1069                         story = lib.getStory(luid, null);
1070                         long size = sizeOf(story);
1071
1072                         synchronized (storyCache) {
1073                                 // Could have been added by another request
1074                                 if (!storyCache.containsKey(luid)) {
1075                                         while (!storyCacheOrder.isEmpty()
1076                                                         && storyCacheSize + size > maxStoryCacheSize) {
1077                                                 String oldestLuid = storyCacheOrder.removeFirst();
1078                                                 Story oldestStory = storyCache.remove(oldestLuid);
1079                                                 maxStoryCacheSize -= sizeOf(oldestStory);
1080                                         }
1081
1082                                         storyCacheOrder.add(luid);
1083                                         storyCache.put(luid, story);
1084                                 }
1085                         }
1086                 }
1087
1088                 return story;
1089         }
1090
1091         private long sizeOf(Story story) {
1092                 long size = 0;
1093                 for (Chapter chap : story) {
1094                         for (Paragraph para : chap) {
1095                                 if (para.getType() == ParagraphType.IMAGE) {
1096                                         size += para.getContentImage().getSize();
1097                                 } else {
1098                                         size += para.getContent().length();
1099                                 }
1100                         }
1101                 }
1102
1103                 return size;
1104         }
1105
1106         private void appendPreHtml(StringBuilder builder, boolean banner) {
1107                 String favicon = "favicon.ico";
1108                 String icon = Instance.getInstance().getUiConfig()
1109                                 .getString(UiConfig.PROGRAM_ICON);
1110                 if (icon != null) {
1111                         favicon = "icon_" + icon.replace("-", "_") + ".png";
1112                 }
1113
1114                 builder.append(getContentOf("index.pre.html").replace("favicon.ico",
1115                                 favicon));
1116
1117                 if (banner) {
1118                         builder.append("<div class='banner'>\n");
1119                         builder.append("\t<img class='ico' src='/") //
1120                                         .append(favicon) //
1121                                         .append("'/>\n");
1122                         builder.append("\t<h1>Fanfix</h1>\n");
1123                         builder.append("\t<h2>") //
1124                                         .append(Version.getCurrentVersion()) //
1125                                         .append("</h2>\n");
1126                         builder.append("</div>\n");
1127                 }
1128         }
1129
1130         private void appendPostHtml(StringBuilder builder) {
1131                 builder.append(getContentOf("index.post.html"));
1132         }
1133
1134         private void appendOption(StringBuilder builder, int depth, String name,
1135                         String value, String selected) {
1136                 for (int i = 0; i < depth; i++) {
1137                         builder.append("\t");
1138                 }
1139                 builder.append("<option value='").append(value).append("'");
1140                 if (value.equals(selected)) {
1141                         builder.append(" selected='selected'");
1142                 }
1143                 builder.append(">").append(name).append("</option>\n");
1144         }
1145
1146         public static void main(String[] args) throws IOException {
1147                 Instance.init();
1148                 WebLibraryServer web = new WebLibraryServer(false);
1149                 web.run();
1150         }
1151 }