Переделать recv() TCP

 rc=recv( CLIENTS[num].client_socket,rec_buf, buf_lenght, 0);

int readn( SOCKET fd, char *rec_buf, size_t len)
{
    int cnt;
    int rc;
    cnt = len;
    while ( cnt > 0 )
    {
        rc = recv( fd, bp, cnt 0 );
 
        if ( rc < 0 )               
        {
                        if ( errno == EINTR )
            continue;           
            return -1;              
        }
        if ( rc == 0 )              
            return len - cnt;       
        rec_buf += rc;
        cnt -= rc;
    }
    return len;
}

 rc=recv( CLIENTS[num].client_socket,rec_buf, buf_lenght, 0);

#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <stdbool.h>
//#include <winsock2.h>
#include "etcp.h"
 
#define bool _Bool
#define EXIT_SUCCES 1
#define buf_lenght 512
#define max_clients 50
#define name_lenght 40
#define total_lenght (buf_lenght+name_lenght+sizeof("<>:\r\n"))
//typedef int SOCKET;
const int on=1;
int work=1;
int N=max_clients;
 
pthread_mutex_t mp;
pthread_mutexattr_t matr;
int ret;
short port;
 
struct client_info{
    char name[name_lenght];
    SOCKET client_socket;
    pthread_t client_thread;
    int number;
    int name_l;
    int enable;
}CLIENTS[max_clients];
void* accept_handler(void*);
void* client_handler_recv (void* );
bool nameYourself (char *, int );
void whisper(char *, int );
void list (int);
 
