//****************************************************** los includes necesarios...

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
//#include <conio.h>

//******************************************************se utilizara este puerto ...

#define PUERTO 8000
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //el semaforo

//****************creamos los 2 sockets...

int sock_servidor, sock_cliente;
int longitud_cli,salir=1;
//****************creamos un buffer para guardar los mensajes a enviar...
char buffer[256];

struct sockaddr_in dir_servidor, dir_cliente;

int n;
int cliente;
struct hostent *cli;
char *num_ip,num_ip_aux[50];

void hilo_users(void *);

void hilo_menu(void *);
void error(char *msg)
{
perror(msg);
exit(1);
}

int main (int argc, char *argv[])

{

pthread_t hilo_cliente1;
pthread_t hilo_cliente2;
pthread_t hilo_cliente3;
pthread_t hilo_servidor;

int valor_hilo;
//******************** creamos el socket....
//******************** los argumentos son los siguientes:
//******************** AF_INET familia de direcciones
//******************** SOCK_STREAM tipo de socket
//******************** 0 es el protocolo que se determina por los otros argumentos
//******************** anteriores(TCP)
sock_servidor = socket(AF_INET, SOCK_STREAM, 0);

if (sock_servidor < 0)
error("No se pudo crear el socket =/ \n");

//******************** dejamos en ceros la estructura del dir_servidor...

bzero((char *) &dir_servidor, sizeof(dir_servidor));

//******************** configuramos los paramentros de la estructura dir_servidor...

dir_servidor.sin_family = AF_INET; //*******************************familia de
direcciones
dir_servidor.sin_addr.s_addr = INADDR_ANY; //*********************numero IP del servidor
dir_servidor.sin_port = htons(PUERTO); //*************************numero de puerto

//******************** enlazamos el socket...

if (bind(sock_servidor, (struct sockaddr *) &dir_servidor,sizeof(dir_servidor)) < 0)

error("No se puede enlazar el socket!\n ");

//******************** dejamos escuchando el socket...

listen(sock_servidor,5);
longitud_cli = sizeof(dir_cliente);
printf(" SERVIDOR LEVANTADO!!!\n");

//******************** Se crea un hilo servidor que llamara al procedimiento menu

//******************** que se ejecutara al mismo tiempo que se conecten los clientes
valor_hilo = pthread_create(&hilo_servidor, NULL, (void *)hilo_menu, NULL);
if (valor_hilo != 0) {
perror("NO SE PUDO CREAR HILO: hilo_cliente1");
exit(0);
}
//*********************************************************************************
**********
//******************** se crea el hilo para que el servidor atienda la llamada de un cliente
//******************** al mismo tiempo escuche a otro posible cliente que solicite el servicio
//******************** Crea 3 hilos

valor_hilo = pthread_create(&hilo_cliente1, NULL, (void *)hilo_users, NULL);

if (valor_hilo != 0) {
 perror("NO SE PUDO CREAR HILO: hilo_cliente1");
exit(0);
}

valor_hilo = pthread_create(&hilo_cliente2, NULL, (void *)hilo_users, NULL);

if (valor_hilo != 0) {
perror("NO SE PUDO CREAR HILO: hilo_cliente2");
exit(0);
}

valor_hilo = pthread_create(&hilo_cliente3, NULL, (void *)hilo_users, NULL);

if (valor_hilo != 0) {
perror("NO SE PUDO CREAR HILO: hilo_cliente3");
exit(0);
}

pthread_join(hilo_cliente1, NULL);
pthread_join(hilo_cliente2, NULL);
pthread_join(hilo_cliente3, NULL);
pthread_join(hilo_servidor, NULL);
// y cerramos los sockets...?*/
close(sock_cliente);
close(sock_servidor);
exit(0);
}

//****************** Procedimiento que realiza las conexiones entre el servidor

