Provided by: libbobcat-dev_4.08.06-1build1_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.   The  copy constructor is not


       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),
       ifdstreambuf(3bobcat),          inetaddress(3bobcat),          localserversocket(3bobcat),
       ofdstream(3bobcat), ofdstream(3bobcat), select(2), selector(3bobcat), socketbase(3bobcat)


       None Reported.


       o      bobcat_4.08.06-x.dsc: detached signature;

       o      bobcat_4.08.06-x.tar.gz: source archive;

       o      bobcat_4.08.06-x_i386.changes: change log;

       o      libbobcat1_4.08.06-x_*.deb: debian package holding the libraries;

       o      libbobcat1-dev_4.08.06-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 (