int main(int argc, char** argv) {
    SOCKET server_socket;
    char hname[15];
    char sname[10];
    int err;
    pthread_t tid_s;
    int thr;
    int k;
    struct sockaddr_in serv_addr;
    malloc(buf_lenght );
    ret = pthread_mutexattr_init(&matr);
    ret = pthread_mutexattr_setpshared(&matr, PTHREAD_PROCESS_PRIVATE);
    pthread_mutex_init(&mp,&matr);
    int x;
    for (x=0;x<=max_clients;x++)
    {
        CLIENTS[x].enable=0;
        strcpy(CLIENTS[x].name,"nobody");
        CLIENTS[x].name_l=6;
    }
    printf("Hello, Master!\r\n");
    printf("Please enter the ip address of the server\n");
    fgets( hname,sizeof(hname),stdin);
    printf("Please enter the port of the server\n");
    fgets(sname ,sizeof(sname),stdin);
    int int_port=atoi(sname);
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(int_port);
    serv_addr.sin_addr.s_addr = inet_addr( hname );
    if((server_socket=socket(AF_INET, SOCK_STREAM, 0))==-1){
        printf("Error creating 'socket'\r\n");
        exit(-2);
    }
    if(setsockopt(server_socket,SOL_SOCKET,SO_REUSEADDR, &on, sizeof(on))){
        printf("Error while setting options to the socket");
        exit(-1);
    }
    socklen_t len=sizeof(struct sockaddr);
    if(err=bind(server_socket, (struct sockaddr*) &serv_addr, len)==-1){
        printf("Error binding on socket %d\r\n", server_socket);
        exit(-3);
    }
    k=0;
    thr=pthread_create(&tid_s,NULL,accept_handler,(void *) server_socket);
 
    char command[buf_lenght];
    char text[total_lenght];
    char com[buf_lenght];
    char *lex;
    int number;
    int i;
    while(strncmp(command,"/quit",strlen("/quit"))!=0)
    {
        fgets(command,buf_lenght,stdin);
        if(!strncasecmp(command,"/kill",strlen("/kill"))||
                !strncasecmp(command,"/k",strlen("/k")))
        {
            i=0;
            printf("Number..?\n");
            scanf("%s",com);
            if((number=atoi(com))==0)
            {
                printf("wrong type. (e.g. 123)\n");
            }else
            {
                pthread_mutex_lock(&mp);
                while(i<N && CLIENTS[i].client_socket!=number)
                    i++;
                if(i==N)
                {
                    printf("Sorry, no user with such id.\r\n");
                }else
                {
                    send(CLIENTS[i].client_socket,"Goodbie!;)\r\n",
                                             strlen("Goodbie!;)\r\n")+1,NULL);
                    bzero(text,total_lenght);
                    strcpy(text,CLIENTS[i].name);
                    strncat(text," leaves chat.\r\n",strlen(" leaves chat.\r\n"));
                    int m;
                    for(m=0;m<N;m++)
                    {
                        if(m!=i && CLIENTS[m].enable==1)
                            send(CLIENTS[m].client_socket,text,total_lenght,NULL);
                    }
                    CLIENTS[i].enable=0;
                    close(CLIENTS[i].client_socket);
                    pthread_cancel(CLIENTS[i].client_thread);
                }
                pthread_mutex_unlock(&mp);
            }
        }
        else if(!strncasecmp(command,"/help",strlen("/help"))||
                !strncasecmp(command,"/h",strlen("/h")))
        {
       printf( " _____HELP______________________________________________ \n"
               "|/h(elp) - help                                         |\n"
               "|/list - list of all users                              |\n"
               "|/k(ill) <int> - killing user with id <int>             |\n"
               "|/w <name> - send message directly <name>               |\n"
               "|/q(uit) - exit from program                            |\n"
               "|_______________________________________________________|\n"
               );
        }
        else if(!strncasecmp(command,"/list",strlen("/list")))//||!strcmp(command,"/h"))
        {
            list(69);
        }else if (!strncasecmp(command,"/w",2))
        {
            lex=strtok(command," ");
            lex=strtok('\0'," ");
            if (lex)
            {
                whisper(lex,max_clients+1);
            }
 
            else
            {
                printf("<server>:try specificate the person next time.\r\n");
                fflush(stdout);
            }
        }else if((strncmp(command,"/quit",strlen("/quit"))!=0)&&
                (strncasecmp(command,"/kill",strlen("/kill"))!=0)&&
                (strncasecmp(command,"/k",strlen("/k"))!=0))
        {
            bzero(text,sizeof(text));
            strcpy(text,"<server>:");
            strcat(text,command);
            //printf("%s",text);
            pthread_mutex_lock(&mp);
            int i;
            for(i=0;i<N;i++)
            {
                if (CLIENTS[i].enable==1)
                    send(CLIENTS[i].client_socket,text,
                        total_lenght, NULL);
            }
            pthread_mutex_unlock(&mp);
        }
    }
    printf("Goodbie, master!\r\n");
    pthread_cancel(tid_s);
    bzero(text,sizeof(text));
    strcpy(text,"Goodbie\r\n");
    int m;
    for(m=0;m<N;m++)
    {
        if(CLIENTS[m].enable==1)
        {
            pthread_mutex_lock(&mp);
            send(CLIENTS[m].client_socket,text,
                    total_lenght,NULL);
            close(CLIENTS[m].client_socket);
            pthread_mutex_unlock(&mp);
            sleep(0);
            pthread_cancel(CLIENTS[m].client_thread);
        }
    }
    work=0;
    return (EXIT_SUCCESS);
}
 
void* accept_handler(void *server_socket)
{
    socklen_t len=sizeof(struct sockaddr);
    struct sockaddr_in client_addr;
    SOCKET server=(int) server_socket;
    int err,thr,k=0;
    while(work==1){
        if((err=listen(server,max_clients))==-1){
            printf("Error listening on socket %d\r\n", server);
            exit(-4);
        }
        k++;
        if (k==max_clients)
            k=0;
        pthread_mutex_lock(&mp);
        while(CLIENTS[k].enable==1){
            k++;
            if (k==max_clients)
                k=0;
        }
        printf("k=%d\r\n",k);
        pthread_mutex_unlock(&mp);
 
        CLIENTS[k].client_socket=accept(server,
                                        (struct sockaddr*) &client_addr,&len);
        thr=pthread_create(&CLIENTS[k].client_thread,
                            NULL,client_handler_recv,(void *)k);
        printf("MESSAGE: New client connected!\n"
                "ip=%s port=%d\r\n",inet_ntoa(client_addr.sin_addr)
                ,client_addr.sin_port);
        printf("socket:%d\r\n",CLIENTS[k].client_socket);
        fflush(stdout);
    }
}
 
