Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::filesystem::is_socket(3) C++ Standard Libarystd::filesystem::is_socket(3)

NAME
       std::filesystem::is_socket - std::filesystem::is_socket

Synopsis
	  Defined in header <filesystem>
	  bool	 is_socket(   std::filesystem::file_status   s	 )   noexcept;
       (1) (since C++17)
	  bool	  is_socket(	 const	   std::filesystem::path&     p	    );
       (2) (since C++17)
	  bool	is_socket(  const  std::filesystem::path&  p, std::error_code&
       (3) (since C++17)
	  ec ) noexcept;

	  Checks if the	given file status or path corresponds to a  named  IPC
       socket, as if
	  determined by	the POSIX S_IFSOCK.

	  1) Equivalent	to s.type() == file_type::socket.
	  2,3) Equivalent to is_socket(status(p)) or is_socket(status(p, ec)).

Parameters
	  s  - file status to check
	  p  - path to examine
	  ec - out-parameter for error reporting in the	non-throwing overload

Return value
	  true if the file indicated by	p or if	the type indicated s refers to
       a named socket.
	  The non-throwing overload returns false if an	error occurs.

Exceptions
	  Any  overload	not marked noexcept may	throw std::bad_alloc if	memory
       allocation
	  fails.

	  2,3) Sets a std::error_code& parameter to the	OS API error  code  if
       an OS API call
	  fails, and executes ec.clear() if no errors occur.

Notes
	  Named	 sockets  are  UNIX domain sockets constructed with socket and
       bind POSIX APIs,
	  which	may be used for	advanced interprocess communication.  In  par-
       ticular,	they may
	  be  used to transport	open file descriptors from one running process
       to another.

Example
       // Run this code

	#include <cstdio>
	#include <cstring>
	#include <filesystem>
	#include <fstream>
	#include <iostream>
	#include <sys/socket.h>
	#include <sys/stat.h>
	#include <sys/un.h>
	#include <unistd.h>

	namespace fs = std::filesystem;

	void demo_status(const fs::path& p, fs::file_status s)
	{
	    std::cout << p;
	    // alternative: switch(s.type())  {	 case  fs::file_type::regular:
       ...}
	    if (fs::is_regular_file(s))
		std::cout << " is a regular file\n";
	    if (fs::is_directory(s))
		std::cout << " is a directory\n";
	    if (fs::is_block_file(s))
		std::cout << " is a block device\n";
	    if (fs::is_character_file(s))
		std::cout << " is a character device\n";
	    if (fs::is_fifo(s))
		std::cout << " is a named IPC pipe\n";
	    if (fs::is_socket(s))
		std::cout << " is a named IPC socket\n";
	    if (fs::is_symlink(s))
		std::cout << " is a symlink\n";
	    if (!fs::exists(s))
		std::cout << " does not	exist\n";
	}

	int main()
	{
	    // create files of different kinds
	    fs::create_directory("sandbox");
	    fs::create_directory("sandbox/dir");
	    std::ofstream{"sandbox/file"}; // create regular file
	    fs::create_symlink("file", "sandbox/symlink");

	    mkfifo("sandbox/pipe", 0644);
	    sockaddr_un	addr;
	    addr.sun_family = AF_UNIX;
	    std::strcpy(addr.sun_path, "sandbox/sock");
	    int	fd = socket(PF_UNIX, SOCK_STREAM, 0);
	    bind(fd, reinterpret_cast<sockaddr*>(&addr), sizeof	addr);

	    // demo different status accessors
	    for	 (auto it{fs::directory_iterator("sandbox")}; it != fs::direc-
       tory_iterator();	++it)
		demo_status(*it, it->symlink_status());	// use	cached	status
       from directory entry
	    demo_status("/dev/null", fs::status("/dev/null")); // direct calls
       to status
	    demo_status("/dev/sda", fs::status("/dev/sda"));
	    demo_status("sandbox/no", fs::status("/sandbox/no"));

	    // cleanup (prefer std::unique_ptr-based custom deleters)
	    close(fd);
	    fs::remove_all("sandbox");
	}

Possible output:
	"sandbox/file" is a regular file
	"sandbox/dir" is a directory
	"sandbox/pipe" is a named IPC pipe
	"sandbox/sock" is a named IPC socket
	"sandbox/symlink" is a symlink
	"/dev/null" is a character device
	"/dev/sda" is a	block device
	"sandbox/no" does not exist

See also
	  status	    determines file attributes
	  symlink_status     determines	 file attributes, checking the symlink
       target
	  (C++17)	    (function)
	  (C++17)
	  file_status	    represents file type and permissions
	  (C++17)	    (class)
	  status_known	    checks whether file	status is known
	  (C++17)	    (function)
	  is_block_file	    checks whether the given path refers to block  de-
       vice
	  (C++17)	    (function)
	  is_character_file  checks whether the	given path refers to a charac-
       ter device
	  (C++17)	    (function)
	  is_directory	    checks whether the given path refers to  a	direc-
       tory
	  (C++17)	    (function)
	  is_fifo	     checks  whether  the given	path refers to a named
       pipe
	  (C++17)	    (function)
	  is_other	    checks whether the argument	 refers	 to  an	 other
       file
	  (C++17)	    (function)
	  is_regular_file    checks  whether  the argument refers to a regular
       file
	  (C++17)	    (function)
	  is_symlink	    checks whether the argument	refers to  a  symbolic
       link
	  (C++17)	    (function)
	  exists	    checks whether path	refers to existing file	system
       object
	  (C++17)	    (function)
			    checks  whether  the  directory  entry refers to a
       named IPC socket
	  is_socket	    (public member function of std::filesystem::direc-
       tory_entry)

http://cppreference.com		  2024.06.10	 std::filesystem::is_socket(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::filesystem::is_socket&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help