Spelling fixes by Michael Opdenacker <zumbi2@netcourrier.com>

1 files changed, 1 insertions, 1 deletions

diff --git a/x11/ipc/server/ocopserver.cpp b/x11/ipc/server/ocopserver.cpp
index 992cb8c..3ee38e9 100644
--- a/x11/ipc/server/ocopserver.cpp
+++ b/x11/ipc/server/ocopserver.cpp
@@ -22,193 +22,193 @@ OCopServer::OCopServer()
     init();
     initSocket();
 }
 OCopServer::~OCopServer() {
 // socket notifiers should be deleted
     close(m_serverfd );
 }
 void OCopServer::init() {
     /*
      * we set SIGPIPE to SIG_IGN
      * to get EPIPE on reads ;)
      */
 //    qWarning("SIGPIPE to be ignored");
     signal(SIGPIPE,  SIG_IGN );
 
     /*
      * initialize some variables
      */
     m_server = 0l;
     m_serverError = 0l;
 }
 
 /**
  * here we will init our server
  * socket and bind and do the listen
  */
 void OCopServer::initSocket() {
     /* get the home dir */
     QCString home( getenv("HOME") );
     QCString path( home + "/.opie.cop");
 
     if ( ( m_serverfd = socket( PF_UNIX, SOCK_STREAM, 0 ) ) == -1 ) {
         qWarning("failed to create server socket");
         /* try again later */
         QTimer::singleShot( 400, this, SLOT(initSocket() ) );
         return;
     }
     qWarning( "unlinking file %s", path.data() );
 
     /* unlink previous sockets */
     unlink( path.data() );
 
     struct sockaddr_un m_address;
     memset(&m_address, 0, sizeof(m_address ) );
     m_address.sun_family = AF_UNIX; /* unix domain socket */
     strcpy(m_address.sun_path, path.data() );
     m_adrlaenge = sizeof(m_address.sun_family) + strlen(m_address.sun_path );
 
     /* cast to make it a (sockadr*) */
     if (bind(m_serverfd,  (struct sockaddr*)&m_address, m_adrlaenge ) == -1 ) {
         qWarning("Server could not bind try again");
         close(m_serverfd);
         QTimer::singleShot(400, this, SLOT(initSocket() ) );
         return;
     }
 
     /* tell the kernel that we're listening and accepting
      * 5 pending connections */
     if (listen(m_serverfd, 5) == -1 ) {
         qWarning("could not listen");
         close(m_serverfd );
         QTimer::singleShot(400, this, SLOT(initSocket() ) );
         return;
     }
 
     /*
      * now we will create two QSocketNotifier
      * which will us notify on reads
      * and errors
      * we do this because they integrate
      * nicely into the QApplication eventloop
      */
     m_server = new QSocketNotifier(m_serverfd, QSocketNotifier::Read, this );
     connect( m_server, SIGNAL(activated(int) ),
              this, SLOT(newOnServer() ) );
 
     m_serverError = new QSocketNotifier( m_serverfd, QSocketNotifier::Exception, this);
     connect(m_serverError, SIGNAL(activated(int) ),
             this, SLOT(errorOnServer() ) );
 
     qWarning("done with registering");
 }
 /**
  * we got the possibility to read
  * on the server
  * this is mostly due a connect
  * on a client side
  * we will accept it
  * add it to our list
  */
 void OCopServer::newOnServer() {
     int fd = accept();
     if ( fd < 0 )
         return;
 
     /*
-     * we got a successfull new connection
+     * we got a successful new connection
      * be happy
      * set SocketNotifier
      * connect it
      * and a OCOPClient
      */
 //    qWarning("Heureka new connection %d", fd );
 
 
     registerClient( fd );
 }
 int OCopServer::accept() {
     /*
      * accept it
      * the socket is currently blocking IIRC
      */
     return ::accept( m_serverfd,  (struct sockaddr*)&m_address, &m_adrlaenge );
 }
 void OCopServer::newOnClient( int fd ) {
     errno = 0;
     OCOPHead head;
     memset(&head, 0, sizeof(head) );
     int rea = ::read(fd, &head, sizeof(head) );
     //qWarning("read %d %d", rea,  errno);
     /*
      * I should get EPIPE but nothing like this happens
      * so if rea == 0 and we were signaled by the notifier
      * we close it and drop the clients...
      */
     if ( rea <= 0 ) {
         deregisterClient( fd );
         return;
     }
     /*
      * OCOPHead
      */
     //qWarning("data %s %d", &bug, rea );
 
     /*
      * Check the magic
      * if chcked read till EOF if magic does not match
      * otherwise do read
      *  channel
      * func
      * data into mem
      * and then send the OCOPPacket
      *
      */
     if (head.magic == 47 ) {
 //        qWarning("magic match");
         QCString channel( head.chlen+1 );
         QCString func( head.funclen+1 );
         QByteArray data ( head.datalen+1 );
 
         /*
          * we do not check for errors
          */
 //        qWarning("read ");
         int s = read(fd, channel.data(), head.chlen );
         s = read(fd, func.data(), head.funclen );
         s = read(fd, data.data(), head.datalen );
 //        qWarning("read");
 
         /* debug output */
 //        qWarning("channel %s %d", channel.data(), head.chlen );
 //        qWarning("func %s %d", func.data(), head.funclen );
         /* debug end */
 
         /*
          * now that we got the complete body
          * we need to make a package
          * and then we need to send it to clients
          * making a package is done here
          * dispatching it not
          */
         OCOPPacket packet( head.type, channel, func, data );
         dispatch( packet, fd );
 
     }else{
 //        qWarning("magic does not match");
 //        qWarning("magic %d", head.magic );
     }
 }
 void OCopServer::registerClient( int fd ) {
     if (m_clients.contains(fd) )
         return;
 
     QSocketNotifier* notify = new QSocketNotifier(fd, QSocketNotifier::Read, this );
     connect(notify, SIGNAL(activated(int) ),
             this, SLOT(newOnClient(int) ) );
     OCOPClient client;
     client.fd = fd;
     client.notify = notify;
     m_clients.insert( client.fd, client );
 //    qWarning("clients are up to %d", m_clients.count() );
 };
 void OCopServer::deregisterClient(int fd ) {