gchar* packet_getString(Packet* packet) {
_packet_lock(packet);
GString* packetBuffer = g_string_new("");
switch (packet->protocol) {
case PLOCAL: {
PacketLocalHeader* header = packet->header;
g_string_append_printf(packetBuffer, "%i -> %i bytes %u",
header->sourceDescriptorHandle, header->destinationDescriptorHandle,
packet->payloadLength);
break;
}
case PUDP: {
PacketUDPHeader* header = packet->header;
gchar* sourceIPString = address_ipToNewString(header->sourceIP);
gchar* destinationIPString = address_ipToNewString(header->destinationIP);
g_string_append_printf(packetBuffer, "%s:%u -> ",
sourceIPString, ntohs(header->sourcePort));
g_string_append_printf(packetBuffer, "%s:%u bytes %u",
destinationIPString, ntohs( header->destinationPort),
packet->payloadLength);
g_free(sourceIPString);
g_free(destinationIPString);
break;
}
case PTCP: {
PacketTCPHeader* header = packet->header;
gchar* sourceIPString = address_ipToNewString(header->sourceIP);
gchar* destinationIPString = address_ipToNewString(header->destinationIP);
g_string_append_printf(packetBuffer, "%s:%u -> ",
sourceIPString, ntohs(header->sourcePort));
g_string_append_printf(packetBuffer, "%s:%u packet# %u ack# %u window %u bytes %u",
destinationIPString, ntohs(header->destinationPort),
header->sequence, header->acknowledgement, header->window, packet->payloadLength);
g_free(sourceIPString);
g_free(destinationIPString);
break;
}
default: {
error("unrecognized protocol");
break;
}
}
_packet_unlock(packet);
return g_string_free(packetBuffer, FALSE);
}
void socket_setSocketName(Socket* socket, in_addr_t ip, in_port_t port, gboolean isInternal) {
MAGIC_ASSERT(socket);
socket->boundAddress = ip;
socket->boundPort = port;
/* store the new ascii name of this socket endpoint */
if(socket->boundString) {
g_free(socket->boundString);
}
gchar* ipString = address_ipToNewString(ip);
GString* stringBuffer = g_string_new(ipString);
g_free(ipString);
g_string_append_printf(stringBuffer, ":%u (descriptor %i)", ntohs(port), socket->super.super.handle);
socket->boundString = g_string_free(stringBuffer, FALSE);
/* children of server sockets must not have the same key as the parent
* otherwise when the child is closed, the parent's interface association
* will be removed. in fact, they dont need a key because their parent
* will handle incoming packets and will hand them off as necessary */
if(isInternal) {
socket->associationKey = 0;
} else {
socket->associationKey = PROTOCOL_DEMUX_KEY(socket->protocol, port);
}
/* the socket is now bound */
socket->flags |= SF_BOUND;
}
void socket_setPeerName(Socket* socket, in_addr_t ip, in_port_t port) {
MAGIC_ASSERT(socket);
socket->peerIP = ip;
socket->peerPort = port;
/* store the new ascii name of this peer */
if(socket->peerString) {
g_free(socket->peerString);
}
gchar* ipString = address_ipToNewString(ip);
GString* stringBuffer = g_string_new(ipString);
g_free(ipString);
g_string_append_printf(stringBuffer, ":%u", ntohs(port));
socket->peerString = g_string_free(stringBuffer, FALSE);
}
Address* address_new(GQuark hostID, guint mac, guint32 ip, const gchar* name, gboolean isLocal) {
Address* address = g_new0(Address, 1);
MAGIC_INIT(address);
address->hostID = hostID;
address->mac = mac;
address->ip = ip;
address->ipString = address_ipToNewString((in_addr_t)ip);
address->isLocal = isLocal;
address->name = g_strdup(name);
address->referenceCount = 1;
GString* stringBuffer = g_string_new(NULL);
g_string_printf(stringBuffer, "%s-%s (%s,mac=%i)", address->name, address->ipString,
address->isLocal ? "lo" : "eth", address->mac);
address->idString = g_string_free(stringBuffer, FALSE);
return address;
}
void networkinterface_packetDropped(NetworkInterface* interface, Packet* packet) {
MAGIC_ASSERT(interface);
/*
* someone dropped a packet belonging to our interface
* hand it off to the correct socket layer
*/
gint key = packet_getSourceAssociationKey(packet);
Socket* socket = g_hash_table_lookup(interface->boundSockets, GINT_TO_POINTER(key));
/* just ignore if the socket closed in the meantime */
if(socket) {
socket_droppedPacket(socket, packet);
} else {
in_addr_t ip = packet_getSourceIP(packet);
gchar* ipString = address_ipToNewString(ip);
debug("interface dropping packet from %s:%u, no socket registered at %i",
ipString, packet_getSourcePort(packet), key);
g_free(ipString);
}
}
gint host_connectToPeer(Host* host, gint handle, const struct sockaddr* address) {
MAGIC_ASSERT(host);
sa_family_t family = 0;
in_addr_t peerIP = 0;
in_port_t peerPort = 0;
if(address->sa_family == AF_INET) {
struct sockaddr_in* saddr = (struct sockaddr_in*) address;
family = saddr->sin_family;
peerIP = saddr->sin_addr.s_addr;
peerPort = saddr->sin_port;
} else if (address->sa_family == AF_UNIX) {
struct sockaddr_un* saddr = (struct sockaddr_un*) address;
family = saddr->sun_family;
gchar* sockpath = saddr->sun_path;
peerIP = htonl(INADDR_LOOPBACK);
gpointer val = g_hash_table_lookup(host->unixPathToPortMap, sockpath);
if(val) {
peerPort = (in_port_t)GPOINTER_TO_UINT(val);
}
}
in_addr_t loIP = htonl(INADDR_LOOPBACK);
/* make sure we will be able to route this later */
if(peerIP != loIP) {
Address* myAddress = networkinterface_getAddress(host->defaultInterface);
Address* peerAddress = dns_resolveIPToAddress(worker_getDNS(), peerIP);
if(!peerAddress || !topology_isRoutable(worker_getTopology(), myAddress, peerAddress)) {
/* can't route it - there is no node with this address */
gchar* peerAddressString = address_ipToNewString(peerIP);
warning("attempting to connect to address '%s:%u' for which no host exists", peerAddressString, ntohs(peerPort));
g_free(peerAddressString);
return ECONNREFUSED;
}
}
Descriptor* descriptor = host_lookupDescriptor(host, handle);
if(descriptor == NULL) {
warning("descriptor handle '%i' not found", handle);
return EBADF;
}
DescriptorStatus status = descriptor_getStatus(descriptor);
if(status & DS_CLOSED) {
warning("descriptor handle '%i' not a valid open descriptor", handle);
return EBADF;
}
DescriptorType type = descriptor_getType(descriptor);
if(type != DT_TCPSOCKET && type != DT_UDPSOCKET) {
warning("wrong type for descriptor handle '%i'", handle);
return ENOTSOCK;
}
Socket* socket = (Socket*) descriptor;
if(!socket_isFamilySupported(socket, family)) {
return EAFNOSUPPORT;
}
if(type == DT_TCPSOCKET) {
gint error = tcp_getConnectError((TCP*)socket);
if(error) {
return error;
}
}
if (address->sa_family == AF_UNIX) {
struct sockaddr_un* saddr = (struct sockaddr_un*) address;
socket_setUnixPath(socket, saddr->sun_path, FALSE);
}
if(!socket_isBound(socket)) {
/* do an implicit bind to a random port.
* use default interface unless the remote peer is on loopback */
in_addr_t defaultIP = networkinterface_getIPAddress(host->defaultInterface);
in_addr_t bindAddress = loIP == peerIP ? loIP : defaultIP;
in_port_t bindPort = _host_getRandomFreePort(host, bindAddress, type);
if(!bindPort) {
return EADDRNOTAVAIL;
}
_host_associateInterface(host, socket, bindAddress, bindPort);
}
return socket_connectToPeer(socket, peerIP, peerPort, family);
}
