struct Complex{
	double Re;
	double Im;
};

int main(){
	int a = 4;
	struct Complex c;		//! Va esplicitata
}

#include <stdlib.h>

int main(){
	int mem_size = 5;
	int *ptr;
	ptr = (int*)malloc(sizeof(int)*mem_size);
	if(ptr == NULL){
		// errore nell'allocazione
	}

	free(ptr);
}

#include <stdio.h>

char *str1 = "Hello \n";		// Alloco 8 Byte |H|e|l|l|o| |\n|\0|
int len = strlen(str1);			// len -> 7

char str[20];
n = sizeof(str);
strncpy(str, "Hello \n", n);		// 8 è minore di 20, quindi tutt'ok

char *str2 = "World!\n";
n2 = sizeof(str2);
strcat(str, str2, n2);
/*
* considera str come la lunghezza senza \0, mentre in str2 lo considera
* produce quindi "Hello \nWorld!\n\0"

#include <stdio.h>

// Lettura file
int ret, n;
FILE *fd1;
fd1 = fopen("/tmp/foo.txt", "r");
if (fd1 == NULL) {
	// Gestione errore
}
ret = fscanf(fd1, "%d", &n);


// Scrittura file
char *str = "Hello!\n";
FILE *fd2;
fd2 = fopen("/tmp/bar.txt", "w");
if (fd2 == NULL) {
	// Gestione errore
}
ret = fprintf(fd2, "%s", str);

#include <stdio.h>
#include <sys/stat.h>

// Dimensione
int ret, size;
struct stat info;

ret = stat("/tmp/foo.txt", &info);
size = info.st_size;

time_t rawtime;
struct tm * timeinfo;

/* Ottieni l'ora in formato POSIX */
time(&rawtime);
timeinfo = localtime (&rawtime); 

/* La struttura timeinfo non va deallocata (è allocata staticamente dal 
sistema operativo, viene sovrascritta ad ogni invocazione */

/* Stampa l'ora */

// ctime() trasforma l'ora in stringa
printf("%s\n", ctime(&rawtime));

/* Formattare data/ora in stringa secondo un formato specificato */
strftime(buffer, BUFFER_SIZE, "%Y-%m-%d %H:%M:%S", timeinfo);

struct tm{
	int tm_sec   	// Seconds [0,60]. 
	int tm_min   	// Minutes [0,59]. 
	int tm_hour  	// Hour [0,23]. 
	int tm_mday  	// Day of month [1,31]. 
	int tm_mon   	// Month of year [0,11]. 
	int tm_year  	// Years since 1900. 
	int tm_wday  	// Day of week [0,6] (Sunday =0). 
	int tm_yday  	// Day of year [0,365]. 
	int tm_isdst 	// Daylight Savings flag. 
};

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

/**
* Permette la creazione di un socket. Non lo associa ad un indirizzo IP o ad una porta
* @param domain è la famisglia di protocolli da utilizzare, può valere
*					- AF_LOCAL: comunicazione locale
*					- AF_INET: protocolli IPv4, TCP e UDP
* @param type specifica la tipologia di socket
*					- SOCK_STREAM: connessione affidabile, bidireionale (TCP)
*					- SOCK_DGRAM: invio di pacchetti senza connessione (UDP)
* @param protocol va impostato sempre a 0
* @return un descrittore di file che rappresenta il socket e servità a manipolare il socket attraverso le altre primitive, `-1` su errore
*/
int socket(int domain, int type, int protocol);

/* Endpont IPv4 in `netinet/in.h`*/

struct sockaddr_in{
	sa_family_t		sin_family;		/* address family: AP_INET */
	in_port_t		sin_port;		/* port in network byte order */
	struct in_addr 	sin_addr;		/* internet address */
}

/* Internet address in `netinet/in.h` */
struct in_addr {
	uint32_t		s_addr;			/* address in network byte order*/
}

