/* vim: set expandtab ts=4 sw=4: */ /* * You may redistribute this program and/or modify it under the terms of * the GNU General Public License as published by the Free Software Foundation, * either version 3 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "util/events/FakeNetwork.h" #include "exception/Except.h" #include "interface/Iface.h" #include "interface/addressable/AddrIface.h" #include "memory/Allocator.h" #include "util/events/EventBase.h" #include "util/log/Log.h" #include "interface/ASynchronizer.h" #include "wire/Error.h" #define Map_USE_HASH #define Map_USE_COMPARATOR #define Map_NAME OfIfaces #define Map_KEY_TYPE struct Sockaddr* #define Map_VALUE_TYPE struct FakeNetwork_UDPIface_pvt* #include "util/Map.h" static inline uint32_t Map_OfIfaces_hash(struct Sockaddr** key) { return Sockaddr_hash(*key); } static inline int Map_OfIfaces_compare(struct Sockaddr** keyA, struct Sockaddr** keyB) { return Sockaddr_compare(*keyA, *keyB); } struct FakeNetwork_pvt { struct FakeNetwork pub; struct Allocator* alloc; struct Log* log; struct EventBase* base; struct ASynchronizer* async; struct Iface fromAsync; struct Iface toAsync; uint16_t lastPort; struct Map_OfIfaces map; Identity }; struct FakeNetwork_UDPIface_pvt { struct FakeNetwork_UDPIface pub; struct FakeNetwork_pvt* fnp; Identity }; static void popSockaddr(struct Message* msg, struct Sockaddr_storage* ss) { uint64_t length = 0; Er_assert(Message_epop(msg, &length, 8)); Er_assert(Message_eshift(msg, 8)); Assert_true(length >= Sockaddr_OVERHEAD); Assert_true(length <= sizeof(struct Sockaddr_storage)); Er_assert(Message_epop(msg, ss, length)); } static void pushSockaddr(struct Message* msg, struct Sockaddr* sa) { Er_assert(Message_epush(msg, sa, sa->addrLen)); } static Iface_DEFUN fromAsync(struct Message* msg, struct Iface* fnpFromAsync) { struct FakeNetwork_pvt* fnp = Identity_containerOf(fnpFromAsync, struct FakeNetwork_pvt, fromAsync); struct Sockaddr_storage dest; struct Sockaddr* dp = &dest.addr; popSockaddr(msg, &dest); int idx = Map_OfIfaces_indexForKey(&dp, &fnp->map); if (idx == -1) { char* destAddr = Sockaddr_print(dp, Message_getAlloc(msg)); // hack, the 'dest' becomes the source. popSockaddr(msg, &dest); char* srcAddr = Sockaddr_print(dp, Message_getAlloc(msg)); Log_debug(fnp->log, "Message with unknown dest address [%s] from [%s]", destAddr, srcAddr); return Error(msg, "INVALID"); } struct FakeNetwork_UDPIface_pvt* fnip = Identity_check(fnp->map.values[idx]); return Iface_next(&fnip->pub.generic.iface, msg); } static Iface_DEFUN incoming(struct Message* msg, struct Iface* iface) { struct FakeNetwork_UDPIface_pvt* fnip = Identity_check((struct FakeNetwork_UDPIface_pvt*) iface); struct FakeNetwork_pvt* fnp = Identity_check(fnip->fnp); // Swap so that the message contains [dest][src][content] struct Sockaddr_storage dest; popSockaddr(msg, &dest); pushSockaddr(msg, fnip->pub.generic.addr); pushSockaddr(msg, &dest.addr); return Iface_next(&fnp->toAsync, msg); } struct FakeNetwork_UDPIface* FakeNetwork_iface(struct FakeNetwork* net, struct Sockaddr* bindAddress, struct Allocator* allocator) { struct FakeNetwork_pvt* fnp = Identity_check((struct FakeNetwork_pvt*) net); struct Allocator* alloc = Allocator_child(allocator); struct Sockaddr* addr = Sockaddr_clone(bindAddress, alloc); uint8_t* addrBytes; int addrLen = Sockaddr_getAddress(addr, &addrBytes); if (Sockaddr_getPort(addr) == 0) { Sockaddr_setPort(addr, ++fnp->lastPort); // Check for wrapping. Assert_true(fnp->lastPort != 0); Assert_true(addrLen == 4); Bits_memcpy(addrBytes, ((uint8_t[]){127, 0, 0, 1}), 4); } else if (addrLen == 4 && !Bits_memcmp(addrBytes, "\0\0\0\0", 4)) { Assert_failure("Address 0 with port specified is not allowed"); } if (Map_OfIfaces_indexForKey(&addr, &fnp->map) != -1) { return NULL; } struct FakeNetwork_UDPIface_pvt* fnip = Allocator_calloc(alloc, sizeof(struct FakeNetwork_UDPIface_pvt), 1); Map_OfIfaces_put(&addr, &fnip, &fnp->map); fnip->fnp = fnp; fnip->pub.generic.alloc = alloc; fnip->pub.generic.addr = addr; fnip->pub.generic.iface.send = incoming; Identity_set(fnip); return &fnip->pub; } struct FakeNetwork* FakeNetwork_new(struct EventBase* base, struct Allocator* allocator, struct Log* logger) { struct Allocator* alloc = Allocator_child(allocator); struct FakeNetwork_pvt* fnp = Allocator_calloc(alloc, sizeof(struct FakeNetwork_pvt), 1); fnp->alloc = alloc; fnp->log = logger; fnp->base = base; fnp->map.allocator = alloc; fnp->async = ASynchronizer_new(alloc, base, logger); fnp->fromAsync.send = fromAsync; Iface_plumb(&fnp->fromAsync, &fnp->async->ifB); Iface_plumb(&fnp->toAsync, &fnp->async->ifA); Identity_set(fnp); return &fnp->pub; }