FBB::LocalClientSocket - Client Socket connecting to a Server in the Unix Domain

       Frank B. Brokken (f.b.brokken@rug.nl).

libbobcat-dev_6.07.01                               2005-2025                    FBB::LocalClientSocket(3bobcat)

       Bobcat is an acronym of `Brokken’s Own Base Classes And Templates’.

       o      https://fbb-git.gitlab.io/bobcat/: gitlab project page;

       Debian Bobcat project files:

       o      libbobcat6: debian package containing the shared library, changelog and copyright note;

       o      libbobcat-dev:  debian package containing the static library, headers, manual pages, and developer
              info;

       None Reported.

       o      LocalClientSocket():
              This constructor merely creates a FBB::LocalClientSocket object. Before it can be used, its open()
              member must be called.

       o      LocalClientSocket(std::stringconst&name):
              This  constructor initializes an FBB::LocalClientSocket object, using the named Unix Domain socket
              to connect to the server using the named Unix Domain socket. An FBB::Exception is  thrown  if  the
              socket  could  not  be constructed. The construction of the socket does not mean that a connection
              has actually been established. In order to connect to the server, the member connect() (see below)
              should be used.

       Copy and move constructors (and assignment operators) are not available.

       This is free software, distributed under the terms of the GNU General Public License (GPL).

       An  FBB::LocalClientSocket  may  be  constructed  to  connect to a server process in the Unix Domain. The
       socket made available by the FBB:LocalClientSocket may  be  used  to  initialize  a  std::istream  and/or
       std::ostream.  The  std::istream  is  used  to  read  information  from  the  server process to which the
       FBB::LocalClientSocket connects, The std::ostream is used to send information to the  server  process  to
       which  the  FBB::LocalClientSocket  connects.   Since  a  socket  may be considered a filedescriptor the
       available FBB::IFdStream, FBB::IFdStreamBuf, FBB::OFdStream, and FBB::OFdStreamBuf classes  may  be  used
       profitably  here.  Note  that having available a socket does not mean that this defines the communication
       protocol. It is (still) the responsibility of the programmer to comply with an existing  protocol  or  to
       implement  a  tailor-made  protocol.  The latter situation implies that the sequence of input- and output
       operations is defined by the programmer.

       See also the localserversocket(3bobcat) example.

           #include <iostream>
           #include <bobcat/localclientsocket>
           #include <bobcat/ifdstream>
           #include <bobcat/ofdstream>

           using namespace std;
           using namespace FBB;

           int main(int argc, char **argv)
           try
           {
               if (argc == 1)
               {
                   cerr << "Provide filename representing the unix domain socket\n";
                   return 1;
               }

               LocalClientSocket client(argv[1]);
               int fd = client.connect();
               string line;

               cout << "Connecting to socket " << fd << endl;

               IFdStream in(fd);                 // stream to read from
               OFdStream out(fd);                // stream to write to

               while (true)
               {
                                           // Ask for a textline, stop if empty / none
                   cout << "? ";
                   if (!getline(cin, line) || line.length() == 0)
                       return 0;
                   cout << "Line read: " << line << endl;
                                           // Return the line to the server
                   out << line.c_str() << endl;
                   cout << "wrote line\n";

                                           // Wait for a reply from the server
                   getline(in, line);
                   cout << "Answer: " << line << endl;
               }
           }
           catch (Exception const &err)
           {
               cerr << err.what() << "\n" <<
                       "Can’t connect to " << argv[1] << ", port " << argv[2] << endl;
               return 1;
           }

bobcat/localclientsocket - defines the class interface

FBB::LocalSocketBase

       o      intconnect():
              This member returns a socket that  can  be  used  to  communicate  with  the  server  process.  An
              FBB::Exception exception is thrown if the connection could not be established.

       o      open(std::stringconst&name):
              This  member  function  prepares  the FBB::LocalClientSocket object, constructed earlier using the
              default constructor, for use.  The named Unix Domain socket is used to connect to the server using
              the named Unix Domain socket. An FBB::Exception is thrown if the socket could not be  constructed.
              The  construction  of the socket does not mean that a connection has actually been established. In
              order to connect to the server, the member connect() should be used.

       FBB::LocalClientSocket - Client Socket connecting to a Server in the Unix Domain

FBB
       All constructors, members, operators and manipulators, mentioned in this man-page,  are  defined  in  the
       namespace FBB.

bobcat(7),  ifdstream(3bobcat),   ifdbuf(3bobcat),   clientsocket(3bobcat),   localserversocket(3bobcat),
       localsocketbase(3bobcat), ofdstream(3bobcat), ofdstream(3bobcat)

#include<bobcat/localclientsocket>
       Linking option: -lbobcat