Авторизация в чате

scanf("%s",name);

scanf("%255s",name);

 
strcpy(me.name, name);

strncpy (me.name, name, me_name_length);

struct USER {
        int sockfd; 
        char name[NAMELEN];
	int flag;
};
struct USER me;

printf("================\n");
printf("Enter your login\n");
printf("================\n");
scanf("%s",instruction);
if((strcmp(instruction,user_1)==0)){flag=1;}
else if((strcmp(instruction,user_2)==0)){flag=2;}
else{printf("You are not a member, goodbye\n");break;}	
printf("FLAG=%d\n",flag);
strcpy(heap.name, instruction);
setname(&me);
me.flag=flag;
login(&me);

...

void login(struct USER *me) {
    int recvd;
    if(isconnected) {
        fprintf(stderr, "You are already connected to server at %s:%d\n", SERVERIP, SERVERPORT);
        return;
    }
    sockfd = connect_with_server();
    if(sockfd >= 0) {
        isconnected = 1;
        me->sockfd = sockfd;
        if(strcmp(me->name, "Anonymous")) setname(me);
        printf("Logged in as %s\n", me->name);
        printf("Receiver started [%d]...\n", sockfd);
        struct THREADINFO threadinfo;
        pthread_create(&threadinfo.thread_ID, NULL, receiver, (void *)&threadinfo);
 
    }
    else {
        fprintf(stderr, "Connection rejected...\n");
    }
}


///////SERVER

#define IP "127.0.0.1"
#define PORT 8080
#define BACKLOG 10
#define CLIENTS 10
 
#define BUFFSIZE 1024
#define NAMELEN 32
#define OPTLEN 16

struct HEAP {
    char instruction[OPTLEN]; // instruction
    char name[NAMELEN]; // client's name
    char buff[BUFFSIZE]; // payload
    int n; //flag
};
 
struct THREADINFO {
    pthread_t thread_ID; // thread's pointer
    int sockfd; // socket file descriptor
    char name[NAMELEN]; // client's name
};
 
struct LLNODE {
    struct THREADINFO threadinfo;
    struct LLNODE *next;
};
 
struct LLIST {
    struct LLNODE *head, *tail;
    int size;
};
 
int compare(struct THREADINFO *a, struct THREADINFO *b) {
    return a->sockfd - b->sockfd;
}
 
void list_init(struct LLIST *ll) {
    ll->head = ll->tail = NULL;
    ll->size = 0;
}
 
int list_insert(struct LLIST *ll, struct THREADINFO *thr_info) {
   ...
}
 
int list_delete(struct LLIST *ll, struct THREADINFO *thr_info) {...
}
 
void list_dump(struct LLIST *ll) {
  ...
}
 
int sockfd, newfd;
struct THREADINFO thread_info[CLIENTS];
struct LLIST client_list;
pthread_mutex_t clientlist_mutex;
 
void *io_handler(void *param);
void *client_handler(void *fd);
 
int main(int argc, char **argv) {
    int err_ret, sin_size;
    struct sockaddr_in serv_addr, client_addr;
    pthread_t interrupt;
 
    /* initialize linked list */
    list_init(&client_list);
 
    /* initiate mutex */
    pthread_mutex_init(&clientlist_mutex, NULL);
 
    /* open a socket */
    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        err_ret = errno;
        fprintf(stderr, "socket() failed...\n");
        return err_ret;
    }
 
    /* set initial values */
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    serv_addr.sin_addr.s_addr = inet_addr(IP);
    memset(&(serv_addr.sin_zero), 0, 8);
 
    /* bind address with socket */
    if(bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr)) == -1) {
        err_ret = errno;
        fprintf(stderr, "bind() failed...\n");
        return err_ret;
    }
 
    /* start listening for connection */
    if(listen(sockfd, BACKLOG) == -1) {
        err_ret = errno;
        fprintf(stderr, "listen() failed...\n");
        return err_ret;
    }
 
    /* initiate interrupt handler for IO controlling */
    printf("Starting admin interface...\n");
    if(pthread_create(&interrupt, NULL, io_handler, NULL) != 0) {
        err_ret = errno;
        fprintf(stderr, "pthread_create() failed...\n");
        return err_ret;
    }
 
    /* keep accepting connections */
    printf("Starting socket listener...\n");
    while(1) {
        sin_size = sizeof(struct sockaddr_in);
        if((newfd = accept(sockfd, (struct sockaddr *)&client_addr, (socklen_t*)&sin_size)) == -1) {
            err_ret = errno;
            fprintf(stderr, "accept() failed...\n");
            return err_ret;
        }
        else {
            if(client_list.size == CLIENTS) {
                fprintf(stderr, "Connection full, request rejected...\n");
                continue;
            }
            printf("Connection requested received...\n");
            struct THREADINFO threadinfo;
            threadinfo.sockfd = newfd;
            strcpy(threadinfo.name, "Anonymous");
            pthread_mutex_lock(&clientlist_mutex);
            list_insert(&client_list, &threadinfo);
            pthread_mutex_unlock(&clientlist_mutex);
            pthread_create(&threadinfo.thread_ID, NULL, client_handler, (void *)&threadinfo);
        }
    }
 
    return 0;
}
 
void *io_handler(void *param) {
...
}
 
void *client_handler(void *fd) {
...
}

// char name[me_name_length+1]; //me_name_length максимальная длина, +1 для завершающего '\0' 
strncpy (me.name, name, me_name_length);
me.name[me_name_length] = '\0';