mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-24 21:31:04 +00:00
01583602a9
The bulk of this commit was generated with a script, executed at the top
level of a typical source code checkout. The only non-machine-generated
part was modifying MFBT's moz.build to reflect the new naming.
CLOSED TREE makes big refactorings like this a piece of cake.
# The main substitution.
find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \
xargs perl -p -i -e '
s/nsRefPtr\.h/RefPtr\.h/g; # handle includes
s/nsRefPtr ?</RefPtr</g; # handle declarations and variables
'
# Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h.
perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h
# Handle nsRefPtr.h itself, a couple places that define constructors
# from nsRefPtr, and code generators specially. We do this here, rather
# than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename
# things like nsRefPtrHashtable.
perl -p -i -e 's/nsRefPtr/RefPtr/g' \
mfbt/nsRefPtr.h \
xpcom/glue/nsCOMPtr.h \
xpcom/base/OwningNonNull.h \
ipc/ipdl/ipdl/lower.py \
ipc/ipdl/ipdl/builtin.py \
dom/bindings/Codegen.py \
python/lldbutils/lldbutils/utils.py
# In our indiscriminate substitution above, we renamed
# nsRefPtrGetterAddRefs, the class behind getter_AddRefs. Fix that up.
find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \
xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g'
if [ -d .git ]; then
git mv mfbt/nsRefPtr.h mfbt/RefPtr.h
else
hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h
fi
--HG--
rename : mfbt/nsRefPtr.h => mfbt/RefPtr.h
284 lines
10 KiB
C++
284 lines
10 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=2 et sw=2 tw=80: */
|
|
/* 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 http://mozilla.org/MPL/2.0/. */
|
|
/*
|
|
*/
|
|
|
|
/*
|
|
Based partially on original code from nICEr and nrappkit.
|
|
|
|
nICEr copyright:
|
|
|
|
Copyright (c) 2007, Adobe Systems, Incorporated
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are
|
|
met:
|
|
|
|
* Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
* Neither the name of Adobe Systems, Network Resonance nor the names of its
|
|
contributors may be used to endorse or promote products derived from
|
|
this software without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
nrappkit copyright:
|
|
|
|
Copyright (C) 2001-2003, Network Resonance, Inc.
|
|
Copyright (C) 2006, Network Resonance, Inc.
|
|
All Rights Reserved
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
3. Neither the name of Network Resonance, Inc. nor the name of any
|
|
contributors to this software may be used to endorse or promote
|
|
products derived from this software without specific prior written
|
|
permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
ekr@rtfm.com Thu Dec 20 20:14:49 2001
|
|
*/
|
|
|
|
// Original author: bcampen@mozilla.com [:bwc]
|
|
|
|
#ifndef test_nr_socket__
|
|
#define test_nr_socket__
|
|
|
|
#include "nr_socket_prsock.h"
|
|
|
|
extern "C" {
|
|
#include "nr_socket.h"
|
|
}
|
|
|
|
#include <set>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <list>
|
|
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "prinrval.h"
|
|
|
|
namespace mozilla {
|
|
|
|
class TestNrSocket;
|
|
|
|
/**
|
|
* A group of TestNrSockets that behave as if they were behind the same NAT.
|
|
* @note We deliberately avoid addref/release of TestNrSocket here to avoid
|
|
* masking lifetime errors elsewhere.
|
|
*/
|
|
class TestNat {
|
|
public:
|
|
typedef enum {
|
|
/** For mapping, one port is used for all destinations.
|
|
* For filtering, allow any external address/port. */
|
|
ENDPOINT_INDEPENDENT,
|
|
|
|
/** For mapping, one port for each destination address (for any port).
|
|
* For filtering, allow incoming traffic from addresses that outgoing
|
|
* traffic has been sent to. */
|
|
ADDRESS_DEPENDENT,
|
|
|
|
/** For mapping, one port for each destination address/port.
|
|
* For filtering, allow incoming traffic only from addresses/ports that
|
|
* outgoing traffic has been sent to. */
|
|
PORT_DEPENDENT,
|
|
} NatBehavior;
|
|
|
|
TestNat() :
|
|
enabled_(false),
|
|
filtering_type_(ENDPOINT_INDEPENDENT),
|
|
mapping_type_(ENDPOINT_INDEPENDENT),
|
|
mapping_timeout_(30000),
|
|
allow_hairpinning_(false),
|
|
refresh_on_ingress_(false),
|
|
block_udp_(false),
|
|
sockets_() {}
|
|
|
|
bool has_port_mappings() const;
|
|
|
|
// Helps determine whether we're hairpinning
|
|
bool is_my_external_tuple(const nr_transport_addr &addr) const;
|
|
bool is_an_internal_tuple(const nr_transport_addr &addr) const;
|
|
|
|
int create_socket_factory(nr_socket_factory **factorypp);
|
|
|
|
void insert_socket(TestNrSocket *socket) {
|
|
sockets_.insert(socket);
|
|
}
|
|
|
|
void erase_socket(TestNrSocket *socket) {
|
|
sockets_.erase(socket);
|
|
}
|
|
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(TestNat);
|
|
|
|
bool enabled_;
|
|
TestNat::NatBehavior filtering_type_;
|
|
TestNat::NatBehavior mapping_type_;
|
|
uint32_t mapping_timeout_;
|
|
bool allow_hairpinning_;
|
|
bool refresh_on_ingress_;
|
|
bool block_udp_;
|
|
|
|
private:
|
|
std::set<TestNrSocket*> sockets_;
|
|
|
|
~TestNat(){}
|
|
};
|
|
|
|
/**
|
|
* Subclass of NrSocket that can simulate things like being behind a NAT, packet
|
|
* loss, latency, packet rewriting, etc. Also exposes some stuff that assists in
|
|
* diagnostics.
|
|
*/
|
|
class TestNrSocket : public NrSocket {
|
|
public:
|
|
explicit TestNrSocket(TestNat *nat);
|
|
|
|
virtual ~TestNrSocket();
|
|
|
|
bool has_port_mappings() const;
|
|
bool is_my_external_tuple(const nr_transport_addr &addr) const;
|
|
|
|
// Overrides of NrSocket
|
|
int sendto(const void *msg, size_t len,
|
|
int flags, nr_transport_addr *to) override;
|
|
int recvfrom(void * buf, size_t maxlen,
|
|
size_t *len, int flags,
|
|
nr_transport_addr *from) override;
|
|
int connect(nr_transport_addr *addr) override;
|
|
int write(const void *msg, size_t len, size_t *written) override;
|
|
int read(void *buf, size_t maxlen, size_t *len) override;
|
|
|
|
int async_wait(int how, NR_async_cb cb, void *cb_arg,
|
|
char *function, int line) override;
|
|
int cancel(int how) override;
|
|
|
|
private:
|
|
class UdpPacket {
|
|
public:
|
|
UdpPacket(const void *msg, size_t len, const nr_transport_addr &addr) :
|
|
buffer_(new DataBuffer(static_cast<const uint8_t*>(msg), len)) {
|
|
// TODO(bug 1170299): Remove const_cast when no longer necessary
|
|
nr_transport_addr_copy(&remote_address_,
|
|
const_cast<nr_transport_addr*>(&addr));
|
|
}
|
|
|
|
nr_transport_addr remote_address_;
|
|
UniquePtr<DataBuffer> buffer_;
|
|
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(UdpPacket);
|
|
private:
|
|
~UdpPacket(){}
|
|
};
|
|
|
|
class PortMapping {
|
|
public:
|
|
PortMapping(const nr_transport_addr &remote_address,
|
|
const RefPtr<NrSocket> &external_socket);
|
|
|
|
int sendto(const void *msg, size_t len, const nr_transport_addr &to);
|
|
int async_wait(int how, NR_async_cb cb, void *cb_arg,
|
|
char *function, int line);
|
|
int cancel(int how);
|
|
int send_from_queue();
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PortMapping);
|
|
|
|
PRIntervalTime last_used_;
|
|
RefPtr<NrSocket> external_socket_;
|
|
// For non-symmetric, most of the data here doesn't matter
|
|
nr_transport_addr remote_address_;
|
|
|
|
private:
|
|
~PortMapping(){}
|
|
|
|
// If external_socket_ returns E_WOULDBLOCK, we don't want to propagate
|
|
// that to the code using the TestNrSocket. We can also perhaps use this
|
|
// to help simulate things like latency.
|
|
std::list<RefPtr<UdpPacket>> send_queue_;
|
|
};
|
|
|
|
bool is_port_mapping_stale(const PortMapping &port_mapping) const;
|
|
bool allow_ingress(const nr_transport_addr &from,
|
|
PortMapping **port_mapping_used) const;
|
|
void destroy_stale_port_mappings();
|
|
|
|
static void port_mapping_readable_callback(void *ext_sock_v,
|
|
int how,
|
|
void *test_sock_v);
|
|
void on_port_mapping_readable(NrSocket *external_socket);
|
|
void fire_readable_callback();
|
|
|
|
static void port_mapping_tcp_passthrough_callback(void *ext_sock_v,
|
|
int how,
|
|
void *test_sock_v);
|
|
void cancel_port_mapping_async_wait(int how);
|
|
|
|
static void port_mapping_writeable_callback(void *ext_sock_v,
|
|
int how,
|
|
void *test_sock_v);
|
|
void write_to_port_mapping(NrSocket *external_socket);
|
|
bool is_tcp_connection_behind_nat() const;
|
|
|
|
PortMapping* get_port_mapping(const nr_transport_addr &remote_addr,
|
|
TestNat::NatBehavior filter) const;
|
|
PortMapping* create_port_mapping(
|
|
const nr_transport_addr &remote_addr,
|
|
const RefPtr<NrSocket> &external_socket) const;
|
|
RefPtr<NrSocket> create_external_socket(
|
|
const nr_transport_addr &remote_addr) const;
|
|
|
|
RefPtr<NrSocket> readable_socket_;
|
|
RefPtr<TestNat> nat_;
|
|
// Since our comparison logic is different depending on what kind of NAT
|
|
// we simulate, and the STL does not make it very easy to switch out the
|
|
// comparison function at runtime, and these lists are going to be very
|
|
// small anyway, we just brute-force it.
|
|
std::list<RefPtr<PortMapping>> port_mappings_;
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // test_nr_socket__
|
|
|