Byte serving

There you go, I fixed a couple of bugs. Now this is working with version 5,6 and 7 of acrobat reader.

var adTypeBinary = 1

function set_range(range, filesize){
  /*
  Sets the first and last bytes of a range, given a range expressed as a string
  and the size of the file.

  If the end of the range is not specified, or the end of the range is greater
  than the length of the file, $last is set as the end of the file.

  If the begining of the range is not specified, the meaning of the value after
  the dash is "get the last n bytes of the file".

  If $first is greater than $last, the range is not satisfiable, and we should
  return a response with a status of 416 (Requested range not satisfiable).

  Examples:
  $range='0-499', $filesize=1000 => $first=0, $last=499 .
  $range='500-', $filesize=1000 => $first=500, $last=999 .
  $range='500-1200', $filesize=1000 => $first=500, $last=999 .
  $range='-200', $filesize=1000 => $first=800, $last=999 .

  */
 
  var dash  = range.indexOf('-');
  var first = Trim(range.substr(0, dash))
  var last  = Trim(range.substr(dash+1));
  if (first=='') {
    //suffix byte range: gets last n bytes
    var suffix = last;
    last       = filesize-1;
    first      = filesize-parseInt(suffix);
    if(first<0) first = 0;
  }
  else
  {
    if (last=='' || parseInt(last) > filesize-1)
          last = filesize-1;
  }
 
  first = parseInt(first);
  last  = parseInt(last);
 
  if (first > last){
        /**
         ** Unsatisfiable range, sending status 416 will not work
         ** most of the times, but sending 0 content will.
         **/
        last = first+1;      
    //unsatisfiable range
    //Response.Status = "416 Requested range not satisfiable";
    //Response.CacheControl = "No-store"
    //Response.addHeader("Content-Range", "*/" + filesize);
    //Response.Flush();
    //Response.end
  }
 
  var returnobj = new Object();
  returnobj.first = first;
  returnobj.last  = last;       
 
  return returnobj;
}

function buffered_read(ostream, bytes, buffer_size)
{
      if (!buffer_size)
            buffer_size = 1024;
            
  /*
  Outputs up to $bytes from the file $file to standard output, $buffer_size bytes at a time.
  */
  var bytes_left = bytes;
  while(bytes_left > 0 && !ostream.EOS)
  {
    if(bytes_left > buffer_size)
      bytes_to_read = buffer_size;
    else
      bytes_to_read = bytes_left;
   
    bytes_left -= bytes_to_read;
   
    Response.BinaryWrite(ostream.Read(bytes_to_read));
    Response.Flush();
  }
}

function byteserve(filepath, filesize, contentdisposition, filename){
  /*
  Byteserves the file $filename.  

  When there is a request for a single range, the content is transmitted
  with a Content-Range header, and a Content-Length header showing the number
  of bytes actually transferred.

  When there is a request for multiple ranges, these are transmitted as a
  multipart message. The multipart media type used for this purpose is
  "multipart/byteranges".
  */
 
      Response.Clear
      var ostream = Server.CreateObject("ADODB.Stream")
      ostream.Open       
      ostream.Type = adTypeBinary
      ostream.LoadFromFile(filepath)      
      
      var boundary = "";
      var ipos = (""+Request.ServerVariables('HTTP_RANGE')).indexOf('bytes=')            
      
  ranges = new Array();
  if (Request.ServerVariables('REQUEST_METHOD')=='GET' && !isEmpty(Request.ServerVariables('HTTP_RANGE')) && (ipos >= 0))
  {
        range    = (""+Request.ServerVariables('HTTP_RANGE')).substr(ipos+6);
    boundary = '[lka9uw3et5vxybtp87ghq23dpu7djv84nhls9p]';//set a random boundary
    ranges   = range.split(",")
  }
 
  if (ranges.length > 0)
  {
    if (ranges.length > 1)
    {
          
          if (local_debug) dbl.write("Range > 1...");
      /*
      More than one range is requested.
      */

      //compute content length
      content_length = 0;
      for (var i=0; i < ranges.length; i++)
      {
        rangeobj = set_range(ranges[i], filesize);
       
        content_length += ("\r\n--" + boundary + "\r\n").length;
        content_length += ("Content-type: application/pdf\r\n").length;
        content_length += ("Content-range: bytes " + rangeobj.first + "-" + rangeobj.last + "/" + filesize + "\r\n\r\n").length;
        content_length += rangeobj.last - rangeobj.first + 1;          
      }
                  content_length += ("\r\n--" + boundary + "--\r\n").length;
                  
                  Response.status = "206 Partial content";
                   Response.CacheControl = "No-store"
          Response.addHeader("Accept-Ranges", "bytes");             
                  
      //output headers
      Response.addHeader("Content-Length", ""+content_length);
      Response.ContentType = "multipart/byteranges; boundary=" + boundary
     
      //output the content
      for (var i=0; i < ranges.length; i++)
      {
        rangeobj = set_range(ranges[i], filesize);
       
        Response.write("\r\n--" + boundary + "\r\n");
        Response.write("Content-type: application/pdf\r\n");
        Response.write("Content-range: bytes " + rangeobj.first + "-" + rangeobj.last + "/" + filesize + "\r\n\r\n");
        Response.Flush();
        ostream.position = rangeobj.first;
        buffered_read(ostream, rangeobj.last - rangeobj.first + 1);
      }
      Response.write("\r\n--" + boundary + "--\r\n");
      Response.Flush();
    } else {
      /*
      A single range is requested.
      */
                  Response.status = "206 Partial content";
                   Response.CacheControl = "No-store"
          Response.addHeader("Accept-Ranges", "bytes");                  
     
      range = ranges[0];
      rangeobj = set_range(range, filesize);  
      Response.addHeader("Content-Length", ""+(rangeobj.last - rangeobj.first + 1));
      Response.addHeader("Content-Range", "bytes " + rangeobj.first + "-" + rangeobj.last + "/" + filesize);
      Response.ContentType = "application/pdf";
      ostream.position = rangeobj.first;
      buffered_read(ostream, rangeobj.last - rangeobj.first + 1);
    }
  }
  else
  {
    //no byteserving
    Response.addHeader("Content-Length", filesize);
    Response.ContentType = "application/pdf";

            Response.addHeader("Content-Disposition", contentdisposition + "; filename=" + filename)        
    if (contentdisposition == "inline")
          Response.addHeader("Accept-Ranges", "bytes");
   
            buffered_read(ostream, filesize);
  }
  ostream.Close();
  ostream = null;
}