Ticket #3455: 0002-Bug-3455.2.-Allow-RFC1929-authentication-username-pa.patch

File 0002-Bug-3455.2.-Allow-RFC1929-authentication-username-pa.patch, 46.8 KB (added by arthuredelstein, 5 years ago)

ESR31.1.1-based 3455.2

  • netwerk/base/public/nsIProtocolProxyService.idl

    From 21947a302fb93a7694760ac3d9f7df94ebe16812 Mon Sep 17 00:00:00 2001
    From: Arthur Edelstein <arthuredelstein@gmail.com>
    Date: Tue, 21 Oct 2014 02:17:55 -0700
    Subject: [PATCH 2/2] Bug #3455.2. Allow RFC1929 authentication
     (username/password) to SOCKS servers.
    
    ---
     netwerk/base/public/nsIProtocolProxyService.idl  |  29 +++++
     netwerk/base/public/nsIProxyInfo.idl             |  12 ++-
     netwerk/base/src/nsProtocolProxyService.cpp      |  39 ++++++-
     netwerk/base/src/nsProtocolProxyService.h        |   8 ++
     netwerk/base/src/nsProxyInfo.cpp                 |  14 +++
     netwerk/base/src/nsProxyInfo.h                   |   2 +
     netwerk/base/src/nsSocketTransport2.cpp          |  84 +++++++++++----
     netwerk/base/src/nsSocketTransport2.h            |  15 +--
     netwerk/socket/nsISocketProvider.idl             |   9 +-
     netwerk/socket/nsSOCKSIOLayer.cpp                | 132 ++++++++++++++++++-----
     netwerk/socket/nsSOCKSIOLayer.h                  |   4 +-
     netwerk/socket/nsSOCKSSocketProvider.cpp         |  12 +--
     netwerk/socket/nsUDPSocketProvider.cpp           |   6 +-
     security/manager/ssl/src/nsNSSIOLayer.cpp        |  23 ++--
     security/manager/ssl/src/nsNSSIOLayer.h          |   7 +-
     security/manager/ssl/src/nsSSLSocketProvider.cpp |  12 +--
     security/manager/ssl/src/nsTLSSocketProvider.cpp |  12 +--
     17 files changed, 313 insertions(+), 107 deletions(-)
    
    diff --git a/netwerk/base/public/nsIProtocolProxyService.idl b/netwerk/base/public/nsIProtocolProxyService.idl
    index 9365658..f974f40 100644
    a b interface nsIProtocolProxyService : nsISupports 
    136136                              in nsIProxyInfo aFailoverProxy);
    137137
    138138    /**
     139     * This method may be called to construct a nsIProxyInfo instance for
     140     * a SOCKS connection, with the specified username and password.
     141     * @param aHost
     142     *        The proxy hostname or IP address.
     143     * @param aPort
     144     *        The proxy port.
     145     * @param aUsername
     146     *        The SOCKS5 username
     147     * @param aPassword
     148     *        The SOCKS5 password
     149     * @param aFlags
     150     *        Flags associated with this connection.  See nsIProxyInfo.idl
     151     *        for currently defined flags.
     152     * @param aFailoverTimeout
     153     *        Specifies the length of time (in seconds) to ignore this proxy if
     154     *        this proxy fails.  Pass UINT32_MAX to specify the default
     155     *        timeout value, causing nsIProxyInfo::failoverTimeout to be
     156     *        assigned the default value.
     157     * @param aFailoverProxy
     158     *        Specifies the next proxy to try if this proxy fails.  This
     159     *        parameter may be null.
     160     */
     161    nsIProxyInfo newSOCKSProxyInfo(in AUTF8String aHost, in long aPort,
     162                                   in ACString aUsername, in ACString aPassword,
     163                                   in unsigned long aFlags,
     164                                   in unsigned long aFailoverTimeout,
     165                                   in nsIProxyInfo aFailoverProxy);
     166
     167    /**
    139168     * If the proxy identified by aProxyInfo is unavailable for some reason,
    140169     * this method may be called to access an alternate proxy that may be used
    141170     * instead.  As a side-effect, this method may affect future result values
  • netwerk/base/public/nsIProxyInfo.idl

    diff --git a/netwerk/base/public/nsIProxyInfo.idl b/netwerk/base/public/nsIProxyInfo.idl
    index f6f0bf3..56beb02 100644
    a b  
    88/**
    99 * This interface identifies a proxy server.
    1010 */
    11 [scriptable, uuid(9e557d99-7af0-4895-95b7-e6dba28c9ad9)]
     11[scriptable, uuid(63fff172-2564-4138-96c6-3ae7d245fbed)]
    1212interface nsIProxyInfo : nsISupports
    1313{
    1414  /**
    interface nsIProxyInfo : nsISupports 
    5050  readonly attribute unsigned long resolveFlags;
    5151
    5252  /**
     53   * Specifies a SOCKS5 username.
     54   */
     55  readonly attribute ACString username;
     56
     57  /**
     58   * Specifies a SOCKS5 password.
     59   */
     60  readonly attribute ACString password;
     61
     62  /**
    5363   * This attribute specifies the failover timeout in seconds for this proxy.
    5464   * If a nsIProxyInfo is reported as failed via nsIProtocolProxyService::
    5565   * getFailoverForProxy, then the failed proxy will not be used again for this
  • netwerk/base/src/nsProtocolProxyService.cpp

    diff --git a/netwerk/base/src/nsProtocolProxyService.cpp b/netwerk/base/src/nsProtocolProxyService.cpp
    index 3878c58d..ed8b311 100644
    a b nsProtocolProxyService::PrefsChanged(nsIPrefBranch *prefBranch, 
    516516    if (!pref || !strcmp(pref, PROXY_PREF("socks_port")))
    517517        proxy_GetIntPref(prefBranch, PROXY_PREF("socks_port"), mSOCKSProxyPort);
    518518
     519    if (!pref || !strcmp(pref, PROXY_PREF("socks_username")))
     520        proxy_GetStringPref(prefBranch, PROXY_PREF("socks_username"), mSOCKSProxyUsername);
     521
     522    if (!pref || !strcmp(pref, PROXY_PREF("socks_password")))
     523        proxy_GetStringPref(prefBranch, PROXY_PREF("socks_password"), mSOCKSProxyPassword);
     524
    519525    if (!pref || !strcmp(pref, PROXY_PREF("socks_version"))) {
    520526        int32_t version;
    521527        proxy_GetIntPref(prefBranch, PROXY_PREF("socks_version"), version);
    nsProtocolProxyService::NewProxyInfo(const nsACString &aType, 
    11881194    }
    11891195    NS_ENSURE_TRUE(type, NS_ERROR_INVALID_ARG);
    11901196
    1191     if (aPort <= 0)
    1192         aPort = -1;
     1197    return NewProxyInfo_Internal(type, aHost, aPort,
     1198                                 mSOCKSProxyUsername, mSOCKSProxyPassword,
     1199                                 aFlags, aFailoverTimeout,
     1200                                 aFailoverProxy, 0, aResult);
     1201}
    11931202
    1194     return NewProxyInfo_Internal(type, aHost, aPort, aFlags, aFailoverTimeout,
     1203NS_IMETHODIMP
     1204nsProtocolProxyService::NewSOCKSProxyInfo(const nsACString &aHost,
     1205                                          int32_t aPort,
     1206                                          const nsACString &aUsername,
     1207                                          const nsACString &aPassword,
     1208                                          uint32_t aFlags,
     1209                                          uint32_t aFailoverTimeout,
     1210                                          nsIProxyInfo *aFailoverProxy,
     1211                                          nsIProxyInfo **aResult)
     1212{
     1213    return NewProxyInfo_Internal(kProxyType_SOCKS, aHost, aPort,
     1214                                 aUsername, aPassword,
     1215                                 aFlags, aFailoverTimeout,
    11951216                                 aFailoverProxy, 0, aResult);
    11961217}
    11971218
    nsresult 
    14961517nsProtocolProxyService::NewProxyInfo_Internal(const char *aType,
    14971518                                              const nsACString &aHost,
    14981519                                              int32_t aPort,
     1520                                              const nsACString &aUsername,
     1521                                              const nsACString &aPassword,
    14991522                                              uint32_t aFlags,
    15001523                                              uint32_t aFailoverTimeout,
    15011524                                              nsIProxyInfo *aFailoverProxy,
    15021525                                              uint32_t aResolveFlags,
    15031526                                              nsIProxyInfo **aResult)
    15041527{
     1528    if (aPort <= 0)
     1529        aPort = -1;
     1530
    15051531    nsCOMPtr<nsProxyInfo> failover;
    15061532    if (aFailoverProxy) {
    15071533        failover = do_QueryInterface(aFailoverProxy);
    nsProtocolProxyService::NewProxyInfo_Internal(const char *aType, 
    15151541    proxyInfo->mType = aType;
    15161542    proxyInfo->mHost = aHost;
    15171543    proxyInfo->mPort = aPort;
     1544    proxyInfo->mUsername = aUsername;
     1545    proxyInfo->mPassword = aPassword;
    15181546    proxyInfo->mFlags = aFlags;
    15191547    proxyInfo->mResolveFlags = aResolveFlags;
    15201548    proxyInfo->mTimeout = aFailoverTimeout == UINT32_MAX
    nsProtocolProxyService::Resolve_Internal(nsIChannel *channel, 
    16801708    }
    16811709
    16821710    if (type) {
    1683         rv = NewProxyInfo_Internal(type, *host, port, proxyFlags,
    1684                                    UINT32_MAX, nullptr, flags,
     1711        rv = NewProxyInfo_Internal(type, *host, port,
     1712                                   mSOCKSProxyUsername, mSOCKSProxyPassword,
     1713                                   proxyFlags, UINT32_MAX, nullptr, flags,
    16851714                                   result);
    16861715        if (NS_FAILED(rv))
    16871716            return rv;
  • netwerk/base/src/nsProtocolProxyService.h

    diff --git a/netwerk/base/src/nsProtocolProxyService.h b/netwerk/base/src/nsProtocolProxyService.h
    index 9ef68b9..04c642f 100644
    a b protected: 
    177177     *        The proxy host name (UTF-8 ok).
    178178     * @param port
    179179     *        The proxy port number.
     180     * @param username
     181     *        The username for the proxy (ASCII). May be "", but not null.
     182     * @param password
     183     *        The password for the proxy (ASCII). May be "", but not null.
    180184     * @param flags
    181185     *        The proxy flags (nsIProxyInfo::flags).
    182186     * @param timeout
    protected: 
    191195    NS_HIDDEN_(nsresult) NewProxyInfo_Internal(const char *type,
    192196                                               const nsACString &host,
    193197                                               int32_t port,
     198                                               const nsACString &username,
     199                                               const nsACString &password,
    194200                                               uint32_t flags,
    195201                                               uint32_t timeout,
    196202                                               nsIProxyInfo *next,
    protected: 
    374380    int32_t                      mSOCKSProxyPort;
    375381    int32_t                      mSOCKSProxyVersion;
    376382    bool                         mSOCKSProxyRemoteDNS;
     383    nsCString                    mSOCKSProxyUsername;
     384    nsCString                    mSOCKSProxyPassword;
    377385
    378386    nsRefPtr<nsPACMan>           mPACMan;  // non-null if we are using PAC
    379387    nsCOMPtr<nsISystemProxySettings> mSystemProxySettings;
  • netwerk/base/src/nsProxyInfo.cpp

    diff --git a/netwerk/base/src/nsProxyInfo.cpp b/netwerk/base/src/nsProxyInfo.cpp
    index 4e727c4..66a78a4 100644
    a b nsProxyInfo::GetResolveFlags(uint32_t *result) 
    4848}
    4949
    5050NS_IMETHODIMP
     51nsProxyInfo::GetUsername(nsACString &result)
     52{
     53  result = mUsername;
     54  return NS_OK;
     55}
     56
     57NS_IMETHODIMP
     58nsProxyInfo::GetPassword(nsACString &result)
     59{
     60  result = mPassword;
     61  return NS_OK;
     62}
     63
     64NS_IMETHODIMP
    5165nsProxyInfo::GetFailoverTimeout(uint32_t *result)
    5266{
    5367  *result = mTimeout;
  • netwerk/base/src/nsProxyInfo.h

    diff --git a/netwerk/base/src/nsProxyInfo.h b/netwerk/base/src/nsProxyInfo.h
    index 550bbf2..5432d95 100644
    a b private: 
    5959
    6060  const char  *mType;  // pointer to statically allocated value
    6161  nsCString    mHost;
     62  nsCString    mUsername;
     63  nsCString    mPassword;
    6264  int32_t      mPort;
    6365  uint32_t     mFlags;
    6466  uint32_t     mResolveFlags;
  • netwerk/base/src/nsSocketTransport2.cpp

    diff --git a/netwerk/base/src/nsSocketTransport2.cpp b/netwerk/base/src/nsSocketTransport2.cpp
    index e202044..ea0dd68 100644
    a b nsSocketTransport::nsSocketTransport() 
    751751    : mTypes(nullptr)
    752752    , mTypeCount(0)
    753753    , mPort(0)
    754     , mProxyPort(0)
     754    , mHttpsProxy(false)
     755    , mProxyUse(false)
    755756    , mProxyTransparent(false)
    756757    , mProxyTransparentResolvesHost(false)
    757758    , mConnectionFlags(0)
    nsSocketTransport::Init(const char **types, uint32_t typeCount, 
    813814
    814815    const char *proxyType = nullptr;
    815816    if (proxyInfo) {
    816         mProxyPort = proxyInfo->Port();
    817         mProxyHost = proxyInfo->Host();
     817        mProxyInfo = proxyInfo;
    818818        // grab proxy type (looking for "socks" for example)
    819819        proxyType = proxyInfo->Type();
    820820        if (proxyType && (strcmp(proxyType, "http") == 0 ||
    821821                          strcmp(proxyType, "direct") == 0 ||
    822822                          strcmp(proxyType, "unknown") == 0))
    823823            proxyType = nullptr;
     824
     825        mProxyUse = true;
     826        // check that we don't have a proxyInfo without proxy
     827        nsCString proxyHost;
     828        proxyInfo->GetHost(proxyHost);
     829        if (!proxyType || proxyHost.IsEmpty()) {
     830            mProxyUse = false;
     831        }
    824832    }
    825833
    826     SOCKET_LOG(("nsSocketTransport::Init [this=%p host=%s:%hu proxy=%s:%hu]\n",
    827         this, mHost.get(), mPort, mProxyHost.get(), mProxyPort));
     834    SOCKET_LOG(("nsSocketTransport::Init [this=%x host=%s:%hu proxy=%s]\n",
     835        this, mHost.get(), mPort, mProxyUse ? "yes" : "no"));
    828836
    829837    // include proxy type as a socket type if proxy type is not "http"
    830838    mTypeCount = typeCount + (proxyType != nullptr);
    nsSocketTransport::ResolveHost() 
    9971005
    9981006    nsresult rv;
    9991007
    1000     if (!mProxyHost.IsEmpty()) {
     1008    if (mProxyUse) {
    10011009        if (!mProxyTransparent || mProxyTransparentResolvesHost) {
    10021010#if defined(XP_UNIX)
    10031011            NS_ABORT_IF_FALSE(!mNetAddrIsSet || mNetAddr.raw.family != AF_LOCAL,
    nsSocketTransport::BuildSocket(PRFileDesc *&fd, bool &proxyTransparent, bool &us 
    10791087
    10801088        const char *host       = mHost.get();
    10811089        int32_t     port       = (int32_t) mPort;
    1082         const char *proxyHost  = mProxyHost.IsEmpty() ? nullptr : mProxyHost.get();
    1083         int32_t     proxyPort  = (int32_t) mProxyPort;
    10841090        uint32_t    proxyFlags = 0;
     1091        nsCOMPtr<nsIProxyInfo> proxy = mProxyInfo;
    10851092
    10861093        uint32_t i;
    10871094        for (i=0; i<mTypeCount; ++i) {
    nsSocketTransport::BuildSocket(PRFileDesc *&fd, bool &proxyTransparent, bool &us 
    11021109            if (mConnectionFlags & nsISocketTransport::NO_PERMANENT_STORAGE)
    11031110                proxyFlags |= nsISocketProvider::NO_PERMANENT_STORAGE;
    11041111
     1112
    11051113            nsCOMPtr<nsISupports> secinfo;
    11061114            if (i == 0) {
    11071115                // if this is the first type, we'll want the
    11081116                // service to allocate a new socket
     1117                nsCString proxyHost;
     1118                GetHost(proxyHost);
     1119                int32_t proxyPort;
     1120                GetPort(&proxyPort);
    11091121                rv = provider->NewSocket(mNetAddr.raw.family,
    1110                                          host, port, proxyHost, proxyPort,
     1122                                         mHttpsProxy ? proxyHost.get() : host,
     1123                                         mHttpsProxy ? proxyPort : port,
     1124                                         proxy,
    11111125                                         proxyFlags, &fd,
    11121126                                         getter_AddRefs(secinfo));
    11131127
    nsSocketTransport::BuildSocket(PRFileDesc *&fd, bool &proxyTransparent, bool &us 
    11211135                // so we just want the service to add itself
    11221136                // to the stack (such as pushing an io layer)
    11231137                rv = provider->AddToSocket(mNetAddr.raw.family,
    1124                                            host, port, proxyHost, proxyPort,
     1138                                           host, port, proxy,
    11251139                                           proxyFlags, fd,
    11261140                                           getter_AddRefs(secinfo));
    11271141            }
    nsSocketTransport::BuildSocket(PRFileDesc *&fd, bool &proxyTransparent, bool &us 
    11511165                     (strcmp(mTypes[i], "socks4") == 0)) {
    11521166                // since socks is transparent, any layers above
    11531167                // it do not have to worry about proxy stuff
    1154                 proxyHost = nullptr;
    1155                 proxyPort = -1;
     1168                proxy = nullptr;
    11561169                proxyTransparent = true;
    11571170            }
    11581171        }
    nsSocketTransport::InitiateSocket() 
    12111224                                 netAddrCString.BeginWriting(),
    12121225                                 kIPv6CStrBufSize))
    12131226                netAddrCString = NS_LITERAL_CSTRING("<IP-to-string failed>");
     1227            nsCString proxyHost;
     1228            GetHost(proxyHost);
     1229            int32_t proxyPort;
     1230            GetPort(&proxyPort);
    12141231            SOCKET_LOG(("nsSocketTransport::InitiateSocket skipping "
    12151232                        "speculative connection for host [%s:%d] proxy "
    12161233                        "[%s:%d] with Local IP address [%s]",
    1217                         mHost.get(), mPort, mProxyHost.get(), mProxyPort,
     1234                        mHost.get(), mPort, proxyHost.get(), proxyPort,
    12181235                        netAddrCString.get()));
    12191236        }
    12201237#endif
    nsSocketTransport::InitiateSocket() 
    13631380            //
    13641381            OnSocketConnected();
    13651382
    1366             if (mSecInfo && !mProxyHost.IsEmpty() && proxyTransparent && usingSSL) {
     1383            if (mSecInfo && mProxyUse && proxyTransparent && usingSSL) {
    13671384                // if the connection phase is finished, and the ssl layer has
    13681385                // been pushed, and we were proxying (transparently; ie. nothing
    13691386                // has to happen in the protocol layer above us), it's time for
    nsSocketTransport::InitiateSocket() 
    13871404        // the OS error
    13881405        //
    13891406        else if (PR_UNKNOWN_ERROR == code &&
    1390                  mProxyTransparent &&
    1391                  !mProxyHost.IsEmpty()) {
     1407                 mProxyUse && mProxyTransparent) {
    13921408            code = PR_GetOSError();
    13931409            rv = ErrorAccordingToNSPR(code);
    13941410        }
    nsSocketTransport::InitiateSocket() 
    13971413        //
    13981414        else {
    13991415            rv = ErrorAccordingToNSPR(code);
    1400             if ((rv == NS_ERROR_CONNECTION_REFUSED) && !mProxyHost.IsEmpty())
     1416            if (rv == NS_ERROR_CONNECTION_REFUSED && mProxyUse)
    14011417                rv = NS_ERROR_PROXY_CONNECTION_REFUSED;
    14021418        }
    14031419    }
    nsSocketTransport::OnSocketEvent(uint32_t type, nsresult status, nsISupports *pa 
    17091725            // For SOCKS proxies (mProxyTransparent == true), the socket
    17101726            // transport resolves the real host here, so there's no fixup
    17111727            // (see bug 226943).
    1712             if ((status == NS_ERROR_UNKNOWN_HOST) && !mProxyTransparent &&
    1713                 !mProxyHost.IsEmpty())
     1728            if (status == NS_ERROR_UNKNOWN_HOST && !mProxyTransparent &&
     1729                mProxyUse)
    17141730                mCondition = NS_ERROR_UNKNOWN_PROXY_HOST;
    17151731            else
    17161732                mCondition = status;
    nsSocketTransport::OnSocketReady(PRFileDesc *fd, int16_t outFlags) 
    18351851            // The SOCKS proxy rejected our request. Find out why.
    18361852            //
    18371853            else if (PR_UNKNOWN_ERROR == code &&
    1838                      mProxyTransparent &&
    1839                      !mProxyHost.IsEmpty()) {
     1854                     mProxyUse && mProxyTransparent) {
    18401855                code = PR_GetOSError();
    18411856                mCondition = ErrorAccordingToNSPR(code);
    18421857            }
    nsSocketTransport::OnSocketReady(PRFileDesc *fd, int16_t outFlags) 
    18451860                // else, the connection failed...
    18461861                //
    18471862                mCondition = ErrorAccordingToNSPR(code);
    1848                 if ((mCondition == NS_ERROR_CONNECTION_REFUSED) && !mProxyHost.IsEmpty())
     1863                if (mCondition == NS_ERROR_CONNECTION_REFUSED && mProxyUse)
    18491864                    mCondition = NS_ERROR_PROXY_CONNECTION_REFUSED;
    18501865                SOCKET_LOG(("  connection failed! [reason=%x]\n", mCondition));
    18511866            }
    nsSocketTransport::GetPort(int32_t *port) 
    21682183    return NS_OK;
    21692184}
    21702185
     2186const nsCString &
     2187nsSocketTransport::SocketHost()
     2188{
     2189  if (mProxyInfo && !mProxyTransparent) {
     2190    if (mProxyHostCache.IsEmpty()) {
     2191      mProxyInfo->GetHost(mProxyHostCache);
     2192    }
     2193    return mProxyHostCache;
     2194  }
     2195  else
     2196    return mHost;
     2197}
     2198
     2199uint16_t
     2200nsSocketTransport::SocketPort()
     2201{
     2202  if (mProxyInfo && !mProxyTransparent) {
     2203    int32_t result;
     2204    mProxyInfo->GetPort(&result);
     2205    return (uint16_t) result;
     2206  }
     2207  else
     2208    return mPort;
     2209}
     2210
    21712211NS_IMETHODIMP
    21722212nsSocketTransport::GetPeerAddr(NetAddr *addr)
    21732213{
  • netwerk/base/src/nsSocketTransport2.h

    diff --git a/netwerk/base/src/nsSocketTransport2.h b/netwerk/base/src/nsSocketTransport2.h
    index 8d822bf..73f750e 100644
    a b private: 
    266266    char       **mTypes;
    267267    uint32_t     mTypeCount;
    268268    nsCString    mHost;
    269     nsCString    mProxyHost;
    270269    uint16_t     mPort;
    271     uint16_t     mProxyPort;
    272     bool mProxyTransparent;
    273     bool mProxyTransparentResolvesHost;
     270    bool         mHttpsProxy;
     271
     272    nsCOMPtr<nsIProxyInfo> mProxyInfo;
     273    bool         mProxyUse;
     274    bool         mProxyTransparent;
     275    bool         mProxyTransparentResolvesHost;
    274276    uint32_t     mConnectionFlags;
    275277   
    276     uint16_t         SocketPort() { return (!mProxyHost.IsEmpty() && !mProxyTransparent) ? mProxyPort : mPort; }
    277     const nsCString &SocketHost() { return (!mProxyHost.IsEmpty() && !mProxyTransparent) ? mProxyHost : mHost; }
     278    uint16_t         SocketPort();
     279    const nsCString &SocketHost();
     280    nsCString        mProxyHostCache; // for SocketHost() only
    278281
    279282    //-------------------------------------------------------------------------
    280283    // members accessible only on the socket transport thread:
  • netwerk/socket/nsISocketProvider.idl

    diff --git a/netwerk/socket/nsISocketProvider.idl b/netwerk/socket/nsISocketProvider.idl
    index 57f6c4d..0dd316c 100644
    a b  
    55
    66#include "nsISupports.idl"
    77
     8interface nsIProxyInfo;
    89[ptr] native PRFileDescStar(struct PRFileDesc);
    910
    1011/**
    1112 * nsISocketProvider
    1213 */
    13 [scriptable, uuid(00b3df92-e830-11d8-d48e-0004e22243f8)]
     14[scriptable, uuid(508d5469-9e1e-4a08-b5b0-7cfebba1e51a)]
    1415interface nsISocketProvider : nsISupports
    1516{
    1617    /**
    interface nsISocketProvider : nsISupports 
    3839    void newSocket(in long            aFamily,
    3940                   in string          aHost,
    4041                   in long            aPort,
    41                    in string          aProxyHost,
    42                    in long            aProxyPort,
     42                   in nsIProxyInfo    aProxy,
    4343                   in unsigned long   aFlags,
    4444                   out PRFileDescStar aFileDesc,
    4545                   out nsISupports    aSecurityInfo);
    interface nsISocketProvider : nsISupports 
    5858    void addToSocket(in long           aFamily,
    5959                     in string         aHost,
    6060                     in long           aPort,
    61                      in string         aProxyHost,
    62                      in long           aProxyPort,
     61                     in nsIProxyInfo   aProxy,
    6362                     in unsigned long  aFlags,
    6463                     in PRFileDescStar aFileDesc,
    6564                     out nsISupports   aSecurityInfo);
  • netwerk/socket/nsSOCKSIOLayer.cpp

    diff --git a/netwerk/socket/nsSOCKSIOLayer.cpp b/netwerk/socket/nsSOCKSIOLayer.cpp
    index e03b94c..f317fb9 100644
    a b class nsSOCKSSocketInfo : public nsISOCKSSocketInfo 
    5050        SOCKS4_READ_CONNECT_RESPONSE,
    5151        SOCKS5_WRITE_AUTH_REQUEST,
    5252        SOCKS5_READ_AUTH_RESPONSE,
     53        SOCKS5_WRITE_USERNAME_REQUEST,
     54        SOCKS5_READ_USERNAME_RESPONSE,
    5355        SOCKS5_WRITE_CONNECT_REQUEST,
    5456        SOCKS5_READ_CONNECT_RESPONSE_TOP,
    5557        SOCKS5_READ_CONNECT_RESPONSE_BOTTOM,
    class nsSOCKSSocketInfo : public nsISOCKSSocketInfo 
    5961
    6062    // A buffer of 262 bytes should be enough for any request and response
    6163    // in case of SOCKS4 as well as SOCKS5
    62     static const uint32_t BUFFER_SIZE = 262;
     64    static const uint32_t BUFFER_SIZE = 513;
    6365    static const uint32_t MAX_HOSTNAME_LEN = 255;
    6466
    6567public:
    public: 
    7274
    7375    void Init(int32_t version,
    7476              int32_t family,
    75               const char *proxyHost,
    76               int32_t proxyPort,
     77              nsIProxyInfo *proxy,
    7778              const char *destinationHost,
    7879              uint32_t flags);
    7980
    private: 
    9596    PRStatus ReadV4ConnectResponse();
    9697    PRStatus WriteV5AuthRequest();
    9798    PRStatus ReadV5AuthResponse();
     99    PRStatus WriteV5UsernameRequest();
     100    PRStatus ReadV5UsernameResponse();
    98101    PRStatus WriteV5ConnectRequest();
    99102    PRStatus ReadV5AddrTypeAndLength(uint8_t *type, uint32_t *len);
    100103    PRStatus ReadV5ConnectResponseTop();
    private: 
    130133    PRFileDesc             *mFD;
    131134
    132135    nsCString mDestinationHost;
    133     nsCString mProxyHost;
    134     int32_t   mProxyPort;
     136    nsCOMPtr<nsIProxyInfo> mProxy;
    135137    int32_t   mVersion;   // SOCKS version 4 or 5
    136138    int32_t   mDestinationFamily;
    137139    uint32_t  mFlags;
    private: 
    139141    NetAddr   mExternalProxyAddr;
    140142    NetAddr   mDestinationAddr;
    141143    PRIntervalTime mTimeout;
     144    nsCString mProxyUsername; // Cache, from mProxy
    142145};
    143146
    144147nsSOCKSSocketInfo::nsSOCKSSocketInfo()
    nsSOCKSSocketInfo::nsSOCKSSocketInfo() 
    147150    , mDataLength(0)
    148151    , mReadOffset(0)
    149152    , mAmountToRead(0)
    150     , mProxyPort(-1)
    151153    , mVersion(-1)
    152154    , mDestinationFamily(AF_INET)
    153155    , mFlags(0)
    nsSOCKSSocketInfo::nsSOCKSSocketInfo() 
    169171}
    170172
    171173void
    172 nsSOCKSSocketInfo::Init(int32_t version, int32_t family, const char *proxyHost, int32_t proxyPort, const char *host, uint32_t flags)
     174nsSOCKSSocketInfo::Init(int32_t version, int32_t family, nsIProxyInfo *proxy, const char *host, uint32_t flags)
    173175{
    174176    mVersion         = version;
    175177    mDestinationFamily = family;
    176     mProxyHost       = proxyHost;
    177     mProxyPort       = proxyPort;
     178    mProxy           = proxy;
    178179    mDestinationHost = host;
    179180    mFlags           = flags;
     181    mProxy->GetUsername(mProxyUsername); // cache
    180182}
    181183
    182184NS_IMPL_ISUPPORTS(nsSOCKSSocketInfo, nsISOCKSSocketInfo, nsIDNSListener)
    nsSOCKSSocketInfo::StartDNS(PRFileDesc *fd) 
    263265    if (!dns)
    264266        return PR_FAILURE;
    265267
     268    nsCString proxyHost;
     269    mProxy->GetHost(proxyHost);
     270
    266271    mFD  = fd;
    267     nsresult rv = dns->AsyncResolve(mProxyHost, 0, this,
     272    nsresult rv = dns->AsyncResolve(proxyHost, 0, this,
    268273                                    NS_GetCurrentThread(),
    269274                                    getter_AddRefs(mLookup));
    270275
    271276    if (NS_FAILED(rv)) {
    272277        LOGERROR(("socks: DNS lookup for SOCKS proxy %s failed",
    273                   mProxyHost.get()));
     278                  proxyHost.get()));
    274279        return PR_FAILURE;
    275280    }
    276281    mState = SOCKS_DNS_IN_PROGRESS;
    nsSOCKSSocketInfo::ConnectToProxy(PRFileDesc *fd) 
    315320        mVersion = 5;
    316321    }
    317322
     323    int32_t proxyPort;
     324    mProxy->GetPort(&proxyPort);
     325
    318326    int32_t addresses = 0;
    319327    do {
    320328        if (addresses++)
    321             mDnsRec->ReportUnusable(mProxyPort);
     329            mDnsRec->ReportUnusable(proxyPort);
    322330       
    323         rv = mDnsRec->GetNextAddr(mProxyPort, &mInternalProxyAddr);
     331        rv = mDnsRec->GetNextAddr(proxyPort, &mInternalProxyAddr);
    324332        // No more addresses to try? If so, we'll need to bail
    325333        if (NS_FAILED(rv)) {
     334            nsCString proxyHost;
     335            mProxy->GetHost(proxyHost);
    326336            LOGERROR(("socks: unable to connect to SOCKS proxy, %s",
    327                      mProxyHost.get()));
     337                     proxyHost.get()));
    328338            return PR_FAILURE;
    329339        }
    330340
    nsSOCKSSocketInfo::WriteV4ConnectRequest() 
    465475        // than 0, is used to notify the proxy that this is a SOCKS 4a
    466476        // request. This request type works for Tor and perhaps others.
    467477        WriteUint32(htonl(0x00000001)); // Fake IP
    468         WriteUint8(0x00); // Send an emtpy username
     478        WriteString(mProxyUsername); // Send username. May be empty.
     479        WriteUint8(0x00); // Null-terminate username
     480        // Password not supported by V4.
    469481        if (mDestinationHost.Length() > MAX_HOSTNAME_LEN) {
    470482            LOGERROR(("socks4: destination host name is too long!"));
    471483            HandshakeFinished(PR_BAD_ADDRESS_ERROR);
    nsSOCKSSocketInfo::WriteV4ConnectRequest() 
    475487        WriteUint8(0x00);
    476488    } else if (addr->raw.family == AF_INET) {
    477489        WriteNetAddr(addr); // Add the IPv4 address
    478         WriteUint8(0x00); // Send an emtpy username
     490        WriteString(mProxyUsername); // Send username. May be empty.
     491        WriteUint8(0x00); // Null-terminate username
     492        // Password not supported by V4.
    479493    } else if (addr->raw.family == AF_INET6) {
    480494        LOGERROR(("socks: SOCKS 4 can't handle IPv6 addresses!"));
    481495        HandshakeFinished(PR_BAD_ADDRESS_ERROR);
    nsSOCKSSocketInfo::WriteV5AuthRequest() 
    518532{
    519533    NS_ABORT_IF_FALSE(mVersion == 5, "SOCKS version must be 5!");
    520534
     535    mDataLength = 0;
    521536    mState = SOCKS5_WRITE_AUTH_REQUEST;
    522537
    523538    // Send an initial SOCKS 5 greeting
    524539    LOGDEBUG(("socks5: sending auth methods"));
    525540    WriteUint8(0x05); // version -- 5
    526     WriteUint8(0x01); // # auth methods -- 1
    527     WriteUint8(0x00); // we don't support authentication
     541    WriteUint8(0x01); // # of auth methods -- 1
     542    if (mProxyUsername.IsEmpty()) {
     543      WriteUint8(0x00); // no authentication
     544    } else {
     545      WriteUint8(0x02); // username/password
     546    }
    528547
    529548    return PR_SUCCESS;
    530549}
    nsSOCKSSocketInfo::ReadV5AuthResponse() 
    537556    NS_ABORT_IF_FALSE(mDataLength == 2,
    538557                      "SOCKS 5 auth method reply must be 2 bytes!");
    539558
    540     LOGDEBUG(("socks5: checking auth method reply"));
    541 
    542559    // Check version number
    543560    if (ReadUint8() != 0x05) {
    544561        LOGERROR(("socks5: unexpected version in the reply"));
    nsSOCKSSocketInfo::ReadV5AuthResponse() 
    546563        return PR_FAILURE;
    547564    }
    548565
    549     // Make sure our authentication choice was accepted
    550     if (ReadUint8() != 0x00) {
     566    // Make sure our authentication choice was accepted,
     567    // and continue accordingly
     568    uint8_t authMethod = ReadUint8();
     569    if (mProxyUsername.IsEmpty() && authMethod == 0x00) { // no auth
     570        LOGDEBUG(("socks5: server allows connection without authentication"));
     571        return WriteV5ConnectRequest();
     572    } else if (!mProxyUsername.IsEmpty() && authMethod == 0x02) { // username/pw
     573        LOGDEBUG(("socks5: auth method accepted by server"));
     574        return WriteV5UsernameRequest();
     575    } else { // 0xFF signals error
    551576        LOGERROR(("socks5: server did not accept our authentication method"));
    552577        HandshakeFinished(PR_CONNECT_REFUSED_ERROR);
    553578        return PR_FAILURE;
    554579    }
     580}
     581
     582PRStatus
     583nsSOCKSSocketInfo::WriteV5UsernameRequest()
     584{
     585    NS_ABORT_IF_FALSE(mVersion == 5, "SOCKS version must be 5!");
     586
     587    mDataLength = 0;
     588    mState = SOCKS5_WRITE_USERNAME_REQUEST;
     589
     590    LOGDEBUG(("socks5: sending username and password"));
     591    // RFC 1929 Username/password auth for SOCKS 5
     592    WriteUint8(0x01); // version 1 (not 5)
     593    WriteUint8(mProxyUsername.Length()); // username length
     594    WriteString(mProxyUsername); // username
     595    nsCString password;
     596    mProxy->GetPassword(password);
     597    WriteUint8(password.Length()); // password length
     598    WriteString(password); // password. WARNING: Sent unencrypted!
     599
     600    return PR_SUCCESS;
     601}
     602
     603PRStatus
     604nsSOCKSSocketInfo::ReadV5UsernameResponse()
     605{
     606    NS_ABORT_IF_FALSE(mState == SOCKS5_READ_USERNAME_RESPONSE,
     607                      "Handling SOCKS 5 username/password reply in wrong state!");
     608    NS_ABORT_IF_FALSE(mDataLength == 2,
     609                      "SOCKS 5 username reply must be 2 bytes!");
     610
     611    // Check version number, must be 1 (not 5)
     612    if (ReadUint8() != 0x01) {
     613        LOGERROR(("socks5: unexpected version in the reply"));
     614        HandshakeFinished(PR_CONNECT_REFUSED_ERROR);
     615        return PR_FAILURE;
     616    }
     617
     618    // Check whether username/password were accepted
     619    if (ReadUint8() != 0x00) { // 0 = success
     620        LOGERROR(("socks5: username/password not accepted"));
     621        HandshakeFinished(PR_CONNECT_REFUSED_ERROR);
     622        return PR_FAILURE;
     623    }
     624
     625    LOGDEBUG(("socks5: username/password accepted by server"));
    555626
    556627    return WriteV5ConnectRequest();
    557628}
    nsSOCKSSocketInfo::DoHandshake(PRFileDesc *fd, int16_t oflags) 
    795866            if (ReadFromSocket(fd) != PR_SUCCESS)
    796867                return PR_FAILURE;
    797868            return ReadV5AuthResponse();
     869        case SOCKS5_WRITE_USERNAME_REQUEST:
     870            if (WriteToSocket(fd) != PR_SUCCESS)
     871                return PR_FAILURE;
     872            WantRead(2);
     873            mState = SOCKS5_READ_USERNAME_RESPONSE;
     874            return PR_SUCCESS;
     875        case SOCKS5_READ_USERNAME_RESPONSE:
     876            if (ReadFromSocket(fd) != PR_SUCCESS)
     877                return PR_FAILURE;
     878            return ReadV5UsernameResponse();
    798879        case SOCKS5_WRITE_CONNECT_REQUEST:
    799880            if (WriteToSocket(fd) != PR_SUCCESS)
    800881                return PR_FAILURE;
    nsSOCKSSocketInfo::GetPollFlags() const 
    839920            return PR_POLL_EXCEPT | PR_POLL_WRITE;
    840921        case SOCKS4_WRITE_CONNECT_REQUEST:
    841922        case SOCKS5_WRITE_AUTH_REQUEST:
     923        case SOCKS5_WRITE_USERNAME_REQUEST:
    842924        case SOCKS5_WRITE_CONNECT_REQUEST:
    843925            return PR_POLL_WRITE;
    844926        case SOCKS4_READ_CONNECT_RESPONSE:
    845927        case SOCKS5_READ_AUTH_RESPONSE:
     928        case SOCKS5_READ_USERNAME_RESPONSE:
    846929        case SOCKS5_READ_CONNECT_RESPONSE_TOP:
    847930        case SOCKS5_READ_CONNECT_RESPONSE_BOTTOM:
    848931            return PR_POLL_READ;
    nsresult 
    12211304nsSOCKSIOLayerAddToSocket(int32_t family,
    12221305                          const char *host,
    12231306                          int32_t port,
    1224                           const char *proxyHost,
    1225                           int32_t proxyPort,
     1307                          nsIProxyInfo *proxy,
    12261308                          int32_t socksVersion,
    12271309                          uint32_t flags,
    12281310                          PRFileDesc *fd,
    nsSOCKSIOLayerAddToSocket(int32_t family, 
    12891371    }
    12901372
    12911373    NS_ADDREF(infoObject);
    1292     infoObject->Init(socksVersion, family, proxyHost, proxyPort, host, flags);
     1374    infoObject->Init(socksVersion, family, proxy, host, flags);
    12931375    layer->secret = (PRFilePrivate*) infoObject;
    12941376    rv = PR_PushIOLayer(fd, PR_GetLayersIdentity(fd), layer);
    12951377
  • netwerk/socket/nsSOCKSIOLayer.h

    diff --git a/netwerk/socket/nsSOCKSIOLayer.h b/netwerk/socket/nsSOCKSIOLayer.h
    index dfe7c0c..54d936e 100644
    a b  
    99
    1010#include "prio.h"
    1111#include "nscore.h"
     12#include "nsIProxyInfo.h"
    1213
    1314nsresult nsSOCKSIOLayerAddToSocket(int32_t       family,
    1415                                   const char   *host,
    1516                                   int32_t       port,
    16                                    const char   *proxyHost,
    17                                    int32_t       proxyPort,
     17                                   nsIProxyInfo *proxyInfo,
    1818                                   int32_t       socksVersion,
    1919                                   uint32_t      flags,
    2020                                   PRFileDesc   *fd,
  • netwerk/socket/nsSOCKSSocketProvider.cpp

    diff --git a/netwerk/socket/nsSOCKSSocketProvider.cpp b/netwerk/socket/nsSOCKSSocketProvider.cpp
    index af7c9b5..c5a5655 100644
    a b NS_IMETHODIMP 
    4444nsSOCKSSocketProvider::NewSocket(int32_t family,
    4545                                 const char *host,
    4646                                 int32_t port,
    47                                  const char *proxyHost,
    48                                  int32_t proxyPort,
     47                                 nsIProxyInfo *proxy,
    4948                                 uint32_t flags,
    5049                                 PRFileDesc **result,
    5150                                 nsISupports **socksInfo)
    nsSOCKSSocketProvider::NewSocket(int32_t family, 
    5958    nsresult rv = nsSOCKSIOLayerAddToSocket(family,
    6059                                            host,
    6160                                            port,
    62                                             proxyHost,
    63                                             proxyPort,
     61                                            proxy,
    6462                                            mVersion,
    6563                                            flags,
    6664                                            sock,
    NS_IMETHODIMP 
    7775nsSOCKSSocketProvider::AddToSocket(int32_t family,
    7876                                   const char *host,
    7977                                   int32_t port,
    80                                    const char *proxyHost,
    81                                    int32_t proxyPort,
     78                                   nsIProxyInfo *proxy,
    8279                                   uint32_t flags,
    8380                                   PRFileDesc *sock,
    8481                                   nsISupports **socksInfo)
    nsSOCKSSocketProvider::AddToSocket(int32_t family, 
    8683    nsresult rv = nsSOCKSIOLayerAddToSocket(family,
    8784                                            host,
    8885                                            port,
    89                                             proxyHost,
    90                                             proxyPort,
     86                                            proxy,
    9187                                            mVersion,
    9288                                            flags,
    9389                                            sock,
  • netwerk/socket/nsUDPSocketProvider.cpp

    diff --git a/netwerk/socket/nsUDPSocketProvider.cpp b/netwerk/socket/nsUDPSocketProvider.cpp
    index 4ca7b29..f03b624 100644
    a b NS_IMETHODIMP 
    1616nsUDPSocketProvider::NewSocket(int32_t aFamily,
    1717                               const char *aHost,
    1818                               int32_t aPort,
    19                                const char *aProxyHost,
    20                                int32_t aProxyPort,
     19                               nsIProxyInfo *aProxy,
    2120                               uint32_t aFlags,
    2221                               PRFileDesc * *aFileDesc,
    2322                               nsISupports **aSecurityInfo)
    NS_IMETHODIMP 
    3635nsUDPSocketProvider::AddToSocket(int32_t aFamily,
    3736                                 const char *aHost,
    3837                                 int32_t aPort,
    39                                  const char *aProxyHost,
    40                                  int32_t aProxyPort,
     38                                 nsIProxyInfo *aProxy,
    4139                                 uint32_t aFlags,
    4240                                 struct PRFileDesc * aFileDesc,
    4341                                 nsISupports **aSecurityInfo)
  • security/manager/ssl/src/nsNSSIOLayer.cpp

    diff --git a/security/manager/ssl/src/nsNSSIOLayer.cpp b/security/manager/ssl/src/nsNSSIOLayer.cpp
    index 43bb013..a71f265 100644
    a b nsresult 
    15981598nsSSLIOLayerNewSocket(int32_t family,
    15991599                      const char* host,
    16001600                      int32_t port,
    1601                       const char* proxyHost,
    1602                       int32_t proxyPort,
     1601                      nsIProxyInfo *proxy,
    16031602                      PRFileDesc** fd,
    16041603                      nsISupports** info,
    16051604                      bool forSTARTTLS,
    nsSSLIOLayerNewSocket(int32_t family, 
    16091608  PRFileDesc* sock = PR_OpenTCPSocket(family);
    16101609  if (!sock) return NS_ERROR_OUT_OF_MEMORY;
    16111610
    1612   nsresult rv = nsSSLIOLayerAddToSocket(family, host, port, proxyHost, proxyPort,
     1611  nsresult rv = nsSSLIOLayerAddToSocket(family, host, port, proxy,
    16131612                                        sock, info, forSTARTTLS, flags);
    16141613  if (NS_FAILED(rv)) {
    16151614    PR_Close(sock);
    loser: 
    22742273
    22752274static nsresult
    22762275nsSSLIOLayerSetOptions(PRFileDesc* fd, bool forSTARTTLS,
    2277                        const char* proxyHost, const char* host, int32_t port,
     2276                       bool haveProxy, const char* host, int32_t port,
    22782277                       nsNSSSocketInfo* infoObject)
    22792278{
    22802279  nsNSSShutDownPreventionLock locker;
    2281   if (forSTARTTLS || proxyHost) {
     2280  if (forSTARTTLS || haveProxy) {
    22822281    if (SECSuccess != SSL_OptionSet(fd, SSL_SECURITY, false)) {
    22832282      return NS_ERROR_FAILURE;
    22842283    }
    nsresult 
    23502349nsSSLIOLayerAddToSocket(int32_t family,
    23512350                        const char* host,
    23522351                        int32_t port,
    2353                         const char* proxyHost,
    2354                         int32_t proxyPort,
     2352                        nsIProxyInfo* proxy,
    23552353                        PRFileDesc* fd,
    23562354                        nsISupports** info,
    23572355                        bool forSTARTTLS,
    nsSSLIOLayerAddToSocket(int32_t family, 
    23732371  infoObject->SetHostName(host);
    23742372  infoObject->SetPort(port);
    23752373
     2374  bool haveProxy = false;
     2375  if (proxy) {
     2376    nsCString proxyHost;
     2377    proxy->GetHost(proxyHost);
     2378    haveProxy = !proxyHost.IsEmpty();
     2379  }
     2380
    23762381  // A plaintext observer shim is inserted so we can observe some protocol
    23772382  // details without modifying nss
    23782383  plaintextLayer = PR_CreateIOLayerStub(nsSSLIOLayerHelpers::nsSSLPlaintextLayerIdentity,
    nsSSLIOLayerAddToSocket(int32_t family, 
    23942399
    23952400  infoObject->SetFileDescPtr(sslSock);
    23962401
    2397   rv = nsSSLIOLayerSetOptions(sslSock, forSTARTTLS, proxyHost, host, port,
     2402  rv = nsSSLIOLayerSetOptions(sslSock, forSTARTTLS, haveProxy, host, port,
    23982403                              infoObject);
    23992404
    24002405  if (NS_FAILED(rv))
    nsSSLIOLayerAddToSocket(int32_t family, 
    24192424  infoObject->QueryInterface(NS_GET_IID(nsISupports), (void**) (info));
    24202425
    24212426  // We are going use a clear connection first //
    2422   if (forSTARTTLS || proxyHost) {
     2427  if (forSTARTTLS || haveProxy) {
    24232428    infoObject->SetHandshakeNotPending();
    24242429  }
    24252430
  • security/manager/ssl/src/nsNSSIOLayer.h

    diff --git a/security/manager/ssl/src/nsNSSIOLayer.h b/security/manager/ssl/src/nsNSSIOLayer.h
    index fca0ce8..6ba745d 100644
    a b  
    1010#include "TransportSecurityInfo.h"
    1111#include "nsISSLSocketControl.h"
    1212#include "nsIClientAuthDialogs.h"
     13#include "nsIProxyInfo.h"
    1314#include "nsNSSCertificate.h"
    1415#include "nsDataHashtable.h"
    1516#include "nsTHashtable.h"
    private: 
    202203nsresult nsSSLIOLayerNewSocket(int32_t family,
    203204                               const char* host,
    204205                               int32_t port,
    205                                const char* proxyHost,
    206                                int32_t proxyPort,
     206                               nsIProxyInfo *proxy,
    207207                               PRFileDesc** fd,
    208208                               nsISupports** securityInfo,
    209209                               bool forSTARTTLS,
    nsresult nsSSLIOLayerNewSocket(int32_t family, 
    212212nsresult nsSSLIOLayerAddToSocket(int32_t family,
    213213                                 const char* host,
    214214                                 int32_t port,
    215                                  const char* proxyHost,
    216                                  int32_t proxyPort,
     215                                 nsIProxyInfo *proxy,
    217216                                 PRFileDesc* fd,
    218217                                 nsISupports** securityInfo,
    219218                                 bool forSTARTTLS,
  • security/manager/ssl/src/nsSSLSocketProvider.cpp

    diff --git a/security/manager/ssl/src/nsSSLSocketProvider.cpp b/security/manager/ssl/src/nsSSLSocketProvider.cpp
    index fd37f4c..0666082 100644
    a b NS_IMETHODIMP 
    2222nsSSLSocketProvider::NewSocket(int32_t family,
    2323                               const char *host,
    2424                               int32_t port,
    25                                const char *proxyHost,
    26                                int32_t proxyPort,
     25                               nsIProxyInfo *proxy,
    2726                               uint32_t flags,
    2827                               PRFileDesc **_result,
    2928                               nsISupports **securityInfo)
    nsSSLSocketProvider::NewSocket(int32_t family, 
    3130  nsresult rv = nsSSLIOLayerNewSocket(family,
    3231                                      host,
    3332                                      port,
    34                                       proxyHost,
    35                                       proxyPort,
     33                                      proxy,
    3634                                      _result,
    3735                                      securityInfo,
    3836                                      false,
    NS_IMETHODIMP 
    4543nsSSLSocketProvider::AddToSocket(int32_t family,
    4644                                 const char *host,
    4745                                 int32_t port,
    48                                  const char *proxyHost,
    49                                  int32_t proxyPort,
     46                                 nsIProxyInfo *proxy,
    5047                                 uint32_t flags,
    5148                                 PRFileDesc *aSocket,
    5249                                 nsISupports **securityInfo)
    nsSSLSocketProvider::AddToSocket(int32_t family, 
    5451  nsresult rv = nsSSLIOLayerAddToSocket(family,
    5552                                        host,
    5653                                        port,
    57                                         proxyHost,
    58                                         proxyPort,
     54                                        proxy,
    5955                                        aSocket,
    6056                                        securityInfo,
    6157                                        false,
  • security/manager/ssl/src/nsTLSSocketProvider.cpp

    diff --git a/security/manager/ssl/src/nsTLSSocketProvider.cpp b/security/manager/ssl/src/nsTLSSocketProvider.cpp
    index 029b2c5..09dd2bd 100644
    a b NS_IMETHODIMP 
    2222nsTLSSocketProvider::NewSocket(int32_t family,
    2323                               const char *host,
    2424                               int32_t port,
    25                                const char *proxyHost,
    26                                int32_t proxyPort,
     25                               nsIProxyInfo *proxy,
    2726                               uint32_t flags,
    2827                               PRFileDesc **_result,
    2928                               nsISupports **securityInfo)
    nsTLSSocketProvider::NewSocket(int32_t family, 
    3130  nsresult rv = nsSSLIOLayerNewSocket(family,
    3231                                      host,
    3332                                      port,
    34                                       proxyHost,
    35                                       proxyPort,
     33                                      proxy,
    3634                                      _result,
    3735                                      securityInfo,
    3836                                      true,
    NS_IMETHODIMP 
    4644nsTLSSocketProvider::AddToSocket(int32_t family,
    4745                                 const char *host,
    4846                                 int32_t port,
    49                                  const char *proxyHost,
    50                                  int32_t proxyPort,
     47                                 nsIProxyInfo *proxy,
    5148                                 uint32_t flags,
    5249                                 PRFileDesc *aSocket,
    5350                                 nsISupports **securityInfo)
    nsTLSSocketProvider::AddToSocket(int32_t family, 
    5552  nsresult rv = nsSSLIOLayerAddToSocket(family,
    5653                                        host,
    5754                                        port,
    58                                         proxyHost,
    59                                         proxyPort,
     55                                        proxy,
    6056                                        aSocket,
    6157                                        securityInfo,
    6258                                        true,