Added SystemExternalAccess Function to RPC.

This provides ExternalPort + DHTKey to Client. To be used to find and connect - even if Dynamic IP address changes :)



git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@6004 b45a01b8-16f6-495d-af2f-9b41ad6348cc

libretroshare/src/dht/p3bitdht.cc

@@ -161,6 +161,13 @@ p3BitDht::~p3BitDht()
 }
 
 
+bool 	p3BitDht::getOwnDhtId(std::string &ownDhtId)
+{
+        bdStdPrintNodeId(ownDhtId, &(mOwnDhtId), false);
+	return true;
+}
+
+
 void    p3BitDht::setupConnectBits(UdpStunner *dhtStunner, UdpStunner *proxyStunner, UdpRelayReceiver  *relay)
 {
 	mDhtStunner = dhtStunner;

libretroshare/src/dht/p3bitdht.h

@@ -168,6 +168,8 @@ virtual std::string getUdpAddressString();
 virtual void    getDhtRates(float &read, float &write);
 virtual void    getRelayRates(float &read, float &write, float &relay);
 
+virtual bool    getOwnDhtId(std::string &ownDhtId);
+
 /***********************************************************************************************
  ********** External RsDHT Interface (defined in libretroshare/src/retroshare/rsdht.h) *********
 ************************************************************************************************/

libretroshare/src/retroshare/rsdht.h

@@ -190,6 +190,9 @@ virtual	int	 setRelayMode(uint32_t mode) = 0;
 virtual int	getRelayAllowance(int  classIdx, uint32_t &count, uint32_t &bandwidth) = 0;
 virtual int	setRelayAllowance(int classIdx, uint32_t  count, uint32_t  bandwidth) = 0;
 
+	// So we can provide to clients.
+virtual bool    getOwnDhtId(std::string &ownDhtId) = 0;
+
 
 #if 0
 virtual std::string getPeerStatusString();

retroshare-nogui/src/retroshare.cc

@@ -48,6 +48,9 @@
 
 #include "rpc/rpcsetup.h"
 
+// NASTY GLOBAL VARIABLE HACK - NEED TO THINK OF A BETTER SYSTEM.
+#include "rpc/proto/rpcprotosystem.h"
+
 #endif
 
 /* Basic instructions for running libretroshare as background thread.
@@ -108,7 +111,10 @@ int main(int argc, char **argv)
 	std::string sshRsaFile = "";
 	std::string sshPortStr = "7022";
 
-	while((c = getopt(argc, argv,"ChTL:P:K:GS::")) != -1)
+	uint16_t extPort = 0;
+	bool     extPortSet = false;
+
+	while((c = getopt(argc, argv,"ChTL:P:K:GS::E:")) != -1)
 	{
 		switch(c)
 		{
@@ -124,6 +130,11 @@ int main(int argc, char **argv)
 				}
 				strictCheck = false;
 				break;
+			case 'E':
+				extPort = atoi(optarg);
+				extPortSet = true;
+				strictCheck = false;
+				break;
 			case 'H':
 				enableSshHtml = true;
 				strictCheck = false;
@@ -158,6 +169,7 @@ int main(int argc, char **argv)
 				std::cerr << "\t-G                  Generate a Password Hash for SSH Server" << std::endl;
 				std::cerr << "\t-T                  Enable Terminal Interface" << std::endl;
 				std::cerr << "\t-S [port]           Enable SSH Server, optionally specify port" << std::endl;
+				std::cerr << "\t-E <port>           Specify Alternative External Port (provided to Clients)" << std::endl;
 				std::cerr << "\t-L <user>           Specify SSH login user (default:user)" << std::endl;
 				std::cerr << "\t-P <pwdhash>        Enable SSH login via Password" << std::endl;
 				std::cerr << "\t-C                  Enable RPC Protocol (requires -S too)" << std::endl;
@@ -364,6 +376,13 @@ int main(int argc, char **argv)
         		ssh->adduserpwdhash(sshUser, sshPwdHash);
 		}
 			
+		if (!extPortSet)
+		{
+			extPort = atoi(sshPortStr.c_str());
+		}
+
+		// NASTY GLOBAL VARIABLE HACK - NEED TO THINK OF A BETTER SYSTEM.
+		RpcProtoSystem::mExtPort = extPort;
 	}
 
 

retroshare-nogui/src/rpc/proto/gencc/system.pb.cc

@@ -32,6 +32,12 @@ const ::google::protobuf::EnumDescriptor* RequestSystemQuit_QuitCode_descriptor_
 const ::google::protobuf::Descriptor* ResponseSystemQuit_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   ResponseSystemQuit_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RequestSystemExternalAccess_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RequestSystemExternalAccess_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ResponseSystemExternalAccess_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ResponseSystemExternalAccess_reflection_ = NULL;
 const ::google::protobuf::EnumDescriptor* RequestMsgIds_descriptor_ = NULL;
 const ::google::protobuf::EnumDescriptor* ResponseMsgIds_descriptor_ = NULL;
 
@@ -109,6 +115,37 @@ void protobuf_AssignDesc_system_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ResponseSystemQuit));
+  RequestSystemExternalAccess_descriptor_ = file->message_type(4);
+  static const int RequestSystemExternalAccess_offsets_[1] = {
+  };
+  RequestSystemExternalAccess_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RequestSystemExternalAccess_descriptor_,
+      RequestSystemExternalAccess::default_instance_,
+      RequestSystemExternalAccess_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestSystemExternalAccess, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestSystemExternalAccess, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RequestSystemExternalAccess));
+  ResponseSystemExternalAccess_descriptor_ = file->message_type(5);
+  static const int ResponseSystemExternalAccess_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResponseSystemExternalAccess, status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResponseSystemExternalAccess, ext_port_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResponseSystemExternalAccess, dht_key_),
+  };
+  ResponseSystemExternalAccess_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ResponseSystemExternalAccess_descriptor_,
+      ResponseSystemExternalAccess::default_instance_,
+      ResponseSystemExternalAccess_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResponseSystemExternalAccess, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResponseSystemExternalAccess, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ResponseSystemExternalAccess));
   RequestMsgIds_descriptor_ = file->enum_type(0);
   ResponseMsgIds_descriptor_ = file->enum_type(1);
 }
@@ -131,6 +168,10 @@ void protobuf_RegisterTypes(const ::std::string&) {
     RequestSystemQuit_descriptor_, &RequestSystemQuit::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     ResponseSystemQuit_descriptor_, &ResponseSystemQuit::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RequestSystemExternalAccess_descriptor_, &RequestSystemExternalAccess::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ResponseSystemExternalAccess_descriptor_, &ResponseSystemExternalAccess::default_instance());
 }
 
 }  // namespace
@@ -144,6 +185,10 @@ void protobuf_ShutdownFile_system_2eproto() {
   delete RequestSystemQuit_reflection_;
   delete ResponseSystemQuit::default_instance_;
   delete ResponseSystemQuit_reflection_;
+  delete RequestSystemExternalAccess::default_instance_;
+  delete RequestSystemExternalAccess_reflection_;
+  delete ResponseSystemExternalAccess::default_instance_;
+  delete ResponseSystemExternalAccess_reflection_;
 }
 
 void protobuf_AddDesc_system_2eproto() {
@@ -169,21 +214,31 @@ void protobuf_AddDesc_system_2eproto() {
     "(\0162).rsctrl.system.RequestSystemQuit.Qui"
     "tCode\".\n\010QuitCode\022\021\n\rCLOSE_CHANNEL\020\001\022\017\n\013"
     "SHUTDOWN_RS\020\002\"9\n\022ResponseSystemQuit\022#\n\006s"
-    "tatus\030\001 \002(\0132\023.rsctrl.core.Status*K\n\rRequ"
+    "tatus\030\001 \002(\0132\023.rsctrl.core.Status\"\035\n\033Requ"
-    "estMsgIds\022\035\n\031MsgId_RequestSystemStatus\020\001"
+    "estSystemExternalAccess\"f\n\034ResponseSyste"
-    "\022\033\n\027MsgId_RequestSystemQuit\020\002*N\n\016Respons"
+    "mExternalAccess\022#\n\006status\030\001 \002(\0132\023.rsctrl"
-    "eMsgIds\022\036\n\032MsgId_ResponseSystemStatus\020\001\022"
+    ".core.Status\022\020\n\010ext_port\030\002 \002(\r\022\017\n\007dht_ke"
-    "\034\n\030MsgId_ResponseSystemQuit\020\002", 789);
+    "y\030\003 \002(\t*r\n\rRequestMsgIds\022\035\n\031MsgId_Reques"
+    "tSystemStatus\020\001\022\033\n\027MsgId_RequestSystemQu"
+    "it\020\002\022%\n!MsgId_RequestSystemExternalAcces"
+    "s\020\003*v\n\016ResponseMsgIds\022\036\n\032MsgId_ResponseS"
+    "ystemStatus\020\001\022\034\n\030MsgId_ResponseSystemQui"
+    "t\020\002\022&\n\"MsgId_ResponseSystemExternalAcces"
+    "s\020\003", 1003);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "system.proto", &protobuf_RegisterTypes);
   RequestSystemStatus::default_instance_ = new RequestSystemStatus();
   ResponseSystemStatus::default_instance_ = new ResponseSystemStatus();
   RequestSystemQuit::default_instance_ = new RequestSystemQuit();
   ResponseSystemQuit::default_instance_ = new ResponseSystemQuit();
+  RequestSystemExternalAccess::default_instance_ = new RequestSystemExternalAccess();
+  ResponseSystemExternalAccess::default_instance_ = new ResponseSystemExternalAccess();
   RequestSystemStatus::default_instance_->InitAsDefaultInstance();
   ResponseSystemStatus::default_instance_->InitAsDefaultInstance();
   RequestSystemQuit::default_instance_->InitAsDefaultInstance();
   ResponseSystemQuit::default_instance_->InitAsDefaultInstance();
+  RequestSystemExternalAccess::default_instance_->InitAsDefaultInstance();
+  ResponseSystemExternalAccess::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_system_2eproto);
 }
 
@@ -202,6 +257,7 @@ bool RequestMsgIds_IsValid(int value) {
   switch(value) {
     case 1:
     case 2:
+    case 3:
       return true;
     default:
       return false;
@@ -216,6 +272,7 @@ bool ResponseMsgIds_IsValid(int value) {
   switch(value) {
     case 1:
     case 2:
+    case 3:
       return true;
     default:
       return false;
@@ -1254,6 +1311,474 @@ void ResponseSystemQuit::Swap(ResponseSystemQuit* other) {
 }
 
 
+// ===================================================================
+
+#ifndef _MSC_VER
+#endif  // !_MSC_VER
+
+RequestSystemExternalAccess::RequestSystemExternalAccess()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void RequestSystemExternalAccess::InitAsDefaultInstance() {
+}
+
+RequestSystemExternalAccess::RequestSystemExternalAccess(const RequestSystemExternalAccess& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void RequestSystemExternalAccess::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RequestSystemExternalAccess::~RequestSystemExternalAccess() {
+  SharedDtor();
+}
+
+void RequestSystemExternalAccess::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void RequestSystemExternalAccess::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RequestSystemExternalAccess::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RequestSystemExternalAccess_descriptor_;
+}
+
+const RequestSystemExternalAccess& RequestSystemExternalAccess::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_system_2eproto();  return *default_instance_;
+}
+
+RequestSystemExternalAccess* RequestSystemExternalAccess::default_instance_ = NULL;
+
+RequestSystemExternalAccess* RequestSystemExternalAccess::New() const {
+  return new RequestSystemExternalAccess;
+}
+
+void RequestSystemExternalAccess::Clear() {
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RequestSystemExternalAccess::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+      return true;
+    }
+    DO_(::google::protobuf::internal::WireFormat::SkipField(
+          input, tag, mutable_unknown_fields()));
+  }
+  return true;
+#undef DO_
+}
+
+void RequestSystemExternalAccess::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* RequestSystemExternalAccess::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int RequestSystemExternalAccess::ByteSize() const {
+  int total_size = 0;
+  
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RequestSystemExternalAccess::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RequestSystemExternalAccess* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RequestSystemExternalAccess*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RequestSystemExternalAccess::MergeFrom(const RequestSystemExternalAccess& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RequestSystemExternalAccess::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RequestSystemExternalAccess::CopyFrom(const RequestSystemExternalAccess& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RequestSystemExternalAccess::IsInitialized() const {
+  
+  return true;
+}
+
+void RequestSystemExternalAccess::Swap(RequestSystemExternalAccess* other) {
+  if (other != this) {
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RequestSystemExternalAccess::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RequestSystemExternalAccess_descriptor_;
+  metadata.reflection = RequestSystemExternalAccess_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ResponseSystemExternalAccess::kStatusFieldNumber;
+const int ResponseSystemExternalAccess::kExtPortFieldNumber;
+const int ResponseSystemExternalAccess::kDhtKeyFieldNumber;
+#endif  // !_MSC_VER
+
+ResponseSystemExternalAccess::ResponseSystemExternalAccess()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void ResponseSystemExternalAccess::InitAsDefaultInstance() {
+  status_ = const_cast< ::rsctrl::core::Status*>(&::rsctrl::core::Status::default_instance());
+}
+
+ResponseSystemExternalAccess::ResponseSystemExternalAccess(const ResponseSystemExternalAccess& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void ResponseSystemExternalAccess::SharedCtor() {
+  _cached_size_ = 0;
+  status_ = NULL;
+  ext_port_ = 0u;
+  dht_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ResponseSystemExternalAccess::~ResponseSystemExternalAccess() {
+  SharedDtor();
+}
+
+void ResponseSystemExternalAccess::SharedDtor() {
+  if (dht_key_ != &::google::protobuf::internal::kEmptyString) {
+    delete dht_key_;
+  }
+  if (this != default_instance_) {
+    delete status_;
+  }
+}
+
+void ResponseSystemExternalAccess::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ResponseSystemExternalAccess::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ResponseSystemExternalAccess_descriptor_;
+}
+
+const ResponseSystemExternalAccess& ResponseSystemExternalAccess::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_system_2eproto();  return *default_instance_;
+}
+
+ResponseSystemExternalAccess* ResponseSystemExternalAccess::default_instance_ = NULL;
+
+ResponseSystemExternalAccess* ResponseSystemExternalAccess::New() const {
+  return new ResponseSystemExternalAccess;
+}
+
+void ResponseSystemExternalAccess::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_status()) {
+      if (status_ != NULL) status_->::rsctrl::core::Status::Clear();
+    }
+    ext_port_ = 0u;
+    if (has_dht_key()) {
+      if (dht_key_ != &::google::protobuf::internal::kEmptyString) {
+        dht_key_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ResponseSystemExternalAccess::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .rsctrl.core.Status status = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_status()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(16)) goto parse_ext_port;
+        break;
+      }
+      
+      // required uint32 ext_port = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_ext_port:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &ext_port_)));
+          set_has_ext_port();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_dht_key;
+        break;
+      }
+      
+      // required string dht_key = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_dht_key:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_dht_key()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->dht_key().data(), this->dht_key().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void ResponseSystemExternalAccess::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required .rsctrl.core.Status status = 1;
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->status(), output);
+  }
+  
+  // required uint32 ext_port = 2;
+  if (has_ext_port()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->ext_port(), output);
+  }
+  
+  // required string dht_key = 3;
+  if (has_dht_key()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->dht_key().data(), this->dht_key().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->dht_key(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* ResponseSystemExternalAccess::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required .rsctrl.core.Status status = 1;
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->status(), target);
+  }
+  
+  // required uint32 ext_port = 2;
+  if (has_ext_port()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->ext_port(), target);
+  }
+  
+  // required string dht_key = 3;
+  if (has_dht_key()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->dht_key().data(), this->dht_key().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->dht_key(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int ResponseSystemExternalAccess::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .rsctrl.core.Status status = 1;
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->status());
+    }
+    
+    // required uint32 ext_port = 2;
+    if (has_ext_port()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->ext_port());
+    }
+    
+    // required string dht_key = 3;
+    if (has_dht_key()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->dht_key());
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ResponseSystemExternalAccess::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ResponseSystemExternalAccess* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ResponseSystemExternalAccess*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ResponseSystemExternalAccess::MergeFrom(const ResponseSystemExternalAccess& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_status()) {
+      mutable_status()->::rsctrl::core::Status::MergeFrom(from.status());
+    }
+    if (from.has_ext_port()) {
+      set_ext_port(from.ext_port());
+    }
+    if (from.has_dht_key()) {
+      set_dht_key(from.dht_key());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ResponseSystemExternalAccess::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ResponseSystemExternalAccess::CopyFrom(const ResponseSystemExternalAccess& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ResponseSystemExternalAccess::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+  
+  if (has_status()) {
+    if (!this->status().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ResponseSystemExternalAccess::Swap(ResponseSystemExternalAccess* other) {
+  if (other != this) {
+    std::swap(status_, other->status_);
+    std::swap(ext_port_, other->ext_port_);
+    std::swap(dht_key_, other->dht_key_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ResponseSystemExternalAccess::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ResponseSystemExternalAccess_descriptor_;
+  metadata.reflection = ResponseSystemExternalAccess_reflection_;
+  return metadata;
+}
+
+
 // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace system

retroshare-nogui/src/rpc/proto/gencc/system.pb.h

@@ -38,6 +38,8 @@ class RequestSystemStatus;
 class ResponseSystemStatus;
 class RequestSystemQuit;
 class ResponseSystemQuit;
+class RequestSystemExternalAccess;
+class ResponseSystemExternalAccess;
 
 enum ResponseSystemStatus_NetCode {
   ResponseSystemStatus_NetCode_BAD_UNKNOWN = 0,
@@ -86,11 +88,12 @@ inline bool RequestSystemQuit_QuitCode_Parse(
 }
 enum RequestMsgIds {
   MsgId_RequestSystemStatus = 1,
-  MsgId_RequestSystemQuit = 2
+  MsgId_RequestSystemQuit = 2,
+  MsgId_RequestSystemExternalAccess = 3
 };
 bool RequestMsgIds_IsValid(int value);
 const RequestMsgIds RequestMsgIds_MIN = MsgId_RequestSystemStatus;
-const RequestMsgIds RequestMsgIds_MAX = MsgId_RequestSystemQuit;
+const RequestMsgIds RequestMsgIds_MAX = MsgId_RequestSystemExternalAccess;
 const int RequestMsgIds_ARRAYSIZE = RequestMsgIds_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* RequestMsgIds_descriptor();
@@ -105,11 +108,12 @@ inline bool RequestMsgIds_Parse(
 }
 enum ResponseMsgIds {
   MsgId_ResponseSystemStatus = 1,
-  MsgId_ResponseSystemQuit = 2
+  MsgId_ResponseSystemQuit = 2,
+  MsgId_ResponseSystemExternalAccess = 3
 };
 bool ResponseMsgIds_IsValid(int value);
 const ResponseMsgIds ResponseMsgIds_MIN = MsgId_ResponseSystemStatus;
-const ResponseMsgIds ResponseMsgIds_MAX = MsgId_ResponseSystemQuit;
+const ResponseMsgIds ResponseMsgIds_MAX = MsgId_ResponseSystemExternalAccess;
 const int ResponseMsgIds_ARRAYSIZE = ResponseMsgIds_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* ResponseMsgIds_descriptor();
@@ -538,6 +542,185 @@ class ResponseSystemQuit : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static ResponseSystemQuit* default_instance_;
 };
+// -------------------------------------------------------------------
+
+class RequestSystemExternalAccess : public ::google::protobuf::Message {
+ public:
+  RequestSystemExternalAccess();
+  virtual ~RequestSystemExternalAccess();
+  
+  RequestSystemExternalAccess(const RequestSystemExternalAccess& from);
+  
+  inline RequestSystemExternalAccess& operator=(const RequestSystemExternalAccess& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RequestSystemExternalAccess& default_instance();
+  
+  void Swap(RequestSystemExternalAccess* other);
+  
+  // implements Message ----------------------------------------------
+  
+  RequestSystemExternalAccess* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RequestSystemExternalAccess& from);
+  void MergeFrom(const RequestSystemExternalAccess& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // @@protoc_insertion_point(class_scope:rsctrl.system.RequestSystemExternalAccess)
+ private:
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[1];
+  
+  friend void  protobuf_AddDesc_system_2eproto();
+  friend void protobuf_AssignDesc_system_2eproto();
+  friend void protobuf_ShutdownFile_system_2eproto();
+  
+  void InitAsDefaultInstance();
+  static RequestSystemExternalAccess* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ResponseSystemExternalAccess : public ::google::protobuf::Message {
+ public:
+  ResponseSystemExternalAccess();
+  virtual ~ResponseSystemExternalAccess();
+  
+  ResponseSystemExternalAccess(const ResponseSystemExternalAccess& from);
+  
+  inline ResponseSystemExternalAccess& operator=(const ResponseSystemExternalAccess& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ResponseSystemExternalAccess& default_instance();
+  
+  void Swap(ResponseSystemExternalAccess* other);
+  
+  // implements Message ----------------------------------------------
+  
+  ResponseSystemExternalAccess* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ResponseSystemExternalAccess& from);
+  void MergeFrom(const ResponseSystemExternalAccess& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required .rsctrl.core.Status status = 1;
+  inline bool has_status() const;
+  inline void clear_status();
+  static const int kStatusFieldNumber = 1;
+  inline const ::rsctrl::core::Status& status() const;
+  inline ::rsctrl::core::Status* mutable_status();
+  inline ::rsctrl::core::Status* release_status();
+  
+  // required uint32 ext_port = 2;
+  inline bool has_ext_port() const;
+  inline void clear_ext_port();
+  static const int kExtPortFieldNumber = 2;
+  inline ::google::protobuf::uint32 ext_port() const;
+  inline void set_ext_port(::google::protobuf::uint32 value);
+  
+  // required string dht_key = 3;
+  inline bool has_dht_key() const;
+  inline void clear_dht_key();
+  static const int kDhtKeyFieldNumber = 3;
+  inline const ::std::string& dht_key() const;
+  inline void set_dht_key(const ::std::string& value);
+  inline void set_dht_key(const char* value);
+  inline void set_dht_key(const char* value, size_t size);
+  inline ::std::string* mutable_dht_key();
+  inline ::std::string* release_dht_key();
+  
+  // @@protoc_insertion_point(class_scope:rsctrl.system.ResponseSystemExternalAccess)
+ private:
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_ext_port();
+  inline void clear_has_ext_port();
+  inline void set_has_dht_key();
+  inline void clear_has_dht_key();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  ::rsctrl::core::Status* status_;
+  ::std::string* dht_key_;
+  ::google::protobuf::uint32 ext_port_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_system_2eproto();
+  friend void protobuf_AssignDesc_system_2eproto();
+  friend void protobuf_ShutdownFile_system_2eproto();
+  
+  void InitAsDefaultInstance();
+  static ResponseSystemExternalAccess* default_instance_;
+};
 // ===================================================================
 
 
@@ -734,6 +917,123 @@ inline ::rsctrl::core::Status* ResponseSystemQuit::release_status() {
   return temp;
 }
 
+// -------------------------------------------------------------------
+
+// RequestSystemExternalAccess
+
+// -------------------------------------------------------------------
+
+// ResponseSystemExternalAccess
+
+// required .rsctrl.core.Status status = 1;
+inline bool ResponseSystemExternalAccess::has_status() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ResponseSystemExternalAccess::set_has_status() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ResponseSystemExternalAccess::clear_has_status() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ResponseSystemExternalAccess::clear_status() {
+  if (status_ != NULL) status_->::rsctrl::core::Status::Clear();
+  clear_has_status();
+}
+inline const ::rsctrl::core::Status& ResponseSystemExternalAccess::status() const {
+  return status_ != NULL ? *status_ : *default_instance_->status_;
+}
+inline ::rsctrl::core::Status* ResponseSystemExternalAccess::mutable_status() {
+  set_has_status();
+  if (status_ == NULL) status_ = new ::rsctrl::core::Status;
+  return status_;
+}
+inline ::rsctrl::core::Status* ResponseSystemExternalAccess::release_status() {
+  clear_has_status();
+  ::rsctrl::core::Status* temp = status_;
+  status_ = NULL;
+  return temp;
+}
+
+// required uint32 ext_port = 2;
+inline bool ResponseSystemExternalAccess::has_ext_port() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ResponseSystemExternalAccess::set_has_ext_port() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ResponseSystemExternalAccess::clear_has_ext_port() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ResponseSystemExternalAccess::clear_ext_port() {
+  ext_port_ = 0u;
+  clear_has_ext_port();
+}
+inline ::google::protobuf::uint32 ResponseSystemExternalAccess::ext_port() const {
+  return ext_port_;
+}
+inline void ResponseSystemExternalAccess::set_ext_port(::google::protobuf::uint32 value) {
+  set_has_ext_port();
+  ext_port_ = value;
+}
+
+// required string dht_key = 3;
+inline bool ResponseSystemExternalAccess::has_dht_key() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ResponseSystemExternalAccess::set_has_dht_key() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ResponseSystemExternalAccess::clear_has_dht_key() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ResponseSystemExternalAccess::clear_dht_key() {
+  if (dht_key_ != &::google::protobuf::internal::kEmptyString) {
+    dht_key_->clear();
+  }
+  clear_has_dht_key();
+}
+inline const ::std::string& ResponseSystemExternalAccess::dht_key() const {
+  return *dht_key_;
+}
+inline void ResponseSystemExternalAccess::set_dht_key(const ::std::string& value) {
+  set_has_dht_key();
+  if (dht_key_ == &::google::protobuf::internal::kEmptyString) {
+    dht_key_ = new ::std::string;
+  }
+  dht_key_->assign(value);
+}
+inline void ResponseSystemExternalAccess::set_dht_key(const char* value) {
+  set_has_dht_key();
+  if (dht_key_ == &::google::protobuf::internal::kEmptyString) {
+    dht_key_ = new ::std::string;
+  }
+  dht_key_->assign(value);
+}
+inline void ResponseSystemExternalAccess::set_dht_key(const char* value, size_t size) {
+  set_has_dht_key();
+  if (dht_key_ == &::google::protobuf::internal::kEmptyString) {
+    dht_key_ = new ::std::string;
+  }
+  dht_key_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ResponseSystemExternalAccess::mutable_dht_key() {
+  set_has_dht_key();
+  if (dht_key_ == &::google::protobuf::internal::kEmptyString) {
+    dht_key_ = new ::std::string;
+  }
+  return dht_key_;
+}
+inline ::std::string* ResponseSystemExternalAccess::release_dht_key() {
+  clear_has_dht_key();
+  if (dht_key_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = dht_key_;
+    dht_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+
 
 // @@protoc_insertion_point(namespace_scope)
 

retroshare-nogui/src/rpc/proto/rpcprotosystem.cc

@@ -27,10 +27,14 @@
 #include <retroshare/rspeers.h>
 #include <retroshare/rsconfig.h>
 #include <retroshare/rsiface.h>
+#include <retroshare/rsdht.h>
 
 #include <iostream>
 #include <algorithm>
 
+// NASTY GLOBAL VARIABLE HACK - NEED TO THINK OF A BETTER SYSTEM.
+uint16_t RpcProtoSystem::mExtPort = 0;
+
 RpcProtoSystem::RpcProtoSystem(uint32_t serviceId)
 	:RpcQueueService(serviceId)
 { 
@@ -91,6 +95,9 @@ int RpcProtoSystem::processMsg(uint32_t chan_id, uint32_t msg_id, uint32_t req_i
 			processSystemQuit(chan_id, msg_id, req_id, msg);
 			break;
 #endif
+		case rsctrl::system::MsgId_RequestSystemExternalAccess:
+			processSystemExternalAccess(chan_id, msg_id, req_id, msg);
+			break;
 		default:
 			std::cerr << "RpcProtoSystem::processMsg() ERROR should never get here";
 			std::cerr << std::endl;
@@ -284,3 +291,64 @@ int RpcProtoSystem::processSystemQuit(uint32_t chan_id, uint32_t msg_id, uint32_
 }
 
 
+int RpcProtoSystem::processSystemExternalAccess(uint32_t chan_id, uint32_t msg_id, uint32_t req_id, const std::string &msg)
+{
+	std::cerr << "RpcProtoSystem::processSystemExternalAccess()";
+	std::cerr << std::endl;
+
+	// parse msg.
+	rsctrl::system::RequestSystemExternalAccess req;
+	if (!req.ParseFromString(msg))
+	{
+		std::cerr << "RpcProtoSystem::processSystemExternalAccess() ERROR ParseFromString()";
+		std::cerr << std::endl;
+		return 0;
+	}
+
+	// NO Options... so go straight to answer.
+	// response.
+	rsctrl::system::ResponseSystemExternalAccess resp;
+	bool success = true;
+
+
+	std::string dhtKey;
+	if (!rsDht->getOwnDhtId(dhtKey))
+	{
+		success = false;
+	}
+	// have to set something anyway!.
+	resp.set_dht_key(dhtKey);
+        // NASTY GLOBAL VARIABLE HACK - NEED TO THINK OF A BETTER SYSTEM.
+        resp.set_ext_port(mExtPort);
+
+        if (success)
+	{
+		rsctrl::core::Status *status = resp.mutable_status();
+		status->set_code(rsctrl::core::Status::SUCCESS);
+	}
+	else
+	{
+		rsctrl::core::Status *status = resp.mutable_status();
+		status->set_code(rsctrl::core::Status::FAILED);
+		status->set_msg("Unknown ERROR");
+	}
+
+	std::string outmsg;
+	if (!resp.SerializeToString(&outmsg))
+	{
+		std::cerr << "RpcProtoSystem::processSystemExternalAccess() ERROR SerialiseToString()";
+		std::cerr << std::endl;
+		return 0;
+	}
+	
+	// Correctly Name Message.
+	uint32_t out_msg_id = constructMsgId(rsctrl::core::CORE, rsctrl::core::SYSTEM, 
+				rsctrl::system::MsgId_ResponseSystemExternalAccess, true);
+
+	// queue it.
+	queueResponse(chan_id, out_msg_id, req_id, outmsg);
+
+	return 1;
+}
+
+

retroshare-nogui/src/rpc/proto/rpcprotosystem.h

@@ -36,6 +36,11 @@ public:
 
 	virtual int processSystemStatus(uint32_t chan_id, uint32_t msg_id, uint32_t req_id, const std::string &msg);
 	virtual int processSystemQuit(uint32_t chan_id, uint32_t msg_id, uint32_t req_id, const std::string &msg);
+	virtual int processSystemExternalAccess(uint32_t chan_id, uint32_t msg_id, uint32_t req_id, const std::string &msg);
+
+// NASTY GLOBAL VARIABLE HACK - NEED TO THINK OF A BETTER SYSTEM.
+static uint16_t mExtPort;
+
 };
 
 

rsctrl/src/definition/system.proto

@@ -9,11 +9,13 @@ import "core.proto";
 enum RequestMsgIds {
     MsgId_RequestSystemStatus = 1;
     MsgId_RequestSystemQuit   = 2;
+    MsgId_RequestSystemExternalAccess = 3;
 }
 
 enum ResponseMsgIds {
     MsgId_ResponseSystemStatus = 1;
     MsgId_ResponseSystemQuit   = 2;
+    MsgId_ResponseSystemExternalAccess = 3;
 }
 
 ///////////////////////////////////////////////////////////////
@@ -73,6 +75,24 @@ message ResponseSystemQuit {
   required rsctrl.core.Status status = 1;
 }
 
+
+///////////////////////////////////////////////////////////////
+
+// REQUEST: RequestSystemExternalAccess
+message RequestSystemExternalAccess {
+  // Nothing here?
+}
+
+// RESPONSE: ResponseSystemExternalAccess
+message ResponseSystemExternalAccess {
+
+  // Status of response.
+  required rsctrl.core.Status status = 1;
+
+  required uint32 ext_port		= 2;
+  required string dht_key		= 3;
+}
+
 ///////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////