@warren-bank/hls-proxy 2.0.1 → 3.1.0

package/hls-proxy/manifest_parser.js

@@ -1,50 +1,102 @@
+const {URL} = require('@warren-bank/url')
 const utils = require('./utils')
 
 const regexs = {
-  m3u8:         new RegExp('\\.m3u8(?:[\\?#]|$)', 'i'),
-  ts_duration:  new RegExp('^#EXT-X-TARGETDURATION:(\\d+)(?:\\.\\d+)?$', 'im'),
-  vod:          new RegExp('^(?:#EXT-X-PLAYLIST-TYPE:VOD|#EXT-X-ENDLIST)$', 'im'),
-  vod_start_at: new RegExp('#vod_start(?:_prefetch_at)?=((?:\\d+:)?(?:\\d+:)?\\d+)$', 'i'),
-  urls:         new RegExp('(^|(?<!(?:KEYFORMAT=))[\\s\'"])((?:https?:/)?/)?((?:[^\\?#/\\s\'"]*/)+?)?([^\\?#,/\\s\'"]+?)(\\.[^\\?#,/\\.\\s\'"]+(?:[\\?#][^\\s\'"]*)?)?([\\s\'"]|$)', 'img'),
-  keys:         new RegExp('(^#EXT-X-KEY:(?:.+,)?URI=")([^"]+)(".*$)', 'img')
+  vod_start_at:        /#vod_start(?:_prefetch_at)?=((?:\d+:)?(?:\d+:)?\d+)$/i,
+  m3u8_line_separator: /\s*[\r\n]+\s*/,
+  m3u8_line_landmark:  /^(#[^:]+[:]?)/,
+  m3u8_line_url:       /URI=["']([^"']+)["']/id
 }
 
-const ts_regexs = {
-  "file_ext": /^\.ts/i,
-  "sequence_number": /[^\d](\d+)$/i
+const url_location_landmarks = {
+  m3u8: {
+    same_line: [
+      '#EXT-X-MEDIA:',
+      '#EXT-X-I-FRAME-STREAM-INF:',
+      '#EXT-X-RENDITION-REPORT:',
+      '#EXT-X-DATERANGE:',
+      '#EXT-X-CONTENT-STEERING:'
+    ],
+    next_line: [
+      '#EXT-X-STREAM-INF:'
+    ]
+  },
+  ts: {
+    same_line: [
+      '#EXT-X-PART:',
+      '#EXT-X-PRELOAD-HINT:'
+    ],
+    next_line: [
+      '#EXTINF:'
+    ]
+  },
+  json: {
+    same_line: [
+      '#EXT-X-SESSION-DATA:'
+    ],
+    next_line: []
+  },
+  key: {
+    same_line: [
+      '#EXT-X-KEY:'
+    ],
+    next_line: []
+  },
+  other: {
+    same_line: [],
+    next_line: []
+  }
 }
 
-const get_ts_file_ext = function(file_name, file_ext) {
-  let ts_file_ext, matches
-
-  if (ts_regexs["file_ext"].test(file_ext)) {
-    matches = ts_regexs["sequence_number"].exec(file_name)
-    if (matches && matches.length) {
-      ts_file_ext = `_${matches[1]}${file_ext}`
+const meta_data_location_landmarks = {
+  is_vod: {
+    same_line: [
+      '#EXT-X-PLAYLIST-TYPE:',
+      '#EXT-X-ENDLIST'
+    ],
+    resolve_value: {
+      '#EXT-X-PLAYLIST-TYPE:': (m3u8_line, landmark) => {
+        const value = m3u8_line.substring(landmark.length, landmark.length + 3)
+        return (value.toUpperCase() === 'VOD')
+      },
+      '#EXT-X-ENDLIST': () => true
+    }
+  },
+  seg_duration_ms: {
+    same_line: [
+      '#EXT-X-TARGETDURATION:'
+    ],
+    resolve_value: {
+      '#EXT-X-TARGETDURATION:': (m3u8_line, landmark) => {
+        m3u8_line = m3u8_line.substring(landmark.length)
+        const value = parseInt(m3u8_line, 10)
+        return isNaN(value)
+          ? null
+          : (value * 1000)  // convert seconds to ms
+      }
     }
   }
-  return ts_file_ext
 }
 
-const get_seg_duration_ms = function(m3u8_content) {
-  try {
-    const matches  = regexs.ts_duration.exec(m3u8_content)
+const get_vod_start_at_ms = function(m3u8_url) {
+ try {
+   const matches  = regexs.vod_start_at.exec(m3u8_url)
 
-    if ((matches == null) || !Array.isArray(matches) || (matches.length < 2))
-      throw ''
+   if ((matches == null) || !Array.isArray(matches) || (matches.length < 2))
+     throw ''
 
-    let duration
-    duration = matches[1]
-    duration = parseInt(duration, 10)
-    duration = duration * 1000  // convert seconds to ms
+   let offset
+   offset = matches[1]
+   offset = parse_HHMMSS_to_seconds(offset)
+   offset = offset * 1000  // convert seconds to ms
 
-    return duration
-  }
-  catch(e) {
-    const def_duration = 10000  // 10 seconds in ms
+   return offset
+ }
+ catch(e) {
+   const def_offset = null
 
-    return def_duration
-  }
+   return def_offset
+ }
 }
 
 const parse_HHMMSS_to_seconds = function(str) {
@@ -60,25 +112,225 @@ const parse_HHMMSS_to_seconds = function(str) {
   return seconds
 }
 
-const get_vod_start_at_ms = function(m3u8_url) {
- try {
-   const matches  = regexs.vod_start_at.exec(m3u8_url)
+// returns: {
+//   meta_data:     {is_vod, seg_duration_ms},
+//   embedded_urls: [{line_index, url_indices, url_type, original_match_url, resolved_match_url, redirected_url, unencoded_url, encoded_url, referer_url}],
+//   prefetch_urls: [],
+//   modified_m3u8: ''
+// }
+const parse_manifest = function(m3u8_content, m3u8_url, referer_url, hooks, cache_segments, debug, vod_start_at_ms, redirected_base_url, should_prefetch_url) {
+  const m3u8_lines = m3u8_content.split(regexs.m3u8_line_separator)
+  m3u8_content = null
+
+  const meta_data     = {}
+  const embedded_urls = extract_embedded_urls(m3u8_lines, m3u8_url, referer_url, (cache_segments ? meta_data : null))
+  const prefetch_urls = []
+
+  if (embedded_urls && Array.isArray(embedded_urls) && embedded_urls.length) {
+    embedded_urls.forEach(embedded_url => {
+      redirect_embedded_url(embedded_url, hooks, m3u8_url, debug)
+      finalize_embedded_url(embedded_url, vod_start_at_ms, debug)
+      encode_embedded_url(embedded_url, redirected_base_url, debug)
+      get_prefetch_url(embedded_url, should_prefetch_url, prefetch_urls)
+      modify_m3u8_line(embedded_url, m3u8_lines)
+    })
+  }
 
-   if ((matches == null) || !Array.isArray(matches) || (matches.length < 2))
-     throw ''
+  return {
+    meta_data,
+    embedded_urls,
+    prefetch_urls,
+    modified_m3u8: m3u8_lines.filter(line => !!line).join("\n")
+  }
+}
 
-   let offset
-   offset = matches[1]
-   offset = parse_HHMMSS_to_seconds(offset)
-   offset = offset * 1000  // convert seconds to ms
+const extract_embedded_urls = function(m3u8_lines, m3u8_url, referer_url, meta_data) {
+  const embedded_urls = []
+
+  let m3u8_line, has_next_m3u8_line, next_m3u8_line, matches, matching_landmark, matching_url
+
+  for (let i=0; i < m3u8_lines.length; i++) {
+    m3u8_line          = m3u8_lines[i]
+    has_next_m3u8_line = ((i+1) < m3u8_lines.length)
+
+    matches = regexs.m3u8_line_landmark.exec(m3u8_line)
+    if (!matches) continue
+    matching_landmark = matches[1]
+
+    matches = regexs.m3u8_line_url.exec(m3u8_line)
+    matching_url = matches
+      ? matches[1]
+      : null
+
+    if (meta_data !== null)
+      extract_meta_data(meta_data, m3u8_line, matching_landmark)
+
+    for (let url_type in url_location_landmarks) {
+      if (matching_url && (url_location_landmarks[url_type]['same_line'].indexOf(matching_landmark) >= 0)) {
+        embedded_urls.push({
+          line_index:         i,
+          url_indices:        matches.indices[1],
+          url_type:           url_type,
+          original_match_url: matching_url,
+          resolved_match_url: (new URL(matching_url, m3u8_url)).href,
+          redirected_url:     null,
+          referer_url:        referer_url,
+          encoded_url:        null
+        })
+        break
+      }
+      if (has_next_m3u8_line && (url_location_landmarks[url_type]['next_line'].indexOf(matching_landmark) >= 0)) {
+        next_m3u8_line = m3u8_lines[i+1].trim()
+
+        if (next_m3u8_line && (next_m3u8_line[0] !== '#')) {
+          i++
+
+          embedded_urls.push({
+            line_index:         i,
+            url_indices:        null,
+            url_type:           url_type,
+            original_match_url: next_m3u8_line,
+            resolved_match_url: (new URL(next_m3u8_line, m3u8_url)).href,
+            redirected_url:     null,
+            referer_url:        referer_url,
+            encoded_url:        null
+          })
+        }
+        break
+      }
+    }
+  }
 
-   return offset
- }
- catch(e) {
-   const def_offset = null
+  return embedded_urls
+}
 
-   return def_offset
- }
+const extract_meta_data = function(meta_data, m3u8_line, matching_landmark) {
+  for (let meta_data_key in meta_data_location_landmarks) {
+    if (meta_data_location_landmarks[meta_data_key]['same_line'].indexOf(matching_landmark) >= 0) {
+      const func = meta_data_location_landmarks[meta_data_key]['resolve_value'][matching_landmark]
+      if (typeof func === 'function') {
+        const meta_data_value = func(m3u8_line, matching_landmark)
+        if ((meta_data_value !== undefined) && (meta_data_value !== null)) {
+          meta_data[meta_data_key] = meta_data_value
+        }
+      }
+    }
+  }
+}
+
+const redirect_embedded_url = function(embedded_url, hooks, m3u8_url, debug) {
+  if (hooks && (hooks instanceof Object) && hooks.redirect && (typeof hooks.redirect === 'function')) {
+    let url, url_type, referer_url, result
+
+    url         = embedded_url.resolved_match_url
+    url_type    = null
+    referer_url = null
+
+    debug(3, 'redirecting (pre-hook):', url)
+
+    try {
+      result = hooks.redirect(url, embedded_url.referer_url)
+
+      if (result) {
+        if (typeof result === 'string') {
+          url         = result
+        }
+        else if (result instanceof Object) {
+          url         = result.url
+          url_type    = result.url_type
+          referer_url = result.referer_url
+        }
+      }
+
+      if (typeof url !== 'string') throw new Error('bad return value')
+
+      url = url.trim()
+
+      if (url.length && (url.toLowerCase().indexOf('http') !== 0))
+        url = (new URL(url, m3u8_url)).href
+    }
+    catch(e) {
+      url = ''
+    }
+
+    if (url) {
+      embedded_url.redirected_url = url
+
+      if (typeof url_type === 'string') {
+        url_type = url_type.toLowerCase().trim()
+
+        if (url_type.length)
+          embedded_url.url_type = url_type
+      }
+
+      if (typeof referer_url === 'string') {
+        referer_url = referer_url.trim()
+
+        if (referer_url.length && (referer_url.toLowerCase().indexOf('http') === 0))
+          embedded_url.referer_url = referer_url
+      }
+
+      debug(3, 'redirecting (post-hook):', url)
+    }
+    else {
+      embedded_url.redirected_url = ''
+
+      debug(3, 'redirecting (post-hook):', 'URL filtered, removed from manifest')
+    }
+  }
+}
+
+const finalize_embedded_url = function(embedded_url, vod_start_at_ms, debug) {
+  if (embedded_url.redirected_url === '') {
+    embedded_url.unencoded_url = ''
+  }
+  else {
+    const url = embedded_url.redirected_url || embedded_url.resolved_match_url
+
+    if (embedded_url.url_type)
+      debug(3, 'url type:', embedded_url.url_type)
+
+    debug(2, 'redirecting:', url)
+
+    if (vod_start_at_ms && (embedded_url.url_type === 'm3u8'))
+      url += `#vod_start=${Math.floor(vod_start_at_ms/1000)}`
+
+    if (embedded_url.referer_url)
+      url += `|${embedded_url.referer_url}`
+
+    embedded_url.unencoded_url = url
+  }
+}
+
+const encode_embedded_url = function(embedded_url, redirected_base_url, debug) {
+  embedded_url.encoded_url = (embedded_url.unencoded_url)
+    ? `${redirected_base_url}/${ utils.base64_encode(embedded_url.unencoded_url) }.${embedded_url.url_type || 'other'}`
+    : ''
+
+  if (embedded_url.encoded_url)
+    debug(3, 'redirecting (proxied):', embedded_url.encoded_url)
+}
+
+const get_prefetch_url = function(embedded_url, should_prefetch_url, prefetch_urls = []) {
+  if (embedded_url.redirected_url !== '') {
+    const url = embedded_url.redirected_url || embedded_url.resolved_match_url
+
+    if (should_prefetch_url(url, embedded_url.url_type))
+      prefetch_urls.push(url)
+  }
+}
+
+const modify_m3u8_line = function(embedded_url, m3u8_lines) {
+  const {line_index, url_indices, encoded_url} = embedded_url
+
+  if (url_indices && Array.isArray(url_indices) && (url_indices.length === 2)) {
+    const m3u8_line = m3u8_lines[line_index]
+
+    m3u8_lines[line_index] = m3u8_line.substring(0, url_indices[0]) + encoded_url + m3u8_line.substring(url_indices[1])
+  }
+  else {
+    m3u8_lines[line_index] = encoded_url
+  }
 }
 
 const modify_m3u8_content = function(params, segment_cache, m3u8_content, m3u8_url, referer_url, redirected_base_url) {
@@ -93,11 +345,6 @@ const modify_m3u8_content = function(params, segment_cache, m3u8_content, m3u8_u
     m3u8_content = hooks.modify_m3u8_content(m3u8_content, m3u8_url) || m3u8_content
   }
 
-  const base_urls = {
-    "relative": m3u8_url.replace(/[\?#].*$/, '').replace(/[^\/]+$/, ''),
-    "absolute": m3u8_url.replace(/(:\/\/[^\/]+).*$/, '$1')
-  }
-
   const debug_divider = (debug_level >= 4)
     ? ('-').repeat(40)
     : ''
@@ -106,28 +353,13 @@ const modify_m3u8_content = function(params, segment_cache, m3u8_content, m3u8_u
     debug(4, 'proxied response (original m3u8):', `\n${debug_divider}\n${m3u8_content}\n${debug_divider}`)
   }
 
-  if (debug_level >= 2) {
-    m3u8_content = m3u8_content.replace(regexs.keys, function(match, head, key_url, tail) {
-      debug(2, 'key:', key_url)
-      return match
-    })
-  }
-
-  // only used with prefetch
-  const seg_duration_ms = (cache_segments)
-    ? get_seg_duration_ms(m3u8_content)
-    : null
+  let is_vod, seg_duration_ms, prefetch_urls
 
   // only used with prefetch
   const vod_start_at_ms = (cache_segments)
     ? get_vod_start_at_ms(m3u8_url)
     : null
 
-  // only used with prefetch
-  const is_vod = (cache_segments)
-    ? ((typeof vod_start_at_ms === 'number') || (!has_cache(m3u8_url) && regexs.vod.test(m3u8_content)))
-    : null
-
   // only used with prefetch
   const perform_prefetch = (cache_segments)
     ? (urls, dont_touch_access) => {
@@ -158,89 +390,17 @@ const modify_m3u8_content = function(params, segment_cache, m3u8_content, m3u8_u
       }
     : null
 
-  let prefetch_urls = []
-
-  m3u8_content = m3u8_content.replace(regexs.urls, function(match, head, abs_path, rel_path, file_name, file_ext, tail) {
-    if (
-      ((head === `"`) || (head === `'`) || (tail === `"`) || (tail === `'`)) &&
-      (head !== tail)
-    ) return match
-
-    if (
-      !abs_path && (
-           (!file_ext)
-        || ( rel_path && ( rel_path.indexOf('#EXT') === 0))
-        || (!rel_path && (file_name.indexOf('#EXT') === 0))
-      )
-    ) return match
-
-    debug(3, 'modify (raw):', {match, head, abs_path, rel_path, file_name, file_ext, tail})
+  {
+    const parsed_manifest = parse_manifest(m3u8_content, m3u8_url, referer_url, hooks, cache_segments, debug, vod_start_at_ms, redirected_base_url, should_prefetch_url)
+    is_vod          = !!parsed_manifest.meta_data.is_vod                  // default: false => hls live stream
+    seg_duration_ms = parsed_manifest.meta_data.seg_duration_ms || 10000  // default: 10 seconds in ms
+    prefetch_urls   = parsed_manifest.prefetch_urls
+    m3u8_content    = parsed_manifest.modified_m3u8
 
-    let matching_url
-    if (!abs_path) {
-      matching_url = `${base_urls.relative}${rel_path || ''}${file_name}${file_ext || ''}`
+    if (debug_level >= 4) {
+      debug(4, 'parsed manifest:', `\n${debug_divider}\n${JSON.stringify(parsed_manifest, null, 2)}\n${debug_divider}`)
     }
-    else if (abs_path[0] === '/') {
-      matching_url = `${base_urls.absolute}${abs_path}${rel_path || ''}${file_name}${file_ext || ''}`
-    }
-    else {
-      matching_url = `${abs_path}${rel_path || ''}${file_name}${file_ext || ''}`
-    }
-    matching_url = matching_url.trim()
-
-    if (hooks && (hooks instanceof Object) && hooks.redirect && (typeof hooks.redirect === 'function')) {
-      debug(3, 'redirecting (pre-hook):', matching_url)
-
-      try {
-        let result = hooks.redirect(matching_url, referer_url)
-
-        if (result) {
-          if (typeof result === 'string') {
-            matching_url = result
-          }
-          else if (result instanceof Object) {
-            if (result.matching_url) matching_url = result.matching_url
-            if (result.file_name)    file_name    = result.file_name
-            if (result.file_ext)     file_ext     = result.file_ext
-            if (result.referer_url)  referer_url  = result.referer_url
-          }
-        }
-
-        if (typeof matching_url !== 'string') throw new Error('bad return value')
-
-        if (matching_url.length && matching_url.toLowerCase().indexOf('http') !== 0) {
-          matching_url = ( (matching_url[0] === '/') ? base_urls.absolute : base_urls.relative ) + matching_url
-        }
-      }
-      catch(e) {
-        matching_url = ''
-      }
-
-      if (!matching_url) {
-        debug(3, 'redirecting (post-hook):', 'URL filtered, removed from manifest')
-        return `${head}${tail}`
-      }
-    }
-    debug(2, 'redirecting:', matching_url)
-
-    // aggregate prefetch URLs into an array while iterating.
-    // after the loop is complete, check the count.
-    // if it exceeds the size of the cache, remove overflow elements from the beginning.
-    if (should_prefetch_url(matching_url))
-      prefetch_urls.push(matching_url)
-
-    if (vod_start_at_ms && regexs.m3u8.test(matching_url))
-      matching_url += `#vod_start=${Math.floor(vod_start_at_ms/1000)}`
-
-    if (referer_url)
-      matching_url += `|${referer_url}`
-
-    let ts_file_ext    = get_ts_file_ext(file_name, file_ext)
-    let redirected_url = `${redirected_base_url}/${ utils.base64_encode(matching_url) }${ts_file_ext || file_ext || ''}`
-    debug(3, 'redirecting (proxied):', redirected_url)
-
-    return `${head}${redirected_url}${tail}`
-  })
+  }
 
   if (prefetch_urls.length) {
     if (is_vod && vod_start_at_ms) {
@@ -316,13 +476,6 @@ const modify_m3u8_content = function(params, segment_cache, m3u8_content, m3u8_u
     perform_prefetch(prefetch_urls)
   }
 
-  if (debug_level >= 3) {
-    m3u8_content = m3u8_content.replace(regexs.keys, function(match, head, key_url, tail) {
-      debug(3, 'key (proxied):', key_url)
-      return match
-    })
-  }
-
   if (debug_level >= 4) {
     debug(4, 'proxied response (modified m3u8):', `\n${debug_divider}\n${m3u8_content}\n${debug_divider}`)
   }

package/hls-proxy/proxy.js

@@ -2,19 +2,15 @@ const request = require('@warren-bank/node-request').request
 const parser  = require('./manifest_parser')
 const utils   = require('./utils')
 
-const regexs = {
-  wrap: new RegExp('^(.*)/([^\\._/\\?#]+)(?:[\\._][^/\\?#]*)?(?:[\\?#].*)?$', 'i'),
-  m3u8: new RegExp('\\.m3u8(?:[\\?#]|$)', 'i')
-}
-
 const get_middleware = function(params) {
-  const {is_secure, host, cache_segments} = params
-  let {acl_whitelist} = params
+  const {cache_segments} = params
+  let   {acl_whitelist}  = params
 
   const segment_cache = require('./segment_cache')(params)
   const {get_segment, add_listener} = segment_cache
 
   const debug               = utils.debug.bind(null, params)
+  const parse_req_url       = utils.parse_req_url.bind(null, params)
   const get_request_options = utils.get_request_options.bind(null, params)
   const modify_m3u8_content = parser.modify_m3u8_content.bind(null, params, segment_cache)
 
@@ -42,29 +38,7 @@ const get_middleware = function(params) {
 
     utils.add_CORS_headers(res)
 
-    const [url, referer_url] = (() => {
-      if (!regexs.wrap.test(req.url))
-        return ['', '']
-
-      let url, url_lc, index
-
-      url    = utils.base64_decode( req.url.replace(regexs.wrap, '$2') ).trim()
-      url_lc = url.toLowerCase()
-
-      index  = url_lc.indexOf('http')
-      if (index !== 0)
-        return ['', '']
-
-      index = url_lc.indexOf('|http')
-      if (index >=0) {
-        const referer_url = url.substring(index + 1, url.length)
-        url = url.substring(0, index).trim()
-        return [url, referer_url]
-      }
-      else {
-        return [url, '']
-      }
-    })()
+    const {redirected_base_url, url_type, url, referer_url} = parse_req_url(req)
 
     if (!url) {
       res.writeHead(400)
@@ -72,22 +46,22 @@ const get_middleware = function(params) {
       return
     }
 
-    const is_m3u8 = regexs.m3u8.test(url)
+    const is_m3u8 = (url_type === 'm3u8')
 
-    const send_ts = function(segment) {
-      res.writeHead(200, { "Content-Type": "video/MP2T" })
+    const send_cache_segment = function(segment) {
+      res.writeHead(200, { "Content-Type": utils.get_content_type(url_type) })
       res.end(segment)
     }
 
     if (cache_segments && !is_m3u8) {
-      let segment = get_segment(url)   // Buffer (cached segment data), false (prefetch is pending: add callback), undefined (no prefetch is pending)
+      let segment = get_segment(url, url_type)  // Buffer (cached segment data), false (prefetch is pending: add callback), undefined (no prefetch is pending)
 
-      if (segment && segment.length) { // Buffer (cached segment data)
-        send_ts(segment)
+      if (segment && segment.length) {          // Buffer (cached segment data)
+        send_cache_segment(segment)
         return
       }
-      else if (segment === false) {    // false (prefetch is pending: add callback)
-        add_listener(url, send_ts)
+      else if (segment === false) {             // false (prefetch is pending: add callback)
+        add_listener(url, url_type, send_cache_segment)
         return
       }
     }
@@ -108,8 +82,6 @@ const get_middleware = function(params) {
           ? redirects[(redirects.length - 1)]
           : url
 
-        const redirected_base_url = `${ is_secure ? 'https' : 'http' }://${host || req.headers.host}${req.url.replace(regexs.wrap, '$1')}`
-
         res.writeHead(200, { "Content-Type": "application/x-mpegURL" })
         res.end( modify_m3u8_content(response.toString().trim(), m3u8_url, referer_url, redirected_base_url) )
       }

package/hls-proxy/segment_cache.js

@@ -154,8 +154,6 @@ module.exports = function(params) {
   const prefetch_segment = function(m3u8_url, url, referer_url, dont_touch_access) {
     let promise = Promise.resolve()
 
-    if (! should_prefetch_url(url)) return promise
-
     if (cache[m3u8_url] === undefined) {
       // initialize a new data structure
       cache[m3u8_url] = {access: 0, ts: []}
@@ -218,8 +216,8 @@ module.exports = function(params) {
     return promise
   }
 
-  const get_segment = function(url) {
-    if (! should_prefetch_url(url)) return undefined
+  const get_segment = function(url, url_type) {
+    if (! should_prefetch_url(url, url_type)) return undefined
 
     let debug_url = (debug_level >= 3) ? url : get_publickey_from_url(url)
 
@@ -253,8 +251,8 @@ module.exports = function(params) {
     return segment
   }
 
-  const add_listener = function(url, cb) {
-    if (! should_prefetch_url(url)) return false
+  const add_listener = function(url, url_type, cb) {
+    if (! should_prefetch_url(url, url_type)) return false
 
     let debug_url = (debug_level >= 3) ? url : get_publickey_from_url(url)
 

package/hls-proxy/utils.js

@@ -1,8 +1,8 @@
-const parse_url = require('url').parse
+const parse_url = require('@warren-bank/url').parse
 
 const regexs = {
-  origin: new RegExp('^(https?://[^/]+)(?:/.*)?$', 'i'),
-  ts:     new RegExp('\\.ts(?:[\\?#]|$)', 'i')
+  req_url: new RegExp('^(.*)/([^\\._/\\?#]+)(?:[\\._]([^/\\?#]*))?(?:[\\?#].*)?$', 'i'),
+  origin:  new RegExp('^(https?://[^/]+)(?:/.*)?$', 'i')
 }
 
 // btoa
@@ -15,6 +15,61 @@ const base64_decode = function(str) {
   return Buffer.from(str, 'base64').toString('binary')
 }
 
+const parse_req_url = function(params, req) {
+  const {is_secure, host} = params
+
+  const result = {redirected_base_url: '', url_type: '', url: '', referer_url: ''}
+
+  const matches = regexs.req_url.exec(req.url)
+
+  if (matches) {
+    result.redirected_base_url = `${ is_secure ? 'https' : 'http' }://${host || req.headers.host}${matches[1] || ''}`
+
+    if (matches[3])
+      result.url_type = matches[3].toLowerCase().trim()
+
+    let url, url_lc, index
+
+    url    = base64_decode( matches[2] ).trim()
+    url_lc = url.toLowerCase()
+    index  = url_lc.indexOf('http')
+
+    if (index === 0) {
+      index = url_lc.indexOf('|http')
+
+      if (index > 0) {
+        url = url.substring(0, index).trim()
+
+        result.referer_url = url.substring(index + 1, url.length)
+      }
+      result.url = url
+    }
+  }
+
+  return result
+}
+
+const get_content_type = function(url_type) {
+  let content_type
+  switch(url_type) {
+    case 'm3u8':
+      content_type = 'application/x-mpegurl'
+      break
+    case 'ts':
+      content_type = 'video/MP2T'
+      break
+    case 'json':
+      content_type = 'application/json'
+      break
+    case 'key':
+    case 'other':
+    default:
+      content_type = 'application/octet-stream'
+      break
+  }
+  return content_type
+}
+
 const add_CORS_headers = function(res) {
   res.setHeader('Access-Control-Allow-Origin',      '*')
   res.setHeader('Access-Control-Allow-Methods',     '*')
@@ -70,16 +125,16 @@ const get_request_options = function(params, url, is_m3u8, referer_url) {
   return request_options
 }
 
-const should_prefetch_url = function(params, url) {
+const should_prefetch_url = function(params, url, url_type) {
   const {hooks, cache_segments} = params
 
-  let do_prefetch = !!cache_segments
+  let do_prefetch = !!url && !!cache_segments
 
   if (do_prefetch) {
-    do_prefetch = regexs.ts.test(url)
+    do_prefetch = (url_type === 'ts') || (url_type === 'key')
 
     if (hooks && (hooks instanceof Object) && hooks.prefetch && (typeof hooks.prefetch === 'function')) {
-      const override_prefetch = hooks.prefetch(url)
+      const override_prefetch = hooks.prefetch(url, url_type)
 
       if ((typeof override_prefetch === 'boolean') && (override_prefetch !== do_prefetch)) {
         debug(params, 3, 'prefetch override:', (override_prefetch ? 'allow' : 'deny'), url)
@@ -93,6 +148,8 @@ const should_prefetch_url = function(params, url) {
 module.exports = {
   base64_encode,
   base64_decode,
+  parse_req_url,
+  get_content_type,
   add_CORS_headers,
   debug,
   get_request_options,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@warren-bank/hls-proxy",
   "description": "Node.js server to proxy HLS video streams",
-  "version":     "2.0.1",
+  "version":     "3.1.0",
   "scripts": {
     "start":     "node hls-proxy/bin/hlsd.js",
     "sudo": "sudo node hls-proxy/bin/hlsd.js"
@@ -11,7 +11,8 @@
   },
   "dependencies": {
     "@warren-bank/node-process-argv": "^1.2.1",
-    "@warren-bank/node-request": "^2.0.10"
+    "@warren-bank/node-request": "^2.0.10",
+    "@warren-bank/url": "^3.1.0"
   },
   "license": "GPL-2.0",
   "author": {