client
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <pthread.h>
void *recvmg(void *sock)
{
	int their_sock = *((int *)sock);
	char msg[500];
	int len;
	while((len = recv(their_sock,msg,500,0)) > 0) {
		msg[len] = '\0';
		printf("%s\n",msg);
		memset(msg,'\0',sizeof(msg));
	}
}
int main(int argc, char *argv[])
{
	struct sockaddr_in their_addr;
	int my_sock;
	int their_sock;
	int their_addr_size;
	int portno;
	pthread_t sendt,recvt;
	char msg[500];
	char username[100];
	char res[600];
	char ip[INET_ADDRSTRLEN];
	int len;

	if(argc > 3) {
		printf("too many arguments");
		exit(1);
	}
	portno = atoi(argv[2]);
	strcpy(username,argv[1]);
	my_sock = socket(AF_INET,SOCK_STREAM,0);
	memset(their_addr.sin_zero,'\0',sizeof(their_addr.sin_zero));
	their_addr.sin_family = AF_INET;
	their_addr.sin_port = htons(portno);
	their_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

	if(connect(my_sock,(struct sockaddr *)&their_addr,sizeof(their_addr)) < 0) {
		perror("connection not esatablished");
		exit(1);
	}
	inet_ntop(AF_INET, (struct sockaddr *)&their_addr, ip, INET_ADDRSTRLEN);
	printf("connected to %s, start chatting\n",ip);
	pthread_create(&recvt,NULL,recvmg,&my_sock);
	while(fgets(msg,500,stdin) > 0) {
	//	strcpy(res,username);
	//	strcat(res,":");
		strcat(res,msg);
		len = write(my_sock,res,strlen(res));
		if(len < 0) {
			perror("message not sent");
			exit(1);
		}
		memset(msg,'\0',sizeof(msg));
		memset(res,'\0',sizeof(res));
	}
	pthread_join(recvt,NULL);
	close(my_sock);

}

------------------------------------------
-------------------------------------------------
---------------------
serwer
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <stdbool.h>
struct client_info {
	int sockno;
	char ip[INET_ADDRSTRLEN];
};
struct tm * timeinfo;
char buffer[32];
time_t timet;
//obsluga max 100 klientow
int clients[100];
int n = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
char string[100];
double client_sqrt;
int isdigit=0;

void sqrt_char(char *number){

	client_sqrt= sqrt(atoi(number));
}

void date_time(){

	time(&timet);
	timeinfo=localtime(&timet);
	strftime(buffer , 32 , "_%Y_%m_%d_%H_%M" , timeinfo);
}