//****************** y los posibles clientes que se conecten
void hilo_users(void *arg)
{
FILE *archivo;
char linea[256];
int usuario=0;
//******************** esperamos para aceptar un enlace...
sock_cliente = accept(sock_servidor,(struct sockaddr *)&dir_cliente,&longitud_cli);

if (sock_cliente < 0)
{ error("No se puede aceptar el enlace!\n");
exit(0);
}

//******************** obtenemos algunos datos del cliente...

//******************** La direccion IP
num_ip=inet_ntoa(dir_cliente.sin_addr);
strcpy(num_ip_aux,num_ip);

//******************** dejamos con ceros el buffer

bzero(buffer,256);
 n = read(sock_cliente,buffer,255);

if (n < 0)
{ error("No se puede obtener nombre del cliente!\n");
exit(0);
}

//********************
bzero(buffer,256);
usuario=0;
//****** si se coencto algun cliente sale del ciclo
while(usuario!=1)
{
bzero(buffer,256);

//******************** leemos el nombre del cliente y se guarda en buffer

n = read(sock_cliente,buffer,255);
if (n < 0)
{ error("No se puede recibir mensaje del cliente!\n");
exit(0);
}

//printf("%s",buffer);
if (n < 0)
{ error("No se puede enviar mensaje de confirmación =(\n");
exit(0);
}
//******************** se valida el login del cliente
//******************** login validos : cliente1 , cliente2 , cliente3
//******************** envia por lineas (max 255 caractres) el mensaje el archivo memo
correspondiente cliente
if((0==strcmp(buffer,"cliente1\n")))
{
usuario=1;
archivo=fopen("/home/memo1.txt","r");
//******************** envia por lineas (max 255 caractres) el mensaje el archivo memo
correspondiente cliente
while(!feof(archivo))
{
fgets(linea, 255, archivo);
n = write(sock_cliente,linea,255);
n = read(sock_cliente,linea,2);
}
 n = write(sock_cliente,"ok",2);
fclose(archivo);
}

if((0==strcmp(buffer,"cliente2\n")))
{
usuario=1;
archivo=fopen("/home/memo2.txt","r");
//******************** envia por lineas (max 255 caractres) el mensaje el archivo memo
correspondiente cliente
while(!feof(archivo))
{
fgets(linea, 255, archivo);
n = write(sock_cliente,linea,255);
n = read(sock_cliente,linea,2);
}
n = write(sock_cliente,"ok",2);
fclose(archivo);
}

if((0==strcmp(buffer,"cliente3\n")))
{
usuario=1;
archivo=fopen("/home/memo3.txt","r");
//******************** envia por lineas (max 255 caractres) el mensaje el archivo memo
correspondiente cliente
while(!feof(archivo))
{
fgets(linea, 255, archivo);
n = write(sock_cliente,linea,255);
n = read(sock_cliente,linea,2);
}
n = write(sock_cliente,"ok",2);
fclose(archivo);
}

// y cerramos los sockets...?*/

close(sock_cliente);
close(sock_servidor);

}
//*** despliega una interfaz para el servidor
void hilo_menu(void *arg)
{
char *opcion;
int salir=0;
char linea[256];
FILE *archivo_memos;
while(salir!=1)
{

printf("\t\n\n MENU SERVIDOR\n\n\n");

printf("\t [ 1 ] escribir memo cliente 1\n");
printf("\t [ 2 ] escribir memo cliente 2\n");
printf("\t [ 3 ] escribir memo cliente 3\n");
printf("\t [ 4 ] Salir \n\n");
printf("\tIngrese Opcion: ");
//fgets(opcion,1,stdin);
scanf("%s",opcion);
//printf("\n\n ** %s **\n\n",opcion);
if(0==strcmp(opcion,"1"))
{
archivo_memos=fopen("/home/memo1.txt","a");
printf("\n\n\n Escriba el mensaje en el memo1:\n");
fgets(linea,50,stdin);
fputs(linea,archivo_memos);
fputs("\n",archivo_memos);
fclose(archivo_memos);
}
if(0==strcmp(opcion,"2"))
{
archivo_memos=fopen("/home/memo2.txt","a");
printf("\n\n\n Escriba el mensaje en el memo2:\n");
fgets(linea,50,stdin);
fputs(linea,archivo_memos);
fputs("\n",archivo_memos);
fclose(archivo_memos);
}
if(0==strcmp(opcion,"3"))
{
archivo_memos=fopen("/home/memo3.txt","a");
printf("\n\n\n Escriba el mensaje en el memo3:\n");
fgets(linea,50,stdin);
fputs(linea,archivo_memos);
fputs("\n",archivo_memos);
fclose(archivo_memos);
}
if(0==strcmp(opcion,"4"))
{
salir=1;
}
}
close(sock_cliente);
close(sock_servidor);
}

Resultado: