Provided by: libbobcat-dev_5.00.02-2_amd64 bug


       FBB::ServerSocket - Server socket accepting Internet connection requests


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


       An  FBB::ServerSocket  may  be  constructed  to  listen  for  connection requests from the
       Internet or from the local host. Connection requests may be accepted in either blocking or
       non-blocking  modes.  When a connection is accepted a socket is returned which may be used
       to read information from or write information to the client that requested the connection.
       The  socket  that is made available is a file descriptor which may be used to initialize a
       std::istream and/or std::ostream. The std::istream is used to read  information  from  the
       client process; the std::ostream is used to send information to the client process.  Since
       a  socket  may  be  considered   a   file   descriptor   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.

       A Unix Domain server socket can be defined using FBB::LocalServerSocket.


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




       o      ServerSocket(size_t  port):
              This constructor initializes an FBB::ServerSocket object,  which  will  listen  for
              connections  at  the  specified port.  The construction of the socket does not mean
              that the FBB::ServerSocket object is actually listening for connections.  To  start
              listening, the member listen() should be used.

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


       All   members  of  FBB::SocketBase  (and  thus  of  FBB::InetAddress)  are  available,  as
       FBB::ServerSocket inherits from FBB::SocketBase.

       o      void listen(size_t backlog = 5, bool blocking = true):
              The listen() member defines the way the FBB::ServerSocket will listen  for  clients
              requesting  a  connection.   It  can be used only once with a FBB::ServerSocket. An
              FBB::Exception object is thrown if listening fails, if the  constructor  could  not
              create a socket, or if the SocketBase base class could not properly be constructed.

              The listen() member’s backlog parameter defines the size of the FBB::ServerSocket’s
              internal queue in which connection requests may be stored waiting for their turn to
              be  serviced.  When  backlog requests are waiting and another request arrives, then
              that request is lost.

              The member’s second parameter, blocking, is used to control the blocking  mode.  By
              default,   blocking  is  used,  and  listen()  will  wait  until  a  connection  is
              established. This is ok in situations where clients  connect  infrquently  and  for
              relatively   short   time  intervals.  Otherwise,  in  more  complex  programs,  an
              FBB::Selector object can be used to sense input on  the  server  socket  and/or  on
              various client sockets.

       o      SocketBase accept():
              The  accept() member returns an FBB::SocketBase object containing information about
              the client whose connection request  was  accepted.  The  FBB::SocketBase  object’s
              socket value may be used to initialize streams that can be used to communicate with
              the client. In more complex programs the FBB::SocketBase could be passed to a class
              derived  from  FBB::Fork,  handling  the communication with the child as a separate
              (child) process.


       See also the clientsocket(3bobcat) example.

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

           #include <bobcat/a2x>

           using namespace std;
           using namespace FBB;

           int main(int argc, char **argv)
               if (argc == 1)
                   cerr << "Provide server port number\n";
                   return 1;

               size_t portnr = A2x(argv[1]);

               ServerSocket server(portnr);

               cerr << "server listens on port " << argv[1] << endl;

               cerr << "serversocket returns:\n" <<
                   "address = " << server.dottedDecimalAddress() << "\n"
                   "port    = " << server.port() << endl;

               int fd = server.socket();       // open the socket’s descriptor

               cout << "File descriptor of the socket is " << fd << "\n"
                   "The server terminates when it receives a "
                                               "single `q’ on a line\n"
                   "A connection is terminated when no input "
                                               "is received anymore.\n"
                   "Then another connection is possible" << endl;

               server.listen();                // listen in blocking mode

               while (true)
                   SocketBase fdb = server.accept();
                   int fd = fdb.socket();

                   cerr << "Client FD = " << fd << ", " << endl <<
                           "address = " << fdb.dottedDecimalAddress() << ", " <<
                           endl <<
                           "communication through port " << fdb.port() << endl;

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

                   while (getline(in, cmd))
                       cout << "Got: " << cmd << endl;
                       out << "Got: " << cmd << "\r" << endl;

                       if (cmd[0] == ’q’)
                           return 0;
                   cout << "Ready for another connection\n";
           catch (Exception const &err)
               cerr <<
                   err.what() << endl <<
                   "Server socket on port " << argv[1] <<
                   " can’t be opened" << endl;
               return -1;


       bobcat/serversocket - defines the class interface


       bobcat(7),  clientsocket(3bobcat),  fork(3bobcat),  ifdstream(3bobcat),   ifdbuf(3bobcat),
       inetaddress(3bobcat),  localserversocket(3bobcat), ofdstream(3bobcat), ofdstream(3bobcat),
       select(2), selector(3bobcat), socketbase(3bobcat)


       None Reported.


       o      bobcat_5.00.02-x.dsc: detached signature;

       o      bobcat_5.00.02-x.tar.gz: source archive;

       o      bobcat_5.00.02-x_i386.changes: change log;

       o      libbobcat1_5.00.02-x_*.deb: debian package holding the libraries;

       o      libbobcat1-dev_5.00.02-x_*.deb: debian package holding the libraries,  headers  and
              manual pages;

       o public archive location;


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


       This  is  free  software,  distributed  under  the terms of the GNU General Public License


       Frank B. Brokken (