#include <arpa/inet.h>
#include <stdin.h>						// per `uint16_t` e `uint32_t`

uint32_t htonl(uint32_t hostlong); 		// host to network long
uint16_t htons(uint16_t hostshort); 	// host to network short
uint32_t ntohl(uint32_t netlong); 		// network to host long
uint16_t ntohs(uint16_t netshort); 		// network to host short

/**
* Permette di tradurre da formato presentazione a formato numerico
* @param af (address family) famiglia (AF_INET)
* @param src stringa del tipo "ddd.ddd.ddd.ddd"
* @param dst puntatore a una struct in_addr
*/
int inet_pton(int af, const char *src, void *dst);

/**
* Permette di tradurre da formato numerico a formato presentazione
* @param af: famiglia (AF_INET)
* @param src: puntatore a una struct in_addr
* @param dst: puntatore a un buffer di caratteri lungo size
* @param size: deve valere almeno INET_ADDRSTRLEN
*/
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main(){
	int sd = socket(AF_INET, SOCK_STREAM, 0);

	struct sockaddr_in my_addr;
	memset(&my_addr, 0, sizeof(my_addr));	// Pulizia per sicurezza

	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(4242);
	inet_pton(AF_INET, "192.168.4.5", &my_addr.sin_addr);

}

/**
* Assegna un socket a un indirizzo (IP+Porta).
* Viene usata dal server per specificare indirizzo e porta sui quali ricevere richieste.
* 	Di solito, il client non ha bisogno di eseguire questa funzione
* @param sockfd: descrittore del socket (socket file descriptor)
* @param addr: puntatore alla struttura di tipo `struct sockaddr` (Visto che usiamo `struct sockaddr_in` bisogna convertire il puntatore)
* @param addrlen: dimensione di `addr`
* @return `0` se ha successo, `-1` su errore
*/
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

// Esempio
ret = bind(sd, (struct sockaddr*)&my_addr, sizeof(my_addr));


/**
* Specifica che il socket è passivo, verrà quindi utilizzato per ricevere richieste di connessione.
* Possono essere messi in listen solo socket `SOCK_STREAM`
* All'arrivo di una richiesta di conessione il kernel lo mette in attesa in una coda, attendendo la chiamata di accept() per prenderle in carico
* Se arrivano più richieste di `backlog` le nuove richieste verranno rifiutate
* @param sockfd: descrittore del socket
* @param backlog: dimensione della coda, cioè quante richieste dai client possono rimanere in attesa di essere gestite
* @return `0` se ha successo, `-1` su errore
*/
int listen(int sockfd, int backlog);

// Esempio
ret = listen(sd, 10);


/**
* Accetta una richiesta di connessioen perveunta sul socket.
* Ha senso solo sui socket `SOCK_STREAM`
* La funzione è bloccante: il programma si ferma finché non arriva una richiesta
* @param sockfd: descrittore del socket
* @param addr: puntatore a una struttura (vuota) di tipo `struct sockaddr` (Qui ci viene salvato l'indirizzo del client
* @param addrlen: dimensione di addr
* @returns il descrittore di un nuovo socket che verrà usato per la comunicazione, `-1` su errore
*/
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

// Esempio
struct sockaddr_in cl_addr;
int len = sizeof(cl_addr);
new_sd = accept(sd, (struct sockaddr*)&cl_addr, &len);

#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main(){
	int ret, sd, new_sd, len;
	struct sockaddr_in myaddr, cl_addr;

	sd = socket(AF_INET, SOCK_STREAM, 0);

	memset(&my_addr, 0, sizeof(my_addr));
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(4242);
	inet_pton(AF_INET, "192.168.4.5", &my_addr.sin_addr);

	// se vogliamo stare in attesa su tutte le interfacce:
	// `my_addr.sin_addr.s_addr = INADDR_ANY`

	ret = bind(sd, (struct sockaddr*)&myaddr, sizeof(my_addr));
	ret = listen(sd, 10);

	int len = sizeof(cl_addr);

	new_sd = accept(sd, (struct sockaddr*)&cl_addr, &len);
}

