--- /dev/null
+
+/*] Copyright (c) 2009-2010, Charles McGarvey [**************************
+**] All rights reserved.
+*
+* vi:ts=4 sw=4 tw=75
+*
+* Distributable under the terms and conditions of the 2-clause BSD license;
+* see the file COPYING for a complete text of the license.
+*
+**************************************************************************/
+
+#ifndef _MOOF_SOCKET_HH_
+#define _MOOF_SOCKET_HH_
+
+#include <cstring>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#include <Moof/Log.hh>
+#include <Moof/Packet.hh>
+#include <Moof/Thread.hh>
+
+
+namespace Mf {
+
+
+class SocketAddress
+{
+public:
+
+ SocketAddress(int type = SOCK_STREAM)
+ {
+ mType = type;
+ memset(&mAddress.in4, 0, sizeof(mAddress.in4));
+ mAddress.in4.sin_family = AF_INET;
+ mAddress.in4.sin_port = 0;
+ mAddress.in4.sin_addr.s_addr = INADDR_ANY;
+ mName = "[any]";
+ mSize = sizeof(mAddress.in4);
+ }
+
+ SocketAddress(const std::string& name, const std::string& service,
+ int type = SOCK_STREAM, int family = AF_INET)
+ {
+ ASSERT(type == SOCK_STREAM || type == SOCK_DGRAM);
+ ASSERT(family == AF_INET || family == AF_INET6 || family == AF_UNSPEC);
+
+ struct addrinfo hints;
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = family;
+ hints.ai_socktype = type;
+ hints.ai_flags = AI_PASSIVE | AI_CANONNAME;
+
+ struct addrinfo* addr;
+ int status = getaddrinfo(name.length() > 0 ? name.c_str() : 0,
+ service.length() > 0 ? service.c_str() : 0, &hints, &addr);
+ if (status != 0)
+ {
+ Mf::logError("uh oh, that didn't work!");
+ return;
+ }
+
+ mType = addr->ai_socktype;
+ memcpy(&mAddress.sa, addr->ai_addr, addr->ai_addrlen);
+ mName = addr->ai_canonname;
+ mSize = addr->ai_addrlen;
+
+ freeaddrinfo(addr);
+ }
+
+ SocketAddress(const std::string& name, const struct addrinfo* addr)
+ {
+ mType = addr->ai_socktype;
+ memcpy(&mAddress.sa, addr->ai_addr, addr->ai_addrlen);
+ mName = name;
+ mSize = addr->ai_addrlen;
+ }
+
+ SocketAddress(const struct sockaddr* addr, size_t size,
+ int type = SOCK_STREAM)
+ {
+ mType = type;
+ memcpy(&mAddress.sa, addr, size);
+ mSize = size;
+
+ char name[128] = {'\0'};
+ inet_ntop(addr->sa_family, (struct sockaddr_in*)addr,
+ name, sizeof(name));
+ mName = name;
+ }
+
+
+ const std::string& name() const
+ {
+ return mName;
+ }
+
+ unsigned short port() const
+ {
+ return ntohs(mAddress.in4.sin_port);
+ }
+
+ int type() const
+ {
+ return mType;
+ }
+
+ int family() const
+ {
+ return mAddress.sa.sa_family;
+ }
+
+
+ const struct sockaddr* address() const
+ {
+ return &mAddress.sa;
+ }
+
+ size_t size() const
+ {
+ return mSize;
+ }
+
+
+ static int resolve(const std::string& name, const std::string& service,
+ int type, int family, std::vector<SocketAddress>& resolved)
+ {
+ ASSERT(type == SOCK_STREAM || type == SOCK_DGRAM);
+ ASSERT(family == AF_INET || family == AF_INET6 || family == AF_UNSPEC);
+
+ struct addrinfo hints;
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = family;
+ hints.ai_socktype = type;
+ hints.ai_flags = AI_PASSIVE | AI_CANONNAME;
+
+ struct addrinfo* list;
+ int status = getaddrinfo(name.length() > 0 ? name.c_str() : 0,
+ service.length() > 0 ? service.c_str() : 0, &hints, &list);
+ if (status != 0) return -1;
+
+ resolved.clear();
+
+ const char* canonicalName = list->ai_canonname;
+ struct addrinfo* addr = list;
+ while (addr != 0)
+ {
+ resolved.push_back(SocketAddress(canonicalName, addr));
+ addr = addr->ai_next;
+ }
+
+ freeaddrinfo(list);
+ return 0;
+ }
+
+
+private:
+
+ union
+ {
+ sockaddr sa;
+ sockaddr_in in4;
+ sockaddr_in6 in6;
+ } mAddress;
+ size_t mSize;
+ std::string mName;
+ int mType;
+};
+
+
+class Socket
+{
+public:
+
+ Socket(const SocketAddress& address) :
+ mAddress(address)
+ {
+ mFd = socket(address.family(), address.type(), 0);
+ }
+
+ ~Socket()
+ {
+ close(mFd);
+ }
+
+
+ bool isConnected() const
+ {
+ return false;
+ }
+
+ const SocketAddress& address() const
+ {
+ return mAddress;
+ }
+
+
+ void write(const Packet& packet)
+ {
+ write(mAddress, packet);
+ }
+
+ void write(const SocketAddress& address, const Packet& packet)
+ {
+ sendto(mFd, packet.bytes(), packet.size(), 0,
+ address.address(), address.size());
+ }
+
+ Packet read()
+ {
+ char buffer[1024];
+ int size = recv(mFd, buffer, sizeof(buffer), 0);
+
+ return Packet(buffer, size);
+ }
+
+ Packet read(SocketAddress& address)
+ {
+ union
+ {
+ sockaddr sa;
+ sockaddr_storage storage;
+ } addr;
+ socklen_t length = sizeof(addr);
+
+ char buffer[1024];
+ int size = recvfrom(mFd, buffer, sizeof(buffer), 0,
+ &addr.sa, &length);
+
+ address = SocketAddress(&addr.sa, length, SOCK_DGRAM);
+ return Packet(buffer, size);
+ }
+
+
+private:
+
+ int mFd;
+ SocketAddress mAddress;
+};
+
+
+class ResolverTask : public ThreadedTask
+{
+public:
+
+ ResolverTask(const std::string& name, const std::string& service,
+ int type = SOCK_STREAM, int family = AF_UNSPEC) :
+ mIsDone(false)
+ {
+ mFunction = boost::bind(&ResolverTask::resolve,
+ this, name, service, type, family);
+ }
+
+
+ bool isDone() const
+ {
+ return mIsDone;
+ }
+
+ void run()
+ {
+ if (!mThread) mThread = Mf::detachFunction(mFunction);
+ }
+
+
+ const std::vector<SocketAddress>& addresses() const
+ {
+ return mAddressList;
+ }
+
+
+private:
+
+ int resolve(const std::string& name, const std::string& service,
+ int type, int family)
+ {
+ int status = SocketAddress::resolve(name, service,
+ type, family, mAddressList);
+ mIsDone = true;
+ return status;
+ }
+
+
+ std::vector<SocketAddress> mAddressList;
+ bool mIsDone;
+ Function mFunction;
+};
+
+
+} // namespace Mf
+
+#endif // _MOOF_SOCKET_HH_
+
projects / chaz / yoink / blobdiff