Add Files.

Author: liulilittle

ppp/app/client/VEthernetNetworkSwitcher.cpp

@@ -22,6 +22,7 @@ using ppp::threading::Timer;
 using ppp::threading::Executors;
 using ppp::net::AddressFamily;
 using ppp::net::IPEndPoint;
+using ppp::net::Ipep;
 using ppp::net::native::ip_hdr;
 using ppp::net::native::udp_hdr;
 using ppp::net::native::icmp_hdr;
@@ -71,7 +72,7 @@ namespace ppp {
                     boost::asio::ip::udp::endpoint sourceEP = IPEndPoint::ToEndPoint<boost::asio::ip::udp>(frame->Source);
                     std::shared_ptr<VEthernetDatagramPort> datagram = AllocDatagramPort(sourceEP);
                     if (NULL != datagram) {
-                        const std::shared_ptr<BufferSegment>& messages = packet->Payload;
+                        const std::shared_ptr<BufferSegment>& messages = frame->Payload;
                         if (NULL != messages) {
                             boost::asio::ip::udp::endpoint destinationEP = IPEndPoint::ToEndPoint<boost::asio::ip::udp>(frame->Destination);
                             return datagram->SendTo(messages->Buffer.get(), messages->Length, destinationEP);
@@ -119,6 +120,7 @@ namespace ppp {
 
             VEthernetNetworkSwitcher::VEthernetDatagramPortPtr VEthernetNetworkSwitcher::AllocDatagramPort(const boost::asio::ip::udp::endpoint& sourceEP) noexcept {
                 using VEthernetDisposedEventHandler = VEthernetDatagramPort::VEthernetDisposedEventHandler;
+                using VEthernetMessageEventHandler = VEthernetDatagramPort::VEthernetMessageEventHandler;
 
                 SynchronizedObjectScope scope(syncobj_);
                 if (this->IsDisposed()) {
@@ -145,6 +147,25 @@ namespace ppp {
                     [self, this](VEthernetDatagramPort* datagram) noexcept {
                         DeleteDatagramPort(datagram->GetLocalEndPoint());
                     });
+                datagram->MessageEvent = make_shared_object<VEthernetMessageEventHandler>(
+                    [self, this](VEthernetDatagramPort* datagram, void* packet, int packet_size, const boost::asio::ip::udp::endpoint& destinationEP) noexcept {
+                        boost::asio::ip::udp::endpoint remoteEP = Ipep::V6ToV4(destinationEP);
+                        boost::asio::ip::address address = remoteEP.address();
+                        if (address.is_v4()) {
+                            std::shared_ptr<BufferSegment> messages = make_shared_object<BufferSegment>();
+                            messages->Buffer = std::shared_ptr<Byte>(reinterpret_cast<Byte*>(packet), [](Byte*) noexcept {});
+                            messages->Length = packet_size;
+
+                            std::shared_ptr<UdpFrame> frame = make_shared_object<UdpFrame>();
+                            frame->AddressesFamily = AddressFamily::InterNetwork;
+                            frame->Source = IPEndPoint::ToEndPoint(remoteEP);
+                            frame->Destination = IPEndPoint::ToEndPoint(datagram->GetLocalEndPoint());
+                            frame->Payload = messages;
+
+                            std::shared_ptr<IPFrame> ip = UdpFrame::ToIp(frame.get());
+                            Output(ip.get());
+                        }
+                    });
                 return datagram;
             }
 

ppp/app/server/VirtualEthernetDatagramPort.cpp

@@ -124,8 +124,8 @@ namespace ppp {
                         bool disposing = false;
                         if (!ec) {
                             if (sz > 0) {
-                                boost::asio::ip::udp::endpoint destinationEP = Ipep::V6ToV4(sourceEP_);
-                                if (!manager_->DoSendTo(transmission_, remoteEP_, destinationEP, buffer_.get(), sz, nullof<YieldContext>())) {
+                                boost::asio::ip::udp::endpoint remoteEP = Ipep::V6ToV4(remoteEP_);
+                                if (!manager_->DoSendTo(transmission_, sourceEP_, remoteEP, buffer_.get(), sz, nullof<YieldContext>())) {
                                     disposing = true;
                                     transmission_->Dispose();
                                 }

ppp/ethernet/VEthernet.cpp

@@ -351,6 +351,21 @@ namespace ppp
             return true;
         }
 
+        bool VEthernet::Output(IPFrame* packet) noexcept
+        {
+            if (NULL == packet)
+            {
+                return false;
+            }
+
+            std::shared_ptr<BufferSegment> messages = IPFrame::ToArray(packet);
+            if (NULL == messages) {
+                return false;
+            }
+
+            return Output(messages->Buffer, messages->Length);
+        }
+
         bool VEthernet::Output(const void* packet, int packet_length) noexcept
         {
             std::shared_ptr<ITap> tap = GetTap();

ppp/ethernet/VEthernet.h

@@ -43,6 +43,7 @@ namespace ppp
             virtual std::shared_ptr<VNetstack>                              NewNetstack() noexcept;
             virtual bool                                                    OnPacketInput(const std::shared_ptr<IPFrame>& packet) noexcept;
             virtual void                                                    OnTick(uint64_t now) noexcept;
+            bool                                                            Output(IPFrame* packet) noexcept;
             virtual bool                                                    Output(const void* packet, int packet_length) noexcept;
             virtual bool                                                    Output(const std::shared_ptr<Byte>& packet, int packet_length) noexcept;
 

ppp/threading/Executors.cpp

@@ -361,12 +361,6 @@ namespace ppp
 
         }
 
-        Executors::Awaitable::~Awaitable() noexcept
-        {
-            completed = true;
-            cv.notify_all();
-        }
-
         void Executors::Awaitable::Processed() noexcept
         {
             completed = true;

ppp/threading/Executors.h

@@ -15,7 +15,6 @@ namespace ppp
             {
             public:
                 Awaitable() noexcept;
-                virtual ~Awaitable() noexcept;
 
             public:
                 virtual void                                            Processed() noexcept;