Покритикуйте сервер

#include <iostream>
#include "mServer.h"
using namespace std;
 
class newServer:public mServer
{
public:
    newServer():mServer()
    {
 
    }
    virtual int mGrabberListen(int sock_id)
    {
        cout << "connect:" << sock_id << endl;
        return(0);
    }
    virtual int mGrabberRecv(char* message_in, int sock_id, int length)
    {
        cout << sock_id<< ":["<< length << "]:"<< message_in << endl;
        (*this).mSend(sock_id, message_in);
        return(0);
    }
    virtual int mGrabberClose(int sock_id)
    {
        cout << sock_id<< ":closed" << endl;
        return(0);
    }
};
int main()
{
 
    int result;
    sem_t sem1;
           sem_init(&sem1, 0, 0);
 
    newServer::size_in = 1024;
    newServer::max_connection = 64;
 
    newServer server;
 
    result = server.mBind(8080, 0);
    if (result<0) return(0);
    result = server.mListenStart();
    if (result<0) return(0);
    cout << "i'm listening" << endl;
    sem_wait(&sem1);
    return 0;
}

#ifndef MSERVER_H_
#define MSERVER_H_
 
#include <string.h>
#include <stack>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <semaphore.h>
#include <sys/time.h>
#include <sys/types.h>
 
class mServer
{
private:
    int             listener;       // socket-listener
    int*                sock;           // client's socket
    pthread_t           threadListener;     // listener's socket
    pthread_t*          threadSock;     // client's thread
    std::stack<short>       freeSock;       // stack free sockets
    sockaddr_in         addr;           // my address
    char**              message_in;     // array incoming messages
    sem_t               sem;            // for stack synchronize
 
    int mRecv(int sock_id);                 // receive message
    int mClose(int sock_id);                // close connection
protected:
    bool isListen;                      // service working ?
    int mSend(int sock_id,char* message);           // send message
public:
    static int size_in;                 // max size incoming message's
    static int max_connection;              // max number of connections
 
    mServer();
    virtual ~mServer();
 
    int mBind(unsigned int port, char* address);
    int mListenStart();                         // start service
 
    friend void* bRecv(void* argv);                     // client's thread-receive-function
    friend void* bListen(void* argv);                   // thread-listen function
 
    virtual int mGrabberRecv(char* message_in, int sock_id, int length)     // event-function receive message
    {return(0);}
    virtual int mGrabberListen(int sock_id)                 // event-function open connection
    {return(0);}
    virtual int mGrabberClose(int sock_id)                  // event-function close connection
    {return(0);}
};
#endif

#include "mServer.h"
 
int mServer::size_in = 256;
int mServer::max_connection = 64;
 
void* bRecv(void* argv)
{
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
    mServer* cm = (mServer*) argv;
    int i = (*cm).freeSock.top();
    (*cm).freeSock.pop();
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    sem_post(&((*cm).sem));
 
    int flag = 1;
    while(flag>0)  // <0 - error, 0 - close
    {
        flag = (*cm).mRecv(i);
        if (flag>0) (*cm).mGrabberRecv((*cm).message_in[i], i, flag);
    }
    return(0);
}
void* bListen(void* argv)
{
    mServer* cm = (mServer*) argv;
    int i;
    int buf;
    while ((*cm).isListen)
    {
        buf = accept((*cm).listener, NULL, NULL);
        if (buf < 0)
        {
            (*cm).mGrabberListen(-1);
        }
        else
        {
            sem_wait(&((*cm).sem));
            pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
            i = (*cm).freeSock.top();
            (*cm).sock[i] = buf;
            if (pthread_create(&((*cm).threadSock[i]), NULL, bRecv, argv)!=0)
                return(0);
            (*cm).mGrabberListen(i);
            pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
        }
    }
    return(0);
}
mServer::mServer()
{
    isListen = false;
    sock = new int[max_connection];
    message_in = new char*[max_connection];
    threadSock = new pthread_t[max_connection];
 
    for(short i=max_connection-1;i>=0;--i)
    {
        sock[i] = 0;
        threadSock[i] = 0;
        freeSock.push(i);
        message_in[i] = new char[size_in];
    }
 
}
mServer::~mServer()
{
    delete[] sock;
    for(int i=0;i<max_connection;++i)
        delete[] message_in[i];
    delete[] message_in;
    delete[] threadSock;
    sem_destroy(&sem);
    close(listener);
}
int mServer::mBind(unsigned int port, char* address)
{
    listener = socket(AF_INET, SOCK_STREAM, 0);
    if (listener<0) return(-1);
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);//htonl(0xC0A80365);
    if (bind(listener, (struct sockaddr *)&addr, sizeof(addr)) < 0) return(-1);
    if (listen(listener, max_connection)<0) return(-1);
    return(0);
}
int mServer::mSend(int sock_id, char* message)
{
    int i = strlen(message);
    message[i]='\0';
    int res = send(sock[sock_id], message,i+1,0);
    return(res);
}
int mServer::mRecv(int sock_id)
{
    int i = recv(sock[sock_id], message_in[sock_id], size_in, 0);
    if (i<=0)
    {
        mClose(sock_id);
    }
    return(i);
}
int mServer::mClose(int sock_id)
{
    close(sock[sock_id]);
    sem_wait(&sem);
    freeSock.push(sock_id);
    mGrabberClose(sock_id);
    if (threadSock[sock_id]!=0) pthread_cancel(threadSock[sock_id]);
    threadSock[sock_id] = 0;
    sock[sock_id] = 0;
    sem_post(&sem);
    return(0);
}
int mServer::mListenStart()
 {
    if (sem_init(&sem, 0, 1)!=0) return(-1);
    if(pthread_create(&threadListener, NULL, bListen, (void*)(this))!=0)
        return(-1);
    isListen = true;
    return(0);
}