content: /*
   This file is part of Airsonic.
  
   Airsonic is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
  
   Airsonic is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
  
   You should have received a copy of the GNU General Public License
   along with Airsonic.  If not, see <http://www.gnu.org/licenses/>.
  
   Copyright 2016 (C) Airsonic Authors
   Based upon Subsonic, Copyright 2009 (C) Sindre Mehus
   */
  package org.airsonic.player.controller;
  
  import org.airsonic.player.domain.*;
  import org.airsonic.player.io.RangeOutputStream;
  import org.airsonic.player.service.*;
  import org.airsonic.player.util.FileUtil;
  import org.airsonic.player.util.HttpRange;
  import org.airsonic.player.util.Util;
  import org.apache.commons.io.FilenameUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.ServletRequestBindingException;
  import org.springframework.web.bind.ServletRequestUtils;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.servlet.mvc.LastModified;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import java.io.*;
  import java.nio.charset.StandardCharsets;
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  import java.util.zip.CRC32;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipOutputStream;
  
  /**
   * A controller used for downloading files to a remote client. If the requested path refers to a file, the
   * given file is downloaded.  If the requested path refers to a directory, the entire directory (including
   * sub-directories) are downloaded as an uncompressed zip-file.
   *
   * @author Sindre Mehus
   */
  @Controller
  @RequestMapping("/download")
  public class DownloadController implements LastModified {
  
      private static final Logger LOG = LoggerFactory.getLogger(DownloadController.class);
  
      @Autowired
      private PlayerService playerService;
      @Autowired
      private StatusService statusService;
      @Autowired
      private SecurityService securityService;
      @Autowired
      private PlaylistService playlistService;
      @Autowired
      private SettingsService settingsService;
      @Autowired
      private MediaFileService mediaFileService;
  
      public long getLastModified(HttpServletRequest request) {
          try {
              MediaFile mediaFile = getMediaFile(request);
              if (mediaFile == null || mediaFile.isDirectory() || mediaFile.getChanged() == null) {
                  return -1;
              }
              return mediaFile.getChanged().getTime();
          } catch (ServletRequestBindingException e) {
              return -1;
          }
      }
  
      @GetMapping
      public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
  
          User user = securityService.getCurrentUser(request);
          TransferStatus status = null;
          try {
  
              status = statusService.createDownloadStatus(playerService.getPlayer(request, response, false, false));
  
              MediaFile mediaFile = getMediaFile(request);
  
              Integer playlistId = ServletRequestUtils.getIntParameter(request, "playlist");
              Integer playerId = ServletRequestUtils.getIntParameter(request, "player");
              int[] indexes = request.getParameter("i") == null ? null : ServletRequestUtils.getIntParameters(request, "i");
  
              if (mediaFile != null) {
                  response.setIntHeader("ETag", mediaFile.getId());
                  response.setHeader("Accept-Ranges", "bytes");
              }
  
              HttpRange range = HttpRange.valueOf(request.getHeader("Range"));
              if (range != null) {
                  response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
                  LOG.info("Got HTTP range: " + range);
              }
  
              if (mediaFile != null) {
                  if (!securityService.isFolderAccessAllowed(mediaFile, user.getUsername())) {
                      response.sendError(HttpServletResponse.SC_FORBIDDEN,
                              "Access to file " + mediaFile.getId() + " is forbidden for user " + user.getUsername());
                      return;
                  }
  
                  if (mediaFile.isFile()) {
                      downloadFile(response, status, mediaFile.getFile(), range);
                  } else {
                      List<MediaFile> children = mediaFileService.getChildrenOf(mediaFile, true, false, true);
                      String zipFileName = FilenameUtils.getBaseName(mediaFile.getPath()) + ".zip";
                      File coverArtFile = indexes == null ? mediaFile.getCoverArtFile() : null;
                      downloadFiles(response, status, children, indexes, coverArtFile, range, zipFileName);
                  }
  
              } else if (playlistId != null) {
                  List<MediaFile> songs = playlistService.getFilesInPlaylist(playlistId);
                  Playlist playlist = playlistService.getPlaylist(playlistId);
                  downloadFiles(response, status, songs, null, null, range, playlist.getName() + ".zip");
  
              } else if (playerId != null) {
                  Player player = playerService.getPlayerById(playerId);
                  PlayQueue playQueue = player.getPlayQueue();
                  playQueue.setName("Playlist");
                  downloadFiles(response, status, playQueue.getFiles(), indexes, null, range, "download.zip");
              }
  
          } finally {
              if (status != null) {
                  statusService.removeDownloadStatus(status);
                  securityService.updateUserByteCounts(user, 0L, status.getBytesTransfered(), 0L);
              }
          }
      }
  
      private MediaFile getMediaFile(HttpServletRequest request) throws ServletRequestBindingException {
          Integer id = ServletRequestUtils.getIntParameter(request, "id");
          return id == null ? null : mediaFileService.getMediaFile(id);
      }
  
      /**
       * Downloads a single file.
       *
       * @param response The HTTP response.
       * @param status   The download status.
       * @param file     The file to download.
       * @param range    The byte range, may be <code>null</code>.
       * @throws IOException If an I/O error occurs.
       */
      private void downloadFile(HttpServletResponse response, TransferStatus status, File file, HttpRange range) throws IOException {
          LOG.info("Starting to download '" + FileUtil.getShortPath(file) + "' to " + status.getPlayer());
          status.setFile(file);
  
          response.setContentType("application/x-download");
          response.setHeader("Content-Disposition", "attachment; filename*=UTF-8''" + encodeAsRFC5987(file.getName()));
          if (range == null) {
              Util.setContentLength(response, file.length());
          }
  
          copyFileToStream(file, RangeOutputStream.wrap(response.getOutputStream(), range), status, range);
          LOG.info("Downloaded '" + FileUtil.getShortPath(file) + "' to " + status.getPlayer());
      }
  
      private String encodeAsRFC5987(String string) {
          byte[] stringAsByteArray = string.getBytes(StandardCharsets.UTF_8);
          char[] digits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
          byte[] attrChar = {'!', '#', '$', '&', '+', '-', '.', '^', '_', '`', '|', '~', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
          StringBuilder sb = new StringBuilder();
          for (byte b : stringAsByteArray) {
              if (Arrays.binarySearch(attrChar, b) >= 0) {
                  sb.append((char) b);
              } else {
                  sb.append('%');
                  sb.append(digits[0x0f & (b >>> 4)]);
                  sb.append(digits[b & 0x0f]);
              }
          }
          return sb.toString();
      }
  
      /**
       * Downloads the given files.  The files are packed together in an
       * uncompressed zip-file.
       *
       * @param response     The HTTP response.
       * @param status       The download status.
       * @param files        The files to download.
       * @param indexes      Only download songs at these indexes. May be <code>null</code>.
       * @param coverArtFile The cover art file to include, may be {@code null}.
       * @param range        The byte range, may be <code>null</code>.
       * @param zipFileName  The name of the resulting zip file.   @throws IOException If an I/O error occurs.
       */
      private void downloadFiles(HttpServletResponse response, TransferStatus status, List<MediaFile> files, int[] indexes, File coverArtFile, HttpRange range, String zipFileName) throws IOException {
          boolean cover_embedded = false;
  
          if (indexes != null && indexes.length == 1) {
              downloadFile(response, status, files.get(indexes[0]).getFile(), range);
              return;
          }
  
          LOG.info("Starting to download '" + zipFileName + "' to " + status.getPlayer());
          response.setContentType("application/x-download");
          response.setHeader("Content-Disposition", "attachment; filename*=UTF-8''" + encodeAsRFC5987(zipFileName));
  
          ZipOutputStream out = new ZipOutputStream(RangeOutputStream.wrap(response.getOutputStream(), range));
          out.setMethod(ZipOutputStream.STORED);  // No compression.
  
          Set<MediaFile> filesToDownload = new HashSet<>();
          if (indexes == null) {
              filesToDownload.addAll(files);
          } else {
              for (int index : indexes) {
                  try {
                      filesToDownload.add(files.get(index));
                  } catch (IndexOutOfBoundsException x) { /* Ignored */}
              }
          }
  
          for (MediaFile mediaFile : filesToDownload) {
              zip(out, mediaFile.getParentFile(), mediaFile.getFile(), status, range);
              if (coverArtFile != null && coverArtFile.exists()) {
                  if (mediaFile.getFile().getCanonicalPath().equals(coverArtFile.getCanonicalPath())) {
                      cover_embedded = true;
                  }
              }
          }
          if (coverArtFile != null && coverArtFile.exists() && !cover_embedded) {
              zip(out, coverArtFile.getParentFile(), coverArtFile, status, range);
          }
  
  
          out.close();
          LOG.info("Downloaded '" + zipFileName + "' to " + status.getPlayer());
      }
  
      /**
       * Utility method for writing the content of a given file to a given output stream.
       *
       * @param file   The file to copy.
       * @param out    The output stream to write to.
       * @param status The download status.
       * @param range  The byte range, may be <code>null</code>.
       * @throws IOException If an I/O error occurs.
       */
      private void copyFileToStream(File file, OutputStream out, TransferStatus status, HttpRange range) throws IOException {
          LOG.info("Downloading '" + FileUtil.getShortPath(file) + "' to " + status.getPlayer());
  
          final int bufferSize = 16 * 1024; // 16 Kbit
          InputStream in = new BufferedInputStream(new FileInputStream(file), bufferSize);
  
          try {
              byte[] buf = new byte[bufferSize];
              long bitrateLimit = 0;
              long lastLimitCheck = 0;
  
              while (true) {
                  long before = System.currentTimeMillis();
                  int n = in.read(buf);
                  if (n == -1) {
                      break;
                  }
                  out.write(buf, 0, n);
  
                  // Don't sleep if outside range.
                  if (range != null && !range.contains(status.getBytesSkipped() + status.getBytesTransfered())) {
                      status.addBytesSkipped(n);
                      continue;
                  }
  
                  status.addBytesTransfered(n);
                  long after = System.currentTimeMillis();
  
                  // Calculate bitrate limit every 5 seconds.
                  if (after - lastLimitCheck > 5000) {
                      bitrateLimit = 1024L * settingsService.getDownloadBitrateLimit() /
                              Math.max(1, statusService.getAllDownloadStatuses().size());
                      lastLimitCheck = after;
                  }
  
                  // Sleep for a while to throttle bitrate.
                  if (bitrateLimit != 0) {
                      long sleepTime = 8L * 1000 * bufferSize / bitrateLimit - (after - before);
                      if (sleepTime > 0L) {
                          try {
                              Thread.sleep(sleepTime);
                          } catch (Exception x) {
                              LOG.warn("Failed to sleep.", x);
                          }
                      }
                  }
              }
          } finally {
              out.flush();
              FileUtil.closeQuietly(in);
          }
      }
  
      /**
       * Writes a file or a directory structure to a zip output stream. File entries in the zip file are relative
       * to the given root.
       *
       * @param out    The zip output stream.
       * @param root   The root of the directory structure.  Used to create path information in the zip file.
       * @param file   The file or directory to zip.
       * @param status The download status.
       * @param range  The byte range, may be <code>null</code>.
       * @throws IOException If an I/O error occurs.
       */
      private void zip(ZipOutputStream out, File root, File file, TransferStatus status, HttpRange range) throws IOException {
  
          // Exclude all hidden files starting with a "."
          if (file.getName().startsWith(".")) {
              return;
          }
  
          String zipName = file.getCanonicalPath().substring(root.getCanonicalPath().length() + 1);
  
          if (file.isFile()) {
              status.setFile(file);
  
              ZipEntry zipEntry = new ZipEntry(zipName);
              zipEntry.setSize(file.length());
              zipEntry.setCompressedSize(file.length());
              zipEntry.setCrc(computeCrc(file));
  
              out.putNextEntry(zipEntry);
              copyFileToStream(file, out, status, range);
              out.closeEntry();
  
          } else {
              ZipEntry zipEntry = new ZipEntry(zipName + '/');
              zipEntry.setSize(0);
              zipEntry.setCompressedSize(0);
              zipEntry.setCrc(0);
  
              out.putNextEntry(zipEntry);
              out.closeEntry();
  
              File[] children = FileUtil.listFiles(file);
              for (File child : children) {
                  zip(out, root, child, status, range);
              }
          }
      }
  
      /**
       * Computes the CRC checksum for the given file.
       *
       * @param file The file to compute checksum for.
       * @return A CRC32 checksum.
       * @throws IOException If an I/O error occurs.
       */
      private long computeCrc(File file) throws IOException {
          CRC32 crc = new CRC32();
  
          try (InputStream in = new FileInputStream(file)) {
  
              byte[] buf = new byte[8192];
              int n = in.read(buf);
              while (n != -1) {
                  crc.update(buf, 0, n);
                  n = in.read(buf);
              }
  
          }
  
          return crc.getValue();
      }
  
  }
  