server/controllers/download.ts

   1 import * as cors from 'cors'
   2 import * as express from 'express'
   3 import { logger } from '@server/helpers/logger'
   4 import { VideosTorrentCache } from '@server/lib/files-cache/videos-torrent-cache'
   5 import { Hooks } from '@server/lib/plugins/hooks'
   6 import { getVideoFilePath } from '@server/lib/video-paths'
   7 import { MStreamingPlaylist, MVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
   8 import { HttpStatusCode, VideoStreamingPlaylistType } from '@shared/models'
   9 import { STATIC_DOWNLOAD_PATHS } from '../initializers/constants'
  10 import { asyncMiddleware, videosDownloadValidator } from '../middlewares'
  11
  12 const downloadRouter = express.Router()
  13
  14 downloadRouter.use(cors())
  15
  16 downloadRouter.use(
  17   STATIC_DOWNLOAD_PATHS.TORRENTS + ':filename',
  18   asyncMiddleware(downloadTorrent)
  19 )
  20
  21 downloadRouter.use(
  22   STATIC_DOWNLOAD_PATHS.VIDEOS + ':id-:resolution([0-9]+).:extension',
  23   asyncMiddleware(videosDownloadValidator),
  24   asyncMiddleware(downloadVideoFile)
  25 )
  26
  27 downloadRouter.use(
  28   STATIC_DOWNLOAD_PATHS.HLS_VIDEOS + ':id-:resolution([0-9]+)-fragmented.:extension',
  29   asyncMiddleware(videosDownloadValidator),
  30   asyncMiddleware(downloadHLSVideoFile)
  31 )
  32
  33 // ---------------------------------------------------------------------------
  34
  35 export {
  36   downloadRouter
  37 }
  38
  39 // ---------------------------------------------------------------------------
  40
  41 async function downloadTorrent (req: express.Request, res: express.Response) {
  42   const result = await VideosTorrentCache.Instance.getFilePath(req.params.filename)
  43   if (!result) {
  44     return res.fail({
  45       status: HttpStatusCode.NOT_FOUND_404,
  46       message: 'Torrent file not found'
  47     })
  48   }
  49
  50   const allowParameters = { torrentPath: result.path, downloadName: result.downloadName }
  51
  52   const allowedResult = await Hooks.wrapFun(
  53     isTorrentDownloadAllowed,
  54     allowParameters,
  55     'filter:api.download.torrent.allowed.result'
  56   )
  57
  58   if (!checkAllowResult(res, allowParameters, allowedResult)) return
  59
  60   return res.download(result.path, result.downloadName)
  61 }
  62
  63 async function downloadVideoFile (req: express.Request, res: express.Response) {
  64   const video = res.locals.videoAll
  65
  66   const videoFile = getVideoFile(req, video.VideoFiles)
  67   if (!videoFile) {
  68     return res.fail({
  69       status: HttpStatusCode.NOT_FOUND_404,
  70       message: 'Video file not found'
  71     })
  72   }
  73
  74   const allowParameters = { video, videoFile }
  75
  76   const allowedResult = await Hooks.wrapFun(
  77     isVideoDownloadAllowed,
  78     allowParameters,
  79     'filter:api.download.video.allowed.result'
  80   )
  81
  82   if (!checkAllowResult(res, allowParameters, allowedResult)) return
  83
  84   return res.download(getVideoFilePath(video, videoFile), `${video.name}-${videoFile.resolution}p${videoFile.extname}`)
  85 }
  86
  87 async function downloadHLSVideoFile (req: express.Request, res: express.Response) {
  88   const video = res.locals.videoAll
  89   const streamingPlaylist = getHLSPlaylist(video)
  90   if (!streamingPlaylist) return res.status(HttpStatusCode.NOT_FOUND_404).end
  91
  92   const videoFile = getVideoFile(req, streamingPlaylist.VideoFiles)
  93   if (!videoFile) {
  94     return res.fail({
  95       status: HttpStatusCode.NOT_FOUND_404,
  96       message: 'Video file not found'
  97     })
  98   }
  99
 100   const allowParameters = { video, streamingPlaylist, videoFile }
 101
 102   const allowedResult = await Hooks.wrapFun(
 103     isVideoDownloadAllowed,
 104     allowParameters,
 105     'filter:api.download.video.allowed.result'
 106   )
 107
 108   if (!checkAllowResult(res, allowParameters, allowedResult)) return
 109
 110   const filename = `${video.name}-${videoFile.resolution}p-${streamingPlaylist.getStringType()}${videoFile.extname}`
 111   return res.download(getVideoFilePath(streamingPlaylist, videoFile), filename)
 112 }
 113
 114 function getVideoFile (req: express.Request, files: MVideoFile[]) {
 115   const resolution = parseInt(req.params.resolution, 10)
 116   return files.find(f => f.resolution === resolution)
 117 }
 118
 119 function getHLSPlaylist (video: MVideoFullLight) {
 120   const playlist = video.VideoStreamingPlaylists.find(p => p.type === VideoStreamingPlaylistType.HLS)
 121   if (!playlist) return undefined
 122
 123   return Object.assign(playlist, { Video: video })
 124 }
 125
 126 type AllowedResult = {
 127   allowed: boolean
 128   errorMessage?: string
 129 }
 130
 131 function isTorrentDownloadAllowed (_object: {
 132   torrentPath: string
 133 }): AllowedResult {
 134   return { allowed: true }
 135 }
 136
 137 function isVideoDownloadAllowed (_object: {
 138   video: MVideo
 139   videoFile: MVideoFile
 140   streamingPlaylist?: MStreamingPlaylist
 141 }): AllowedResult {
 142   return { allowed: true }
 143 }
 144
 145 function checkAllowResult (res: express.Response, allowParameters: any, result?: AllowedResult) {
 146   if (!result || result.allowed !== true) {
 147     logger.info('Download is not allowed.', { result, allowParameters })
 148
 149     res.fail({
 150       status: HttpStatusCode.FORBIDDEN_403,
 151       message: result?.errorMessage || 'Refused download'
 152     })
 153     return false
 154   }
 155
 156   return true
 157 }