/**
* Permette di connettere un socket locale ad un socket remoto.
* È una funzione bloccante che ferma il programma finché la richiesta di connessione non viene accetata
* @param sockfd descrittore del socket locale
* @param addr puntatore alla struttura contenente l'indirizzo del server
* @param addrlen dimensione di addr
* @returns `0` se ha successo, `-1 su errore
*/
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main () {
	int ret, sd;
  	struct sockaddr_in sv_addr; // Struttura per il server

	/* Creazione socket */
  	sd = socket(AF_INET, SOCK_STREAM, 0);
  	/* Creazione indirizzo del server */
	memset(&sv_addr, 0, sizeof(sv_addr)); // Pulizia
	sv_addr.sin_family = AF_INET ;
	sv_addr.sin_port = htons(4242);
  	inet_pton(AF_INET, "192.168.4.5", &sv_addr.sin_addr);
  	ret = connect(sd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
	//...
}

/**
* Invia un messaggio attraverso un socket connesso.
* È una funzione bloccante che ferma il programma finché non ha scritto tutto il messaggio.
* La funzione non "spedice pacchetti", ma copia dati nel buffer del kernel. Sarà poi quest'ultimo a frammentarli in pacchetti TCP.
* In caso di buffer saturo si blocca l'esecuzione del programma finché non vi è sufficiente spazio
* @param sockfd descrittore del socket
* @param buf puntatore al buffer contenente il messaggio da inviare
* @param len dimensione in byte del messaggio
* @param flags per settare delle opzioni, lo lascieremo a `0`
* @returns `numero di byte inviati` se ha successo, `-1` su errore
*/
ssize_t send(int sockfd, const void* buf, size_t len, int flags);

int ret, sd, len;
char buffer[1024];

// ...

strcpy(buffer, "Hello Server!");
len = strlen(buffer);
ret = send(sd, (void*)buffer, len, 0);
if(ret < len){
	// Gestione Errore
}

/**
* Permette di prelevare un messaggio da un socket connesso.
* La funzione è bloccante, ferma il programma finché non ha letto qualcosa
* @param sockfd descrittore del socket
* @param buf puntatore al buffer in cui salvare il messaggio
* @param len dimensione in byte del messaggio desiderato
* @param flags per settare delle opzioni
* @returns `numero di byte ricevuti`, `-1` su errore, `0` se il socket remoto si è
chiuso
*/
ssize_t recv(int sockfd, const void *buf, size_t len, int flags);

int ret, sd, bytes_needed;
char buffer[1024];

// ...

bytes_needed = 20;

ret = recv(sd, (void*)buffer, bytes_needed, 0);
// Adesso 0 < ret <= bytes_needed
if (ret < bytes_needed) {
	// Gestione errore
}

// OPPURE, per avere la certezza che `ret == bytes_needed`
ret = recv(sd, (void*)buffer, bytes_needed, MSG_WAITALL);

#include <unistd.h>

/**
* Permette di chiudere un socket.
* Invia un messaggio di `0` all'host remoto
* @param fd descrittore del socket
* @returns `0` se ha successo, `-1` su errore
*/
int close(int fd);

#include <errno.h>

ret = bind(sd, (struct sockaddr*)&my_addr, sizeof(my_addr));
  if (ret == -1) {
	switch(errno){
		case EADDRINUSE: /* Gestisci errore */
		case EINVAL:  /* Gestisci errore */
    	//...
	}
  }

#include <stdio.h>

// ...
ret = bind(sd, (struct sockaddr*)&my_addr, sizeof(my_addr));
if (ret == -1) {
	perror("Error: ");
	exit(1);
}
// ...

#include <unistd.h>
pid_t fork(void);

int ret, sd, new_sd, len;
struct sockaddr_in my_addr, cl_addr;

//...

pid_t pid;
sd = socket(AF_INET, SOCK_STREAM, 0);
ret = bind(sd, (struct sockaddr*)&my_addr, sizeof(my_addr));
ret = listen(sd, 10);
len = sizeof(cl_addr); 

//...

while (1) {
	new_sd = accept(sd, (struct sockaddr*)&cl_addr,&len);

	pid = fork();
	if (pid == -1){/*Gestione errore*/}

	if (pid == 0) {
		// Sono nel processo figlio. Chiudo socket in ascolto
		close(sd);
		
		// Servo la richiesta con new_sd
		//...

		close(new_sd);
		exit(0); // Il figlio termina
	}
	
	// Sono nel processo padre. Chiudo socket connesso al client
	close(new_sd);
}

#include <pthread.h>

/**
* crea un nuovo processo che partirà eseguendo start_routine(void)
*/
int pthread_create(pthread_t* thread, const pthread_attr_t* attr, void* (*start_routine)(void), void* arg);

/**
* blocca un thread in attesa della terminazione di un altro
*/
int pthread_join(pthread_t thread, void** retval);

/**
* per terminare un thread e mettere a disposizione un suo risultato
*/
void pthread_exit(void* retval);

int host_fd = socket(AF_INET, SOCK_STREAM|SOCK_NONBLOCK, 0);

#include <unistd.h>
#include <fcntl.h>

/**
* Server per manipolare un descrittore di file o di socket
* @param fd il descrittore
* @param cmd il comando da passare. Alcuni esempo
*		- F_GETFL: ottieni i flag di stato
*		- F_SETFL: imposta i flag di stato
* @param other terzo argomento facoltativo necessario per alcuni comandi
* @returns dipende dal comando, `-1` e errno su errore
*/
int fcntl(int fd, int cmd, int other);

int sd, ret;

sd = socket(/**/);

/* Ottieni i flag attuali */
ret = fcntl(sd, F_GETFL, NULL);

/* Setto il flag non bloccanto, MANTENENDO GLI ALTRI*/
fcntl(sd, F_SET, ret | O_NONBLOCK);

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

/**
* Rileva i socket pronti
* È una funzione bloccante. Si sblocca o quando un socket controllato diventa pronto o quando scade il timeout.
* @param nfds numero del descrittore più alto tra quelli da controllare + 1
* @param readfds lista di descrittori da controllare per la lettura
* @param writefds lista di descrittori da controllare per la scrittura
* @param exceptfds lista di descrittori da controllare per le eccezioni (non lo utilizzeremo)
* @param timeout intervallo di timeout
* @return restituisce il numero di descrittori pronti, `0` se scade il timeout, `-1` su errore
*/
int select(int nfds, fd_set* readfds, fd_set* writefds_fd, fd_set* exceptfds, struct timeval *timeout);

#include <sys/socket.h>
#include <netinet/in.h>

struct timeval{
	long tv_sec;	// secondi
	long tv_usec;	// microsecondi
};

struct timeval timeout = NULL;		// attesa indefinita

timeout = {10; 5};					// attesa massima di 10 secondi e 5 microsecondi
timeout = {0; 0};					// attesa nulla, controlla ed esce (polling)

/* Rimuove un descrittore dal set */
void FD_CLR(int fd, fd_set *set);

/* Controllare se un descrittore è nel set */
int FD_ISSET(int fd, fd_set *set);

/* Aggiunge un descrittore al set */
void FD_SET(int fd, fd_set *set);

/* Svuotare il set */
void FD_ZERO(fd_set *set);

int main(int argc, char** argv){
	fd_set master;					// Set principale
	fd_set read_fds;				// Set di lettura
	int fdmax;						// Numero massimo di descrittori

	struct sockaddr_in sv_addr;		// Indirizzo server
	struct sockaddr_in cl_addr;		// Indirizzo client
	int listener;					// Socket per l'ascolto

	int newfd;
	char buf[1024];
	int nbytes;
	int addrlen;
	int i;

	// Azzero i set
	FD_ZERO(&master);
	FD_ZERO(&read_fds);

	listener = socket(AF_INET, SOCK_STREAM|SOCK_NONBLOCK, 0);

	sv_addr.sin_family = AF_INET;
	sv_addr.sin_port = hton(20000);
	sv_addr.sin_addr.s_addr = INADDR_ANY;

	bind(listener, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
	listen(listener, 10);

	FD_SET(listener, &master);		// Aggiungo il listener al set

	fdmax = listener;

	for(;;){
		read_fds = master;			// copio il set

		select(fdmax + 1, &read_fds, NULL, NULL, NULL);

		for(int i = 0; i <= fd_max; ++i){	// scorro tutto il set
			if(FD_ISSET(i, &read_fds)){		// se trovo un descrittore pronto
				if(i == listener){			// è il listener
					addrlen = sizeof(cl_addr);
					newfd = accept(listener, (struct sockaddr_in*)&cl_addr, &addrlen);

					FD_SET(newfd, &master);	// aggiungo il nuovo socket al set
					if(newfd > fdmax){
						fdmax = newfd;		// aggiorno max
					}
				}
				else{
					// Se è un nuovo socket
					nbytes = recv(i, buf, sizeof(buf));
					// ... uso i dati
					close(i);
					FD_CLR(i, &master);		// rimuovo il socket dal set
				}
			}
		}
	}
}

/**
* È una funzione bloccante
* @param sockfd descrittore del socket
* @param buf buffer contenente il messaggio da inviare
* @param len lunghezza del messaggio in byte
* @param flags per settare opzioni, lo lasceremo a `0`
* @param dest_addr puntatore alla struttura che contiene l'indirizzo del destinatario
* @param addrlen lunghezza di `dest_addr`
* @returns il numero di byte inviati, `-1` su errore
*/
ssize_t sendto(int sockfd, const void* buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);

/**
* È una funzione bloccante
* @param sockfd descrittore del socket
* @param buf buffer contenente il messaggio da ricevere
* @param len lunghezza del messaggio in byte
* @param flags per settare opzioni
* @param src_addr puntatore alla struttura vuota dove salveremo l'indirizzo del mittente
* @param addrlen lunghezza di `src_addr`
* @returns il numero di byte ricevuti, `-1` su errore, `0` se il socket remoto si è chiuso
*/
ssize_t recv_from(itn sockfd, const void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t addrlen);

int main(){
	int ret, sd, len;
	char buf[BUFLEN];

	struct sockaddr_in sv_addr;

	/* Creazione Socket */
	sd = socket(AF_INET, SOCK_DGRAM, 0);

	/* Creazione indirizzo del server */
	memset(&sv_addr, 0, sizeof(sv_addr)); // Pulizia
	sv_addr.sin_family = AF_INET ;
	sv_addr.sin_port = htons(4242);
  	inet_pton(AF_INET, "192.168.4.5", &sv_addr.sin_addr);

	while(1){
		len = sendto(sd, buf, BUFLEN, 0, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
		// ...
	}
}

struct tmp{
	int a;
	char b;
} t;

/* invio */
sprintf(buffer, "%d %c", t.a, t.b);

/* ricezione */
sscanf(buffer, "%d %c", &t.a, &t.b);

sendto(sock, &t, sizeof(struct tmp), 0, &server, length);

struct temp{
 	uint32_t a;
 	uint8_t b;
} t;

//... 

t.a = htonl(t.a); 	// Convertire il formato prima dell’invio
ret = send(new_sd, (void*)&t.a, sizeof(uint32_t), 0);
t.b = htonl(t.b); 
ret = send(new_sd, (void*)&t.b, sizeof(uint8_t), 0);