author Sylvestre Ledru <>
Thu, 06 Jul 2017 14:00:35 +0200
changeset 418830 6a629adbb62a299d7208373d1c6f375149d2afdb
parent 393760 6a9d8f01342be19b7b82f5e91fd71e814a38aeed
child 462851 1d6d0bc1cb27eb3e90fa33367869297b451ddb9c
permissions -rw-r--r--
Bug 1378712 - Remove all trailing whitespaces r=Ehsan MozReview-Commit-ID: Kdz2xtTF9EG

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at */
#ifndef __nsmultimixedconv__h__
#define __nsmultimixedconv__h__

#include "nsIStreamConverter.h"
#include "nsIChannel.h"
#include "nsString.h"
#include "nsCOMPtr.h"
#include "nsIByteRangeRequest.h"
#include "nsILoadInfo.h"
#include "nsIMultiPartChannel.h"
#include "nsAutoPtr.h"
#include "mozilla/Attributes.h"
#include "mozilla/IncrementalTokenizer.h"
#include "nsHttpResponseHead.h"

#define NS_MULTIMIXEDCONVERTER_CID                         \
{ /* 7584CE90-5B25-11d3-A175-0050041CAF44 */         \
    0x7584ce90,                                      \
    0x5b25,                                          \
    0x11d3,                                          \
    {0xa1, 0x75, 0x0, 0x50, 0x4, 0x1c, 0xaf, 0x44}       \

// nsPartChannel is a "dummy" channel which represents an individual part of
// a multipart/mixed stream...
// Instances on this channel are passed out to the consumer through the
// nsIStreamListener interface.
class nsPartChannel final : public nsIChannel,
                            public nsIByteRangeRequest,
                            public nsIMultiPartChannel
  nsPartChannel(nsIChannel *aMultipartChannel, uint32_t aPartID,
                nsIStreamListener* aListener);

  void InitializeByteRange(int64_t aStart, int64_t aEnd);
  void SetIsLastPart() { mIsLastPart = true; }
  nsresult SendOnStartRequest(nsISupports* aContext);
  nsresult SendOnDataAvailable(nsISupports* aContext, nsIInputStream* aStream,
                               uint64_t aOffset, uint32_t aLen);
  nsresult SendOnStopRequest(nsISupports* aContext, nsresult aStatus);
  /* SetContentDisposition expects the full value of the Content-Disposition
   * header */
  void SetContentDisposition(const nsACString& aContentDispositionHeader);
  void SetResponseHead(mozilla::net::nsHttpResponseHead * head) { mResponseHead = head; }



  nsCOMPtr<nsIChannel>    mMultipartChannel;
  nsCOMPtr<nsIStreamListener> mListener;
  nsAutoPtr<mozilla::net::nsHttpResponseHead> mResponseHead;

  nsresult                mStatus;
  nsLoadFlags             mLoadFlags;

  nsCOMPtr<nsILoadGroup>  mLoadGroup;

  nsCString               mContentType;
  nsCString               mContentCharset;
  uint32_t                mContentDisposition;
  nsString                mContentDispositionFilename;
  nsCString               mContentDispositionHeader;
  uint64_t                mContentLength;

  bool                    mIsByteRangeRequest;
  int64_t                 mByteRangeStart;
  int64_t                 mByteRangeEnd;

  uint32_t                mPartID; // unique ID that can be used to identify
                                   // this part of the multipart document
  bool                    mIsLastPart;

// The nsMultiMixedConv stream converter converts a stream of type "multipart/x-mixed-replace"
// to it's subparts. There was some debate as to whether or not the functionality desired
// when HTTP confronted this type required a stream converter. After all, this type really
// prompts various viewer related actions rather than stream conversion. There simply needs
// to be a piece in place that can strip out the multiple parts of a stream of this type, and
// "display" them accordingly.
// With that said, this "stream converter" spends more time packaging up the sub parts of the
// main stream and sending them off the destination stream listener, than doing any real
// stream parsing/converting.
// WARNING: This converter requires that it's destination stream listener be able to handle
//   multiple OnStartRequest(), OnDataAvailable(), and OnStopRequest() call combinations.
//   Each series represents the beginning, data production, and ending phase of each sub-
//   part of the original stream.
// NOTE: this MIME-type is used by HTTP, *not* SMTP, or IMAP.
// NOTE: For reference, a general description of how this MIME type should be handled via
//   HTTP, see . Note that
//   real world server content deviates considerably from this overview.
// Implementation assumptions:
//  Assumed structue:
//  --BoundaryToken[\r]\n
//  content-type: foo/bar[\r]\n
//  ... (other headers if any)
//  [\r]\n (second line feed to delimit end of headers)
//  data
//  --BoundaryToken-- (end delimited by final "--")
// linebreaks can be either CRLF or LFLF. linebreaks preceding
// boundary tokens are NOT considered part of the data. BoundaryToken
// is any opaque string.

class nsMultiMixedConv : public nsIStreamConverter {

    explicit nsMultiMixedConv();

    typedef mozilla::IncrementalTokenizer::Token Token;

    virtual ~nsMultiMixedConv();

    nsresult SendStart();
    void AccumulateData(Token const & aToken);
    nsresult SendData();
    nsresult SendStop(nsresult aStatus);

    // member data
    nsCOMPtr<nsIStreamListener> mFinalListener; // this guy gets the converted data via his OnDataAvailable()

    nsCOMPtr<nsIChannel> mChannel; // The channel as we get in in OnStartRequest call
    RefPtr<nsPartChannel> mPartChannel;   // the channel for the given part we're processing.
                                        // one channel per part.
    nsCOMPtr<nsISupports> mContext;
    nsCString           mContentType;
    nsCString           mContentDisposition;
    uint64_t            mContentLength;
    uint64_t            mTotalSent;

    // The following members are for tracking the byte ranges in
    // multipart/mixed content which specified the 'Content-Range:'
    // header...
    int64_t             mByteRangeStart;
    int64_t             mByteRangeEnd;
    bool                mIsByteRangeRequest;
    // This flag is set first time we create a part channel.
    // We use it to prevent duplicated OnStopRequest call on the listener
    // when we fail from some reason to ever create a part channel that
    // ensures correct notifications.
    bool                mRequestListenerNotified;

    uint32_t            mCurrentPartID;

    // Flag preventing reenter of OnDataAvailable in case the target listener
    // ends up spinning the event loop.
    bool                mInOnDataAvailable;

    // Current state of the incremental parser
    enum EParserState {

    } mParserState;

    // Response part header value, valid when we find a header name
    // we recognize.
    enum EHeader : uint32_t {
    } mResponseHeader;
    // Cumulated value of a response header.
    nsCString mResponseHeaderValue;

    nsCString mBoundary;
    mozilla::IncrementalTokenizer mTokenizer;

    // When in the "body parsing" mode, see below, we cumulate raw data
    // incrementally to mainly avoid any unnecessary granularity.
    // mRawData points to the first byte in the tokenizer buffer where part
    // body data begins or continues.  mRawDataLength is a cumulated length
    // of that data during a single tokenizer input feed.  This is always
    // flushed right after we fed the tokenizer.
    nsACString::const_char_iterator mRawData;
    nsACString::size_type mRawDataLength;

    // At the start we don't know if the server will be sending boundary with
    // or without the leading dashes.
    Token mBoundaryToken;
    Token mBoundaryTokenWithDashes;
    // We need these custom tokens to allow finding CRLF when in the binary mode.
    // CRLF before boundary is considered part of the boundary and not part of
    // the data.
    Token mLFToken;
    Token mCRLFToken;
    // Custom tokens for each of the response headers we recognize.
    Token mHeaderTokens[HEADER_UNKNOWN];

    // Resets values driven by part headers, like content type, to their defaults,
    // called at the start of every part processing.
    void HeadersToDefault();
    // Processes captured value of mResponseHeader header.
    nsresult ProcessHeader();
    // Switches the parser and tokenizer state to "binary mode" which only searches
    // for the 'CRLF boundary' delimiter.
    void SwitchToBodyParsing();
    // Switches to the default mode, we are in this mode when parsing headers and
    // control data around the boundary delimiters.
    void SwitchToControlParsing();
    // Turns on or off recognition of the headers we recognize in part heads.
    void SetHeaderTokensEnabled(bool aEnable);

    // The main parser callback called by the IncrementalTokenizer
    // instance from OnDataAvailable or OnStopRequest.
    nsresult ConsumeToken(Token const & token);

#endif /* __nsmultimixedconv__h__ */