net::un::phy::PhysicalSocket< PhysicalPeerSocketT > Class Template Reference

#include <PhysicalSocket.h>

Inheritance diagram for net::un::phy::PhysicalSocket< PhysicalPeerSocketT >:

Collaboration diagram for net::un::phy::PhysicalSocket< PhysicalPeerSocketT >:

Public Types
using	Super = PhysicalPeerSocketT< net::un::SocketAddress >

Public Member Functions
	PhysicalSocket (int type, int protocol)
	PhysicalSocket (PhysicalSocket &&physicalSocket) noexcept
PhysicalSocket &	operator= (PhysicalSocket &&physicalSocket) noexcept
	~PhysicalSocket () override
int	bind (SocketAddress &bindAddress)

Private Attributes
int	lockFd = -1

Detailed Description

template<template< typename SocketAddressT > typename PhysicalPeerSocketT>
class net::un::phy::PhysicalSocket< PhysicalPeerSocketT >

Definition at line 55 of file PhysicalSocket.h.

Member Typedef Documentation

Super

template<template< typename SocketAddressT > typename PhysicalPeerSocketT>

using net::un::phy::PhysicalSocket< PhysicalPeerSocketT >::Super = PhysicalPeerSocketT<net::un::SocketAddress>

Definition at line 57 of file PhysicalSocket.h.

Constructor & Destructor Documentation

PhysicalSocket() [1/2]

template<template< typename SocketAddress > typename PhysicalPeerSocket>

net::un::phy::PhysicalSocket< PhysicalPeerSocket >::PhysicalSocket	(	int	type,
		int	protocol
	)

Definition at line 60 of file PhysicalSocket.hpp.

        : Super(PF_UNIX, type, protocol) {
    }

Referenced by net::un::dgram::Socket::Socket().

Here is the caller graph for this function:

PhysicalSocket() [2/2]

template<template< typename SocketAddress > typename PhysicalPeerSocket>

net::un::phy::PhysicalSocket< PhysicalPeerSocket >::PhysicalSocket ( PhysicalSocket< PhysicalPeerSocketT > &&  physicalSocket )

noexcept

Definition at line 65 of file PhysicalSocket.hpp.

        : Super(std::move(physicalSocket))
        , lockFd(std::exchange(physicalSocket.lockFd, -1)) {
    }

~PhysicalSocket()

template<template< typename SocketAddress > typename PhysicalPeerSocket>

net::un::phy::PhysicalSocket< PhysicalPeerSocket >::~PhysicalSocket ( )

override

Definition at line 79 of file PhysicalSocket.hpp.

                                                        {
        if (lockFd >= 0) {
            if (std::remove(Super::getBindAddress().getSunPath().data()) == 0) {
                LOG(DEBUG) << "Remove sun path: " << Super::getBindAddress().getSunPath();
            } else {
                PLOG(ERROR) << "Remove sun path: " << Super::getBindAddress().getSunPath();
            }
 
            if (core::system::flock(lockFd, LOCK_UN) == 0) {
                LOG(DEBUG) << "Remove lock from file: " << Super::getBindAddress().getSunPath().append(".lock");
            } else {
                PLOG(ERROR) << "Remove lock from file: " << Super::getBindAddress().getSunPath().append(".lock");
            }
 
            if (std::remove(Super::bindAddress.getSunPath().append(".lock").data()) == 0) {
                LOG(DEBUG) << "Remove lock file: " << Super::getBindAddress().getSunPath().append(".lock");
            } else {
                PLOG(ERROR) << "Remove lock file: " << Super::getBindAddress().getSunPath().append(".lock");
            }
 
            core::system::close(lockFd);
            lockFd = -1;
        }
    }

References core::system::close(), core::system::flock(), and net::un::phy::PhysicalSocket< PhysicalPeerSocketT >::lockFd.

Here is the call graph for this function:

Member Function Documentation

bind()

template<template< typename SocketAddress > typename PhysicalPeerSocket>

int net::un::phy::PhysicalSocket< PhysicalPeerSocket >::bind

(

SocketAddress &

bindAddress

)

Definition at line 105 of file PhysicalSocket.hpp.

                                                                           {
        if (!bindAddress.getSunPath().empty() && !bindAddress.getSunPath().starts_with('\0')) {
            if ((lockFd = open(bindAddress.getSunPath().append(".lock").data(), O_RDONLY | O_CREAT, 0600)) >= 0) {
                LOG(DEBUG) << "Opening lock file: " << bindAddress.getSunPath().append(".lock").data();
                if (core::system::flock(lockFd, LOCK_EX | LOCK_NB) == 0) {
                    LOG(DEBUG) << "Locking lock file: " << bindAddress.getSunPath().append(".lock").data();
                    if (std::filesystem::exists(bindAddress.getSunPath().data())) {
                        if (std::remove(bindAddress.getSunPath().data()) == 0) {
                            LOG(WARNING) << "Removed stalled sun_path: " << bindAddress.getSunPath().data();
                        } else {
                            PLOG(ERROR) << "Removed stalled sun path: " << bindAddress.getSunPath().data();
                        }
                    }
                } else {
                    PLOG(ERROR) << "Locking lock file " << bindAddress.getSunPath().append(".lock").data();
 
                    core::system::close(lockFd);
                    lockFd = -1;
                }
            } else {
                PLOG(ERROR) << "Opening lock file: " << bindAddress.getSunPath().append(".lock").data();
            }
        }
 
        return Super::bind(bindAddress);
    }

References core::system::close(), core::system::flock(), net::un::SocketAddress::getSunPath(), and net::un::phy::PhysicalSocket< PhysicalPeerSocketT >::lockFd.

Here is the call graph for this function:

operator=()

template<template< typename SocketAddress > typename PhysicalPeerSocket>

PhysicalSocket< PhysicalPeerSocket > & net::un::phy::PhysicalSocket< PhysicalPeerSocket >::operator= ( PhysicalSocket< PhysicalPeerSocketT > &&  physicalSocket )

noexcept

Definition at line 71 of file PhysicalSocket.hpp.

                                                                                                                              {
        Super::operator=(std::move(physicalSocket));
        lockFd = std::exchange(physicalSocket.lockFd, -1);
 
        return *this;
    }

References net::un::phy::PhysicalSocket< PhysicalPeerSocketT >::lockFd.

Member Data Documentation

lockFd

template<template< typename SocketAddressT > typename PhysicalPeerSocketT>

int net::un::phy::PhysicalSocket< PhysicalPeerSocketT >::lockFd = -1

private

Definition at line 70 of file PhysicalSocket.h.

Referenced by net::un::phy::PhysicalSocket< PhysicalPeerSocketT >::bind(), net::un::phy::PhysicalSocket< PhysicalPeerSocketT >::operator=(), and net::un::phy::PhysicalSocket< PhysicalPeerSocketT >::~PhysicalSocket().

---

The documentation for this class was generated from the following files:

• net/un/phy/PhysicalSocket.h
• net/un/phy/PhysicalSocket.hpp