void* client_handler_recv (void *number)
{
    int num=(int) number;
    pthread_mutex_lock(&mp);
    strcpy(CLIENTS[num].name,"anonymous");
    CLIENTS[num].name_l=strlen("anonymous");
    CLIENTS[num].enable=1;
    CLIENTS[num].number=num;
    pthread_mutex_unlock(&mp);
    char rec_buf[buf_lenght];
    char name_buf[name_lenght];
    char *lex;
    char text[total_lenght];
    bool good_name=false;
    int rc;
    bzero(rec_buf,buf_lenght);
    strcpy(rec_buf,"Hello! Please, name yourself.\r\n"
            "Remember, that your name must contain less then 40 characters.\r\n");
    pthread_mutex_lock(&mp);
    send(CLIENTS[num].client_socket,rec_buf,buf_lenght,NULL);
    pthread_mutex_unlock(&mp);
    while(good_name==false)
    {
        bzero(name_buf,name_lenght);
        good_name=nameYourself(name_buf,num);
    }
 
    while(strncasecmp(rec_buf,"/quit",strlen("/quit"))!=0)
    {
        bzero(text,total_lenght);
        bzero(rec_buf,buf_lenght);
 
        rc=recv( CLIENTS[num].client_socket,rec_buf, buf_lenght, 0);
/*
        rc=readn( CLIENTS[num].client_socket,rec_buf,
                buf_lenght);
*/
        if(strncmp(rec_buf,"/quit\n",strlen("/quit\n"))!=0)
        {
        if (rc<=0)
        {
            pthread_mutex_lock(&mp);
            CLIENTS[num].enable=0;
            close(CLIENTS[num].client_socket);
            pthread_mutex_unlock(&mp);
            break;
        }
        if(!strncasecmp(rec_buf,"/help",strlen("/help"))||
                !strncasecmp(rec_buf,"/h",2))
        {
       strcpy(text," _____HELP______________________________________________ \n"
                   "|/h(elp) - pleh                                         |\n"
                   "|/list - list of all users                              |\n"
                   "|/w <name> - send message directly <name>               |\n"
                   "|/q(uit) - exit from program                            |\n"
                   "|_______________________________________________________|\n"
               );
        pthread_mutex_lock(&mp);
        send(CLIENTS[num].client_socket,text,total_lenght,NULL);
        pthread_mutex_unlock(&mp);
        }else if(!strncasecmp(rec_buf,"/list",strlen("/list")))
        {
            list(num);
        }else if (!strncasecmp(rec_buf,"/w",2))
        {
            lex=strtok(rec_buf," ");
            lex=strtok('\0'," ");
            if (lex)
            {
                whisper(lex,num);
            }else
            {
                strcpy(text,"<server>:try specificate the person next time.\r\n");
                pthread_mutex_lock(&mp);
                send(CLIENTS[num].client_socket,text,total_lenght,NULL);
                pthread_mutex_unlock(&mp);
            }
        }else //if(strncasecmp(rec_buf,"/wuit",strlen("/quit"))!=0)
        {
            strcpy(text,"<");
            pthread_mutex_lock(&mp);
            strncat(text,CLIENTS[num].name,CLIENTS[num].name_l);
            pthread_mutex_unlock(&mp);
            strcat(text,">:");
            strcat(text,rec_buf);
            printf("%s",text);
            fflush(stdout);
            pthread_mutex_lock(&mp);
            int i;
            for(i=0;i<N;i++)
            {
                if((CLIENTS[i].enable==1) & (i!= num))
                    send(CLIENTS[i].client_socket,text,
                    total_lenght, NULL);
            }
            pthread_mutex_unlock(&mp);
        }
        }
    }
    bzero(text,total_lenght);
    strcpy(text,"Goodbie\r\n");
    send(CLIENTS[num].client_socket,text,total_lenght,NULL);
    pthread_mutex_lock(&mp);
    printf("%s leaves chat\r\n",CLIENTS[num].name);
    fflush(stdout);
    bzero(text,total_lenght);
    strcpy(text,CLIENTS[num].name);
    strncat(text," leaves chat.\r\n",strlen(" leaves chat.\r\n"));
    int m;
    for(m=0;m<N;m++)
    {
        if(m!=num && CLIENTS[m].enable==1)
            send(CLIENTS[m].client_socket,text,total_lenght,NULL);
    }
    CLIENTS[num].enable=0;
    close(CLIENTS[num].client_socket);
    pthread_mutex_unlock(&mp);
}
 
 
bool nameYourself (char *name, int num)
{
    char text[total_lenght];
    int i;
    int rc;
    //rc=readn(CLIENTS[num].client_socket,name,name_lenght,NULL);
    rc=recv(CLIENTS[num].client_socket,name,name_lenght, NULL );
            if(rc<=0)
    {
        pthread_mutex_lock(&mp);
        CLIENTS[num].enable=0;
        close(CLIENTS[num].client_socket);
        pthread_mutex_unlock(&mp);
        pthread_cancel(CLIENTS[num].client_thread);
        return false;
    }
    bzero(text,total_lenght);
    strcpy(text,"<server>:Sorry, but this name is occupied at this moment."
            " Try again.\r\n");
    if(!strncmp(name,"server",6))
    {
        send(CLIENTS[num].client_socket,text,total_lenght,NULL);
        pthread_mutex_unlock(&mp);
        return false;
    }
    pthread_mutex_lock(&mp);
    for(i=0;i<N;i++)
    {
        if((strncmp(name,CLIENTS[i].name,strlen(name)-2)==0)&&(CLIENTS[i].enable==1))
        {
            send(CLIENTS[num].client_socket,text,total_lenght,NULL);
            pthread_mutex_unlock(&mp);
            return false;
        }
    }
    i=0;
    while(name[i]!=0&&name[i]!=4&&name[i]!=10&&name[i]!=20)
        i++;
    if(i>name_lenght)
        i=name_lenght;
    CLIENTS[num].name_l=i-1;
    bzero(text,total_lenght);
    bzero(CLIENTS[num].name,name_lenght);
    strcpy(text,"<server>:Hello, ");
    strncpy(CLIENTS[num].name,name,CLIENTS[num].name_l);
    strncat(text,CLIENTS[num].name,CLIENTS[num].name_l);
    strcat(text,".\n");
    send(CLIENTS[num].client_socket,text,total_lenght,NULL);
    bzero(text,total_lenght);
    strcpy(text,"<");
    strncat(text,name,CLIENTS[num].name_l);
    strcat(text,"> enters chat.\r\n");
    printf("%s",text);
    for (i=0;i<N;i++)
    {
        if ((CLIENTS[i].enable==1)&&i!=num)
            send(CLIENTS[i].client_socket,text,total_lenght,NULL);
    }
    pthread_mutex_unlock(&mp);
    return true;
}
 
void whisper(char *lex, int num)
{
}
 
/*
int readn( SOCKET fd, char *bp, size_t len)
{
    int cnt;
    int rc;
    cnt = len;
    while ( cnt > 0 )
    {
        rc = recv( fd, *bp, cnt, 0 );
 
        if ( rc < 0 )               
        {
            continue;           
            return -1;              
        }
        if ( rc == 0 )              
            return len - cnt;       
        rec_buf += rc;
        cnt -= rc;
    }
    return len;
}
*/
 
void list (int num)
{
}