//to bardzo proste po prostu wysylanie z czatu(msg = nick: wiadomosc). latwo przerobic na komunikacja klient-serwer
void sendtoall(char *msg,int curr)
{
	int i=0;
	int c=0;
	int isdigit=0;




		if(strcmp(msg,"data\n") == 0)
		{
			date_time();
			strcpy(msg,buffer);
		}

		while(c<strlen(msg)-1 && isdigit ==0)
		{

			if(msg[c]>= '0' && msg[c] <='9')
				isdigit=0;
			else
				isdigit=1;
			c++;

		}


		if(isdigit==0)
		{
			sqrt_char(msg);
			sprintf(msg,"%lf",client_sqrt);
			//*(double*)msg=client_sqrt;

		}


	pthread_mutex_lock(&mutex);


	for(i = 0; i < n; i++) {

		if(clients[i] == curr)
 		{
			if(send(clients[i],msg,strlen(msg),0) < 0) {
				perror("sending failure");
				continue;
					}
		}


	}

	pthread_mutex_unlock(&mutex);

}
void *recvmg(void *sock)
{
	struct client_info cl = *((struct client_info *)sock);
	char msg[500];
	int len;
	int i;
	int j;

	//rec zwraca ilość bajtów odczytanych ze żródła rec(gniazdo,bufr_zapisu, wielkosc bufora, flaga - nie powiedzial do czego była ;c )
	while((len = recv(cl.sockno,msg,500,0)) > 0) {
		msg[len] = '\0';
		sendtoall(msg,cl.sockno);
		memset(msg,'\0',sizeof(msg));
	}
	pthread_mutex_lock(&mutex);
//odlaczenie klienta + przepisanie klientów żeby nie było adresu tego co poszedł
	printf("%s disconnected\n",cl.ip);
	for(i = 0; i < n; i++) {
		if(clients[i] == cl.sockno) {
			j = i;
			while(j < n-1) {
				clients[j] = clients[j+1];
				j++;
			}
		}
	}
	n--;
	pthread_mutex_unlock(&mutex);
}
int main(int argc,char *argv[])
{

	/*
	struct sockaddr_in{
		sa_family_t - zawsze sutawione na AF_INET , adresy IP i numery portów
		in_port_t - port komunikacji
		sin_addr - ip hosta
		sin_zero[8] - tego nie ma nanwet w dokumentacji linuxa xD
	}
	*/

	struct sockaddr_in my_addr,their_addr;
	int my_sock;
	int their_sock;
	socklen_t their_addr_size;
	int portno; //port serwera
	pthread_t sendt,recvt;
	char msg[500];
	int len;

	/*
	struct client_info {
		int descriptor- gniazdo klienta
		address - struktura socketaddr_in dla klienta
	}
	*/


	struct client_info cl;
	char ip[INET_ADDRSTRLEN];;
	;

	if(argc > 2) {
		printf("too many arguments");
		exit(1);
	}

	portno = atoi(argv[1]);
	//gniazdo dla tcp
	my_sock = socket(AF_INET,SOCK_STREAM,0);
	// dla udp : my_sock = socket(AF_INET,SOCK_DGRAM,0);
	memset(my_addr.sin_zero,'\0',sizeof(my_addr.sin_zero));
	my_addr.sin_family = AF_INET;
	//zamiana na kolejnosc bajtow sieciowych z kolejnosci hosta
	my_addr.sin_port = htons(portno);
	//inet_add konweruje z adresu w normalnej notacji na binarna
	my_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

	their_addr_size = sizeof(their_addr);
	/*bind(1,2,3) - przypisuje nazwę do gniazda tak było na wykładzie powiedziane
		1- gniazdo
		2- adres na kktó©y wskazuje
		3- okreslony w bajtach rozmiar struktury adresu
	*/
	if(bind(my_sock,(struct sockaddr *)&my_addr,sizeof(my_addr)) != 0) {
		perror("binding unsuccessful");
		exit(1);
	}

	//listen - nasłuch okreslajacy gniazdo nasłuchu i maksymala dlugosc kolejki . jak kolejka jest pełna to wywala bład enconnrefused. dla retransmisji moze zignoworwac polaczenie i sprobowac nawiazac potem
	if(listen(my_sock,5) != 0) {
		perror("listening unsuccessful");
		exit(1);
	}

	//accept - tworzy połączenie i zwraca deskryptor dla tego gniazda
	while(1) {
		if((their_sock = accept(my_sock,(struct sockaddr *)&their_addr,&their_addr_size)) < 0) {
			perror("accept unsuccessful");
			exit(1);
		}

		pthread_mutex_lock(&mutex);
		//konwersja adresu sieciowegodo char[]. cos takiego
		inet_ntop(AF_INET, (struct sockaddr *)&their_addr, ip, INET_ADDRSTRLEN);
		printf("%s connected\n",ip);
		cl.sockno = their_sock;
		strcpy(cl.ip,ip);
		clients[n] = their_sock;
		n++;
		pthread_create(&recvt,NULL,recvmg,&cl);
		pthread_mutex_unlock(&mutex);
	}
	return 0;
}
//na tym wykładzie był też przyponiane o tych mutexach ze te lock blokuje a unlock zwalnia zasoby teg watku