593 lines
19 KiB
C++
593 lines
19 KiB
C++
/*
|
|
* Copyright 2009 The WebRTC Project Authors. All rights reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#ifndef WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_
|
|
#define WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_
|
|
|
|
#include <map>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "webrtc/p2p/base/candidatepairinterface.h"
|
|
#include "webrtc/p2p/base/transport.h"
|
|
#include "webrtc/p2p/base/transportchannel.h"
|
|
#include "webrtc/p2p/base/transportcontroller.h"
|
|
#include "webrtc/p2p/base/transportchannelimpl.h"
|
|
#include "webrtc/base/bind.h"
|
|
#include "webrtc/base/buffer.h"
|
|
#include "webrtc/base/fakesslidentity.h"
|
|
#include "webrtc/base/messagequeue.h"
|
|
#include "webrtc/base/sigslot.h"
|
|
#include "webrtc/base/sslfingerprint.h"
|
|
#include "webrtc/base/thread.h"
|
|
|
|
namespace cricket {
|
|
|
|
class FakeTransport;
|
|
|
|
namespace {
|
|
struct PacketMessageData : public rtc::MessageData {
|
|
PacketMessageData(const char* data, size_t len) : packet(data, len) {}
|
|
rtc::Buffer packet;
|
|
};
|
|
} // namespace
|
|
|
|
// Fake transport channel class, which can be passed to anything that needs a
|
|
// transport channel. Can be informed of another FakeTransportChannel via
|
|
// SetDestination.
|
|
// TODO(hbos): Move implementation to .cc file, this and other classes in file.
|
|
class FakeTransportChannel : public TransportChannelImpl,
|
|
public rtc::MessageHandler {
|
|
public:
|
|
explicit FakeTransportChannel(const std::string& name, int component)
|
|
: TransportChannelImpl(name, component),
|
|
dtls_fingerprint_("", nullptr, 0) {}
|
|
~FakeTransportChannel() { Reset(); }
|
|
|
|
uint64_t IceTiebreaker() const { return tiebreaker_; }
|
|
IceMode remote_ice_mode() const { return remote_ice_mode_; }
|
|
const std::string& ice_ufrag() const { return ice_ufrag_; }
|
|
const std::string& ice_pwd() const { return ice_pwd_; }
|
|
const std::string& remote_ice_ufrag() const { return remote_ice_ufrag_; }
|
|
const std::string& remote_ice_pwd() const { return remote_ice_pwd_; }
|
|
const rtc::SSLFingerprint& dtls_fingerprint() const {
|
|
return dtls_fingerprint_;
|
|
}
|
|
|
|
// If async, will send packets by "Post"-ing to message queue instead of
|
|
// synchronously "Send"-ing.
|
|
void SetAsync(bool async) { async_ = async; }
|
|
|
|
TransportChannelState GetState() const override {
|
|
if (connection_count_ == 0) {
|
|
return had_connection_ ? TransportChannelState::STATE_FAILED
|
|
: TransportChannelState::STATE_INIT;
|
|
}
|
|
|
|
if (connection_count_ == 1) {
|
|
return TransportChannelState::STATE_COMPLETED;
|
|
}
|
|
|
|
return TransportChannelState::STATE_CONNECTING;
|
|
}
|
|
|
|
void SetIceRole(IceRole role) override { role_ = role; }
|
|
IceRole GetIceRole() const override { return role_; }
|
|
void SetIceTiebreaker(uint64_t tiebreaker) override {
|
|
tiebreaker_ = tiebreaker;
|
|
}
|
|
void SetIceCredentials(const std::string& ice_ufrag,
|
|
const std::string& ice_pwd) override {
|
|
ice_ufrag_ = ice_ufrag;
|
|
ice_pwd_ = ice_pwd;
|
|
}
|
|
void SetRemoteIceCredentials(const std::string& ice_ufrag,
|
|
const std::string& ice_pwd) override {
|
|
remote_ice_ufrag_ = ice_ufrag;
|
|
remote_ice_pwd_ = ice_pwd;
|
|
}
|
|
|
|
void SetRemoteIceMode(IceMode mode) override { remote_ice_mode_ = mode; }
|
|
bool SetRemoteFingerprint(const std::string& alg,
|
|
const uint8_t* digest,
|
|
size_t digest_len) override {
|
|
dtls_fingerprint_ = rtc::SSLFingerprint(alg, digest, digest_len);
|
|
return true;
|
|
}
|
|
bool SetSslRole(rtc::SSLRole role) override {
|
|
ssl_role_ = role;
|
|
return true;
|
|
}
|
|
bool GetSslRole(rtc::SSLRole* role) const override {
|
|
*role = ssl_role_;
|
|
return true;
|
|
}
|
|
|
|
void Connect() override {
|
|
if (state_ == STATE_INIT) {
|
|
state_ = STATE_CONNECTING;
|
|
}
|
|
}
|
|
|
|
void MaybeStartGathering() override {
|
|
if (gathering_state_ == kIceGatheringNew) {
|
|
gathering_state_ = kIceGatheringGathering;
|
|
SignalGatheringState(this);
|
|
}
|
|
}
|
|
|
|
IceGatheringState gathering_state() const override {
|
|
return gathering_state_;
|
|
}
|
|
|
|
void Reset() {
|
|
if (state_ != STATE_INIT) {
|
|
state_ = STATE_INIT;
|
|
if (dest_) {
|
|
dest_->state_ = STATE_INIT;
|
|
dest_->dest_ = nullptr;
|
|
dest_ = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetWritable(bool writable) { set_writable(writable); }
|
|
|
|
// Simulates the two transport channels connecting to each other.
|
|
// If |asymmetric| is true this method only affects this FakeTransportChannel.
|
|
// If false, it affects |dest| as well.
|
|
void SetDestination(FakeTransportChannel* dest, bool asymmetric = false) {
|
|
if (state_ == STATE_CONNECTING && dest) {
|
|
// This simulates the delivery of candidates.
|
|
dest_ = dest;
|
|
if (local_cert_ && dest_->local_cert_) {
|
|
do_dtls_ = true;
|
|
NegotiateSrtpCiphers();
|
|
}
|
|
state_ = STATE_CONNECTED;
|
|
set_writable(true);
|
|
if (!asymmetric) {
|
|
dest->SetDestination(this, true);
|
|
}
|
|
} else if (state_ == STATE_CONNECTED && !dest) {
|
|
// Simulates loss of connectivity, by asymmetrically forgetting dest_.
|
|
dest_ = nullptr;
|
|
state_ = STATE_CONNECTING;
|
|
set_writable(false);
|
|
}
|
|
}
|
|
|
|
void SetConnectionCount(size_t connection_count) {
|
|
size_t old_connection_count = connection_count_;
|
|
connection_count_ = connection_count;
|
|
if (connection_count)
|
|
had_connection_ = true;
|
|
// In this fake transport channel, |connection_count_| determines the
|
|
// transport channel state.
|
|
if (connection_count_ < old_connection_count)
|
|
SignalStateChanged(this);
|
|
}
|
|
|
|
void SetCandidatesGatheringComplete() {
|
|
if (gathering_state_ != kIceGatheringComplete) {
|
|
gathering_state_ = kIceGatheringComplete;
|
|
SignalGatheringState(this);
|
|
}
|
|
}
|
|
|
|
void SetReceiving(bool receiving) { set_receiving(receiving); }
|
|
|
|
void SetIceConfig(const IceConfig& config) override {
|
|
receiving_timeout_ = config.receiving_timeout;
|
|
gather_continually_ = config.gather_continually;
|
|
}
|
|
|
|
int receiving_timeout() const { return receiving_timeout_; }
|
|
bool gather_continually() const { return gather_continually_; }
|
|
|
|
int SendPacket(const char* data,
|
|
size_t len,
|
|
const rtc::PacketOptions& options,
|
|
int flags) override {
|
|
if (state_ != STATE_CONNECTED) {
|
|
return -1;
|
|
}
|
|
|
|
if (flags != PF_SRTP_BYPASS && flags != 0) {
|
|
return -1;
|
|
}
|
|
|
|
PacketMessageData* packet = new PacketMessageData(data, len);
|
|
if (async_) {
|
|
rtc::Thread::Current()->Post(RTC_FROM_HERE, this, 0, packet);
|
|
} else {
|
|
rtc::Thread::Current()->Send(RTC_FROM_HERE, this, 0, packet);
|
|
}
|
|
rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis());
|
|
SignalSentPacket(this, sent_packet);
|
|
return static_cast<int>(len);
|
|
}
|
|
int SetOption(rtc::Socket::Option opt, int value) override { return true; }
|
|
bool GetOption(rtc::Socket::Option opt, int* value) override { return true; }
|
|
int GetError() override { return 0; }
|
|
|
|
void AddRemoteCandidate(const Candidate& candidate) override {
|
|
remote_candidates_.push_back(candidate);
|
|
}
|
|
|
|
void RemoveRemoteCandidate(const Candidate& candidate) override {}
|
|
|
|
const Candidates& remote_candidates() const { return remote_candidates_; }
|
|
|
|
void OnMessage(rtc::Message* msg) override {
|
|
PacketMessageData* data = static_cast<PacketMessageData*>(msg->pdata);
|
|
dest_->SignalReadPacket(dest_, data->packet.data<char>(),
|
|
data->packet.size(), rtc::CreatePacketTime(0), 0);
|
|
delete data;
|
|
}
|
|
|
|
bool SetLocalCertificate(
|
|
const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) override {
|
|
local_cert_ = certificate;
|
|
return true;
|
|
}
|
|
|
|
void SetRemoteSSLCertificate(rtc::FakeSSLCertificate* cert) {
|
|
remote_cert_ = cert;
|
|
}
|
|
|
|
bool IsDtlsActive() const override { return do_dtls_; }
|
|
|
|
bool SetSrtpCryptoSuites(const std::vector<int>& ciphers) override {
|
|
srtp_ciphers_ = ciphers;
|
|
return true;
|
|
}
|
|
|
|
bool GetSrtpCryptoSuite(int* crypto_suite) override {
|
|
if (chosen_crypto_suite_ != rtc::SRTP_INVALID_CRYPTO_SUITE) {
|
|
*crypto_suite = chosen_crypto_suite_;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool GetSslCipherSuite(int* cipher_suite) override { return false; }
|
|
|
|
rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate() const override {
|
|
return local_cert_;
|
|
}
|
|
|
|
std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
|
|
const override {
|
|
return remote_cert_ ? std::unique_ptr<rtc::SSLCertificate>(
|
|
remote_cert_->GetReference())
|
|
: nullptr;
|
|
}
|
|
|
|
bool ExportKeyingMaterial(const std::string& label,
|
|
const uint8_t* context,
|
|
size_t context_len,
|
|
bool use_context,
|
|
uint8_t* result,
|
|
size_t result_len) override {
|
|
if (chosen_crypto_suite_ != rtc::SRTP_INVALID_CRYPTO_SUITE) {
|
|
memset(result, 0xff, result_len);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool GetStats(ConnectionInfos* infos) override {
|
|
ConnectionInfo info;
|
|
infos->clear();
|
|
infos->push_back(info);
|
|
return true;
|
|
}
|
|
|
|
void set_ssl_max_protocol_version(rtc::SSLProtocolVersion version) {
|
|
ssl_max_version_ = version;
|
|
}
|
|
rtc::SSLProtocolVersion ssl_max_protocol_version() const {
|
|
return ssl_max_version_;
|
|
}
|
|
|
|
private:
|
|
void NegotiateSrtpCiphers() {
|
|
for (std::vector<int>::const_iterator it1 = srtp_ciphers_.begin();
|
|
it1 != srtp_ciphers_.end(); ++it1) {
|
|
for (std::vector<int>::const_iterator it2 = dest_->srtp_ciphers_.begin();
|
|
it2 != dest_->srtp_ciphers_.end(); ++it2) {
|
|
if (*it1 == *it2) {
|
|
chosen_crypto_suite_ = *it1;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
enum State { STATE_INIT, STATE_CONNECTING, STATE_CONNECTED };
|
|
FakeTransportChannel* dest_ = nullptr;
|
|
State state_ = STATE_INIT;
|
|
bool async_ = false;
|
|
Candidates remote_candidates_;
|
|
rtc::scoped_refptr<rtc::RTCCertificate> local_cert_;
|
|
rtc::FakeSSLCertificate* remote_cert_ = nullptr;
|
|
bool do_dtls_ = false;
|
|
std::vector<int> srtp_ciphers_;
|
|
int chosen_crypto_suite_ = rtc::SRTP_INVALID_CRYPTO_SUITE;
|
|
int receiving_timeout_ = -1;
|
|
bool gather_continually_ = false;
|
|
IceRole role_ = ICEROLE_UNKNOWN;
|
|
uint64_t tiebreaker_ = 0;
|
|
std::string ice_ufrag_;
|
|
std::string ice_pwd_;
|
|
std::string remote_ice_ufrag_;
|
|
std::string remote_ice_pwd_;
|
|
IceMode remote_ice_mode_ = ICEMODE_FULL;
|
|
rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_12;
|
|
rtc::SSLFingerprint dtls_fingerprint_;
|
|
rtc::SSLRole ssl_role_ = rtc::SSL_CLIENT;
|
|
size_t connection_count_ = 0;
|
|
IceGatheringState gathering_state_ = kIceGatheringNew;
|
|
bool had_connection_ = false;
|
|
};
|
|
|
|
// Fake transport class, which can be passed to anything that needs a Transport.
|
|
// Can be informed of another FakeTransport via SetDestination (low-tech way
|
|
// of doing candidates)
|
|
class FakeTransport : public Transport {
|
|
public:
|
|
typedef std::map<int, FakeTransportChannel*> ChannelMap;
|
|
|
|
explicit FakeTransport(const std::string& name) : Transport(name, nullptr) {}
|
|
|
|
// Note that we only have a constructor with the allocator parameter so it can
|
|
// be wrapped by a DtlsTransport.
|
|
FakeTransport(const std::string& name, PortAllocator* allocator)
|
|
: Transport(name, nullptr) {}
|
|
|
|
~FakeTransport() { DestroyAllChannels(); }
|
|
|
|
const ChannelMap& channels() const { return channels_; }
|
|
|
|
// If async, will send packets by "Post"-ing to message queue instead of
|
|
// synchronously "Send"-ing.
|
|
void SetAsync(bool async) { async_ = async; }
|
|
|
|
// If |asymmetric| is true, only set the destination for this transport, and
|
|
// not |dest|.
|
|
void SetDestination(FakeTransport* dest, bool asymmetric = false) {
|
|
dest_ = dest;
|
|
for (const auto& kv : channels_) {
|
|
kv.second->SetLocalCertificate(certificate_);
|
|
SetChannelDestination(kv.first, kv.second, asymmetric);
|
|
}
|
|
}
|
|
|
|
void SetWritable(bool writable) {
|
|
for (const auto& kv : channels_) {
|
|
kv.second->SetWritable(writable);
|
|
}
|
|
}
|
|
|
|
void SetLocalCertificate(
|
|
const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) override {
|
|
certificate_ = certificate;
|
|
}
|
|
bool GetLocalCertificate(
|
|
rtc::scoped_refptr<rtc::RTCCertificate>* certificate) override {
|
|
if (!certificate_)
|
|
return false;
|
|
|
|
*certificate = certificate_;
|
|
return true;
|
|
}
|
|
|
|
bool GetSslRole(rtc::SSLRole* role) const override {
|
|
if (channels_.empty()) {
|
|
return false;
|
|
}
|
|
return channels_.begin()->second->GetSslRole(role);
|
|
}
|
|
|
|
bool SetSslMaxProtocolVersion(rtc::SSLProtocolVersion version) override {
|
|
ssl_max_version_ = version;
|
|
for (const auto& kv : channels_) {
|
|
kv.second->set_ssl_max_protocol_version(ssl_max_version_);
|
|
}
|
|
return true;
|
|
}
|
|
rtc::SSLProtocolVersion ssl_max_protocol_version() const {
|
|
return ssl_max_version_;
|
|
}
|
|
|
|
using Transport::local_description;
|
|
using Transport::remote_description;
|
|
using Transport::VerifyCertificateFingerprint;
|
|
using Transport::NegotiateRole;
|
|
|
|
protected:
|
|
TransportChannelImpl* CreateTransportChannel(int component) override {
|
|
if (channels_.find(component) != channels_.end()) {
|
|
return nullptr;
|
|
}
|
|
FakeTransportChannel* channel = new FakeTransportChannel(name(), component);
|
|
channel->set_ssl_max_protocol_version(ssl_max_version_);
|
|
channel->SetAsync(async_);
|
|
SetChannelDestination(component, channel, false);
|
|
channels_[component] = channel;
|
|
return channel;
|
|
}
|
|
|
|
void DestroyTransportChannel(TransportChannelImpl* channel) override {
|
|
channels_.erase(channel->component());
|
|
delete channel;
|
|
}
|
|
|
|
private:
|
|
FakeTransportChannel* GetFakeChannel(int component) {
|
|
auto it = channels_.find(component);
|
|
return (it != channels_.end()) ? it->second : nullptr;
|
|
}
|
|
|
|
void SetChannelDestination(int component,
|
|
FakeTransportChannel* channel,
|
|
bool asymmetric) {
|
|
FakeTransportChannel* dest_channel = nullptr;
|
|
if (dest_) {
|
|
dest_channel = dest_->GetFakeChannel(component);
|
|
if (dest_channel && !asymmetric) {
|
|
dest_channel->SetLocalCertificate(dest_->certificate_);
|
|
}
|
|
}
|
|
channel->SetDestination(dest_channel, asymmetric);
|
|
}
|
|
|
|
// Note, this is distinct from the Channel map owned by Transport.
|
|
// This map just tracks the FakeTransportChannels created by this class.
|
|
// It's mainly needed so that we can access a FakeTransportChannel directly,
|
|
// even if wrapped by a DtlsTransportChannelWrapper.
|
|
ChannelMap channels_;
|
|
FakeTransport* dest_ = nullptr;
|
|
bool async_ = false;
|
|
rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
|
|
rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_12;
|
|
};
|
|
|
|
// Fake candidate pair class, which can be passed to BaseChannel for testing
|
|
// purposes.
|
|
class FakeCandidatePair : public CandidatePairInterface {
|
|
public:
|
|
FakeCandidatePair(const Candidate& local_candidate,
|
|
const Candidate& remote_candidate)
|
|
: local_candidate_(local_candidate),
|
|
remote_candidate_(remote_candidate) {}
|
|
const Candidate& local_candidate() const override { return local_candidate_; }
|
|
const Candidate& remote_candidate() const override {
|
|
return remote_candidate_;
|
|
}
|
|
|
|
private:
|
|
Candidate local_candidate_;
|
|
Candidate remote_candidate_;
|
|
};
|
|
|
|
// Fake TransportController class, which can be passed into a BaseChannel object
|
|
// for test purposes. Can be connected to other FakeTransportControllers via
|
|
// Connect().
|
|
//
|
|
// This fake is unusual in that for the most part, it's implemented with the
|
|
// real TransportController code, but with fake TransportChannels underneath.
|
|
class FakeTransportController : public TransportController {
|
|
public:
|
|
FakeTransportController()
|
|
: TransportController(rtc::Thread::Current(),
|
|
rtc::Thread::Current(),
|
|
nullptr),
|
|
fail_create_channel_(false) {}
|
|
|
|
explicit FakeTransportController(IceRole role)
|
|
: TransportController(rtc::Thread::Current(),
|
|
rtc::Thread::Current(),
|
|
nullptr),
|
|
fail_create_channel_(false) {
|
|
SetIceRole(role);
|
|
}
|
|
|
|
explicit FakeTransportController(rtc::Thread* worker_thread)
|
|
: TransportController(rtc::Thread::Current(), worker_thread, nullptr),
|
|
fail_create_channel_(false) {}
|
|
|
|
FakeTransportController(rtc::Thread* worker_thread, IceRole role)
|
|
: TransportController(rtc::Thread::Current(), worker_thread, nullptr),
|
|
fail_create_channel_(false) {
|
|
SetIceRole(role);
|
|
}
|
|
|
|
FakeTransport* GetTransport_n(const std::string& transport_name) {
|
|
return static_cast<FakeTransport*>(
|
|
TransportController::GetTransport_n(transport_name));
|
|
}
|
|
|
|
void Connect(FakeTransportController* dest) {
|
|
network_thread()->Invoke<void>(
|
|
RTC_FROM_HERE,
|
|
rtc::Bind(&FakeTransportController::Connect_n, this, dest));
|
|
}
|
|
|
|
TransportChannel* CreateTransportChannel_n(const std::string& transport_name,
|
|
int component) override {
|
|
if (fail_create_channel_) {
|
|
return nullptr;
|
|
}
|
|
return TransportController::CreateTransportChannel_n(transport_name,
|
|
component);
|
|
}
|
|
|
|
FakeCandidatePair* CreateFakeCandidatePair(
|
|
const rtc::SocketAddress& local_address,
|
|
int16_t local_network_id,
|
|
const rtc::SocketAddress& remote_address,
|
|
int16_t remote_network_id) {
|
|
Candidate local_candidate(0, "udp", local_address, 0u, "", "", "local", 0,
|
|
"foundation", local_network_id, 0);
|
|
Candidate remote_candidate(0, "udp", remote_address, 0u, "", "", "local", 0,
|
|
"foundation", remote_network_id, 0);
|
|
return new FakeCandidatePair(local_candidate, remote_candidate);
|
|
}
|
|
|
|
void set_fail_channel_creation(bool fail_channel_creation) {
|
|
fail_create_channel_ = fail_channel_creation;
|
|
}
|
|
|
|
protected:
|
|
Transport* CreateTransport_n(const std::string& transport_name) override {
|
|
return new FakeTransport(transport_name);
|
|
}
|
|
|
|
void Connect_n(FakeTransportController* dest) {
|
|
// Simulate the exchange of candidates.
|
|
ConnectChannels_n();
|
|
dest->ConnectChannels_n();
|
|
for (auto& kv : transports()) {
|
|
FakeTransport* transport = static_cast<FakeTransport*>(kv.second);
|
|
transport->SetDestination(dest->GetTransport_n(kv.first));
|
|
}
|
|
}
|
|
|
|
void ConnectChannels_n() {
|
|
TransportDescription faketransport_desc(
|
|
std::vector<std::string>(),
|
|
rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH),
|
|
rtc::CreateRandomString(cricket::ICE_PWD_LENGTH), cricket::ICEMODE_FULL,
|
|
cricket::CONNECTIONROLE_NONE, nullptr);
|
|
for (auto& kv : transports()) {
|
|
FakeTransport* transport = static_cast<FakeTransport*>(kv.second);
|
|
// Set local transport description for FakeTransport before connecting.
|
|
// Otherwise, the RTC_CHECK in Transport.ConnectChannel will fail.
|
|
if (!transport->local_description()) {
|
|
transport->SetLocalTransportDescription(faketransport_desc,
|
|
cricket::CA_OFFER, nullptr);
|
|
}
|
|
transport->ConnectChannels();
|
|
transport->MaybeStartGathering();
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool fail_create_channel_;
|
|
};
|
|
|
|
} // namespace cricket
|
|
|
|
#endif // WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_
|