Import torrents with webtorrent

4 files changed, 37 insertions, 13 deletions

diff --git a/server/helpers/core-utils.ts b/server/helpers/core-utils.ts
index 884206aad..25eb6454a 100644
--- a/server/helpers/core-utils.ts
+++ b/server/helpers/core-utils.ts
@@ -13,6 +13,7 @@ import * as pem from 'pem'
 import * as rimraf from 'rimraf'
 import { URL } from 'url'
 import { truncate } from 'lodash'
+import * as crypto from 'crypto'
 
 function sanitizeUrl (url: string) {
   const urlObject = new URL(url)
@@ -95,6 +96,10 @@ function peertubeTruncate (str: string, maxLength: number) {
   return truncate(str, options)
 }
 
+function sha256 (str: string) {
+  return crypto.createHash('sha256').update(str).digest('hex')
+}
+
 function promisify0<A> (func: (cb: (err: any, result: A) => void) => void): () => Promise<A> {
   return function promisified (): Promise<A> {
     return new Promise<A>((resolve: (arg: A) => void, reject: (err: any) => void) => {
@@ -165,6 +170,7 @@ export {
   sanitizeHost,
   buildPath,
   peertubeTruncate,
+  sha256,
 
   promisify0,
   promisify1,
diff --git a/server/helpers/custom-validators/video-imports.ts b/server/helpers/custom-validators/video-imports.ts
index d8b9bfaff..4d6ab1fa4 100644
--- a/server/helpers/custom-validators/video-imports.ts
+++ b/server/helpers/custom-validators/video-imports.ts
@@ -1,10 +1,9 @@
 import 'express-validator'
 import 'multer'
 import * as validator from 'validator'
-import { CONSTRAINTS_FIELDS, VIDEO_IMPORT_STATES } from '../../initializers'
-import { exists } from './misc'
+import { CONSTRAINTS_FIELDS, TORRENT_MIMETYPE_EXT, VIDEO_IMPORT_STATES } from '../../initializers'
+import { exists, isFileValid } from './misc'
 import * as express from 'express'
-import { VideoChannelModel } from '../../models/video/video-channel'
 import { VideoImportModel } from '../../models/video/video-import'
 
 function isVideoImportTargetUrlValid (url: string) {
@@ -25,6 +24,12 @@ function isVideoImportStateValid (value: any) {
   return exists(value) && VIDEO_IMPORT_STATES[ value ] !== undefined
 }
 
+const videoTorrentImportTypes = Object.keys(TORRENT_MIMETYPE_EXT).map(m => `(${m})`)
+const videoTorrentImportRegex = videoTorrentImportTypes.join('|')
+function isVideoImportTorrentFile (files: { [ fieldname: string ]: Express.Multer.File[] } | Express.Multer.File[]) {
+  return isFileValid(files, videoTorrentImportRegex, 'torrentfile', CONSTRAINTS_FIELDS.VIDEO_IMPORTS.TORRENT_FILE.FILE_SIZE.max, true)
+}
+
 async function isVideoImportExist (id: number, res: express.Response) {
   const videoImport = await VideoImportModel.loadAndPopulateVideo(id)
 
@@ -45,5 +50,6 @@ async function isVideoImportExist (id: number, res: express.Response) {
 export {
   isVideoImportStateValid,
   isVideoImportTargetUrlValid,
-  isVideoImportExist
+  isVideoImportExist,
+  isVideoImportTorrentFile
 }
diff --git a/server/helpers/utils.ts b/server/helpers/utils.ts
index f4cc5547d..2ad87951e 100644
--- a/server/helpers/utils.ts
+++ b/server/helpers/utils.ts
@@ -6,11 +6,12 @@ import { CONFIG } from '../initializers'
 import { UserModel } from '../models/account/user'
 import { ActorModel } from '../models/activitypub/actor'
 import { ApplicationModel } from '../models/application/application'
-import { pseudoRandomBytesPromise, unlinkPromise } from './core-utils'
+import { pseudoRandomBytesPromise, sha256, unlinkPromise } from './core-utils'
 import { logger } from './logger'
 import { isArray } from './custom-validators/misc'
 import * as crypto from "crypto"
 import { join } from "path"
+import { Instance as ParseTorrent } from 'parse-torrent'
 
 const isCidr = require('is-cidr')
 
@@ -183,13 +184,18 @@ async function getServerActor () {
   return Promise.resolve(serverActor)
 }
 
-function generateVideoTmpPath (id: string) {
-  const hash = crypto.createHash('sha256').update(id).digest('hex')
+function generateVideoTmpPath (target: string | ParseTorrent) {
+  const id = typeof target === 'string' ? target : target.infoHash
+
+  const hash = sha256(id)
   return join(CONFIG.STORAGE.VIDEOS_DIR, hash + '-import.mp4')
 }
 
-type SortType = { sortModel: any, sortValue: string }
+function getSecureTorrentName (originalName: string) {
+  return sha256(originalName) + '.torrent'
+}
 
+type SortType = { sortModel: any, sortValue: string }
 
 // ---------------------------------------------------------------------------
 
@@ -199,6 +205,7 @@ export {
   generateRandomString,
   getFormattedObjects,
   isSignupAllowed,
+  getSecureTorrentName,
   isSignupAllowedForCurrentIP,
   computeResolutionsToTranscode,
   resetSequelizeInstance,
diff --git a/server/helpers/webtorrent.ts b/server/helpers/webtorrent.ts
index fce88a1f6..04b3ac71b 100644
--- a/server/helpers/webtorrent.ts
+++ b/server/helpers/webtorrent.ts
@@ -2,17 +2,22 @@ import { logger } from './logger'
 import { generateVideoTmpPath } from './utils'
 import * as WebTorrent from 'webtorrent'
 import { createWriteStream } from 'fs'
+import { Instance as ParseTorrent } from 'parse-torrent'
+import { CONFIG } from '../initializers'
+import { join } from 'path'
 
-function downloadWebTorrentVideo (target: string) {
-  const path = generateVideoTmpPath(target)
+function downloadWebTorrentVideo (target: { magnetUri: string, torrentName: string }) {
+  const id = target.magnetUri || target.torrentName
 
-  logger.info('Importing torrent video %s', target)
+  const path = generateVideoTmpPath(id)
+  logger.info('Importing torrent video %s', id)
 
   return new Promise<string>((res, rej) => {
     const webtorrent = new WebTorrent()
 
-    const torrent = webtorrent.add(target, torrent => {
-      if (torrent.files.length !== 1) throw new Error('The number of files is not equal to 1 for ' + target)
+    const torrentId = target.magnetUri || join(CONFIG.STORAGE.TORRENTS_DIR, target.torrentName)
+    const torrent = webtorrent.add(torrentId, torrent => {
+      if (torrent.files.length !== 1) return rej(new Error('The number of files is not equal to 1 for ' + torrentId))
 
       const file = torrent.files[ 0 ]
       file.createReadStream().pipe(createWriteStream(path))