haiku.git

/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef UNIX_ADDRESS_H
#define UNIX_ADDRESS_H

#include <sys/un.h>

#include <SupportDefs.h>


// NOTE: We support the standard FS address space as well as the alternative
// internal address space Linux features (sun_path[0] is 0, followed by 5 hex
// digits, without null-termination). The latter one is nice to have, because
// the address lookup is quick (hash table lookup, instead of asking the VFS to
// resolve the path), and we don't have to pollute the FS when auto-binding
// sockets (e.g. on connect()).


#define	INTERNAL_UNIX_ADDRESS_LEN	(2 + 1 + 5)
	// sun_len + sun_family + null byte + 5 hex digits


struct vnode;


class UnixAddress {
public:
	UnixAddress()
	{
		Unset();
	}

	UnixAddress(const UnixAddress& other)
	{
		*this = other;
	}

	UnixAddress(int32 internalID)
	{
		SetTo(internalID);
	}

	UnixAddress(dev_t volumeID, ino_t nodeID, struct vnode* vnode)
	{
		SetTo(volumeID, nodeID, vnode);
	}

	void SetTo(int32 internalID)
	{
		fInternalID = internalID;
		fVolumeID = -1;
		fNodeID = -1;
		fVnode = NULL;
	}

	void SetTo(dev_t volumeID, ino_t nodeID, struct vnode* vnode)
	{
		fInternalID = -1;
		fVolumeID = volumeID;
		fNodeID = nodeID;
		fVnode = vnode;
	}

	void Unset()
	{
		fInternalID = -1;
		fVolumeID = -1;
		fNodeID = -1;
		fVnode = NULL;
	}

	bool IsValid() const
	{
		return fInternalID >= 0 || fVolumeID >= 0;
	}

	bool IsInternalAddress() const
	{
		return fInternalID >= 0;
	}

	int32 InternalID() const
	{
		return fInternalID;
	}

	int32 VolumeID() const
	{
		return fVolumeID;
	}

	int32 NodeID() const
	{
		return fNodeID;
	}

	struct vnode* Vnode() const
	{
		return fVnode;
	}

	uint32 HashCode() const
	{
		return fInternalID >= 0
			? fInternalID
			: uint32(fVolumeID) ^ uint32(fNodeID);
	}

	char* ToString(char *buffer, size_t bufferSize) const;

	UnixAddress& operator=(const UnixAddress& other)
	{
		fInternalID = other.fInternalID;
		fVolumeID = other.fVolumeID;
		fNodeID = other.fNodeID;
		fVnode = other.fVnode;
		return *this;
	}

	bool operator==(const UnixAddress& other) const
	{
		return fInternalID >= 0
			? fInternalID == other.fInternalID
			: fVolumeID == other.fVolumeID
				&& fNodeID == other.fNodeID;
	}

	bool operator!=(const UnixAddress& other) const
	{
		return !(*this == other);
	}

	static bool IsEmptyAddress(const sockaddr_un& address)
	{
		return address.sun_len == sizeof(sockaddr)
			&& address.sun_path[0] == '\0' && address.sun_path[1] == '\0';
	}

	static int32 InternalID(const sockaddr_un& address)
	{
		if (address.sun_len < INTERNAL_UNIX_ADDRESS_LEN
				|| address.sun_path[0] != '\0') {
			return B_BAD_VALUE;
		}

		// parse the ID
		int32 id = 0;

		for (int32 i = 0; i < 5; i++) {
			char c = address.sun_path[i + 1];
			if (c >= '0' && c <= '9')
				id = (id << 4) + (c - '0');
			else if (c >= 'a' && c <= 'f')
				id = (id << 4) + 10 + (c - 'a');
			else
				return B_BAD_VALUE;
		}

		return id;
	}

private:
	// fat interface: If fInternalID is >= 0, it's an address in the internal
	// namespace, otherwise a FS address.
	int32			fInternalID;
	dev_t			fVolumeID;
	ino_t			fNodeID;
	struct vnode*	fVnode;
};


#endif	// UNIX_ADDRESS_H