Creato server-client daytime e print_ip_client

7.client-server-daytime/daytimecli.c

@@ -0,0 +1,35 @@
+/* Client che interroga un daytime server */
+
+#include	"../basic.h"
+
+int main(int argc, char **argv) {
+	int			sockfd, n;
+	char			recvline[MAXLINE + 1];
+	struct sockaddr_in	servaddr;
+
+	if (argc != 3){
+		printf("usage: daytimecli <indirizzoIP> <porta> \n");
+		exit(0);
+}
+        if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ){
+			printf("socket error\n");
+			exit(0);
+}
+	bzero(&servaddr, sizeof(servaddr));
+	servaddr.sin_family = AF_INET;
+        servaddr.sin_port = htons(atoi(argv[2])); /* server port */ 
+
+        if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){
+                printf("inet_pton error for %s\n", argv[1]);
+		exit(0);
+}
+	if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0){
+		printf("connect error\n");
+		exit(0);
+}
+	while ( (n = read(sockfd, recvline, MAXLINE)) > 0) {
+		recvline[n] = 0;	/* null terminate */
+		fputs(recvline, stdout);
+	}
+		exit(0);
+		}

7.client-server-daytime/daytimecli.c~

@@ -0,0 +1,35 @@
+/* Client che interroga un daytime server */
+
+#include	"basic.h"
+
+int main(int argc, char **argv) {
+	int			sockfd, n;
+	char			recvline[MAXLINE + 1];
+	struct sockaddr_in	servaddr;
+
+	if (argc != 3){
+		printf("usage: daytimecli <indirizzoIP> <porta> \n");
+		exit(0);
+}
+        if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ){
+			printf("socket error\n");
+			exit(0);
+}
+	bzero(&servaddr, sizeof(servaddr));
+	servaddr.sin_family = AF_INET;
+        servaddr.sin_port = htons(atoi(argv[2])); /* server port */ 
+
+        if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){
+                printf("inet_pton error for %s\n", argv[1]);
+		exit(0);
+}
+	if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0){
+		printf("connect error\n");
+		exit(0);
+}
+	while ( (n = read(sockfd, recvline, MAXLINE)) > 0) {
+		recvline[n] = 0;	/* null terminate */
+		fputs(recvline, stdout);
+	}
+		exit(0);
+		}

7.client-server-daytime/daytimesrv.c

@@ -0,0 +1,42 @@
+/* Implementa un daytime server che risponde alla porta definita dall'utente */
+
+#include	"../basic.h"
+#include	<time.h>
+
+int main(int argc, char **argv) {
+	int			listenfd, connfd, n;
+	struct sockaddr_in	servaddr;
+	char			buff[MAXLINE];
+	time_t			ticks;
+
+	if (argc != 2 ){
+		printf("usage: daytimesrv <porta>\n");
+		exit(0);
+}
+	if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
+		printf("socket error\n");
+		exit(0);
+}
+	bzero(&servaddr, sizeof(servaddr));
+	servaddr.sin_family      = AF_INET;
+	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   /* wildcard address */
+	servaddr.sin_port        = htons(atoi(argv[1])); /* server port */
+
+	if( (bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr))) < 0){
+		printf("bind error\n"); exit(0);
+}
+	if( listen(listenfd, 5) < 0 )
+		{ printf("listen error\n");
+		  exit(0);
+}
+	for ( ; ; ) {
+		if( (connfd = accept(listenfd, (struct sockaddr *) NULL, NULL)) < 0)
+		{ printf("accept error\n"); exit(0);} else {
+		}
+
+        	ticks = time(NULL);
+        	snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks));
+        	while ( (n=write(connfd, buff, strlen(buff))) < 0 ); 
+		close(connfd);
+	}
+}

7.client-server-daytime/daytimesrv.c~

@@ -0,0 +1,41 @@
+/* Implementa un daytime server che risponde alla porta definita dall'utente */
+
+#include	"basic.h"
+#include	<time.h>
+
+int main(int argc, char **argv) {
+	int			listenfd, connfd, n;
+	struct sockaddr_in	servaddr;
+	char			buff[MAXLINE];
+	time_t			ticks;
+
+	if (argc != 2 ){
+		printf("usage: daytimesrv <porta>\n");
+		exit(0);
+}
+	if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
+		printf("socket error\n");
+		exit(0);
+}
+	bzero(&servaddr, sizeof(servaddr));
+	servaddr.sin_family      = AF_INET;
+	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   /* wildcard address */
+	servaddr.sin_port        = htons(atoi(argv[1])); /* server port */
+
+	if( (bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr))) < 0){
+		printf("bind error\n"); exit(0);
+}
+	if( listen(listenfd, 5) < 0 )
+		{ printf("listen error\n");
+		  exit(0);
+}
+	for ( ; ; ) {
+		if( (connfd = accept(listenfd, (struct sockaddr *) NULL, NULL)) < 0)
+		{ printf("accept error\n"); exit(0);}
+
+        	ticks = time(NULL);
+        	snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks));
+        	while ( (n=write(connfd, buff, strlen(buff))) < 0 ); 
+		close(connfd);
+	}
+}

7.client-server-daytime/makefile

@@ -0,0 +1,9 @@
+all : server client
+server : daytimesrv.o ../fun-corso-reti.o
+	gcc -o server daytimesrv.o ../fun-corso-reti.o
+client : daytimecli.o ../fun-corso-reti.o
+	gcc -o client daytimecli.o ../fun-corso-reti.o
+daytimesrv.o : daytimesrv.c ../basic.h
+	gcc -c -o daytimesrv.o daytimesrv.c
+fun-corso-reti.o : ../fun-corso-reti.c ../basic.h
+	gcc -c -o ../fun-corso-reti.o ../fun-corso-reti.c

7.client-server-daytime/makefile~

@@ -0,0 +1,8 @@
+server : daytimesrv.o ../fun-corso-reti.o
+	gcc -o server daytimesrv.o ../fun-corso-reti.o
+client : daytimecli.o ../fun-corso-reti.o
+	gcc -o client daytimecli.o ../fun-corso-reti.o
+daytimesrv.o : daytimesrv.c ../basic.h
+	gcc -c -o daytimesrv.o daytimesrv.c
+fun-corso-reti.o : ../fun-corso-reti.c ../basic.h
+	gcc -c -o ../fun-corso-reti.o ../fun-corso-reti.c

7.client-server-daytime/readme

@@ -0,0 +1,2 @@
+il server per ogni richiesta accettata copia la data locale al socket client
+il client colelgato legge la data copiata e stampa 

7.client-server-sendip/daytimecli.c

@@ -0,0 +1,30 @@
+/* Client che si collega a un server e basta */
+
+#include	"../basic.h"
+
+int main(int argc, char **argv) {
+	int			sockfd;
+	struct sockaddr_in	servaddr;
+
+	if (argc != 3){
+		printf("usage: daytimecli <indirizzoIP> <porta> \n");
+		exit(0);
+}
+        if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ){
+			printf("socket error\n");
+			exit(0);
+}
+	bzero(&servaddr, sizeof(servaddr));
+	servaddr.sin_family = AF_INET;
+        servaddr.sin_port = htons(atoi(argv[2])); /* server port */ 
+
+        if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){
+                printf("inet_pton error for %s\n", argv[1]);
+		exit(0);
+}
+	if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0){
+		printf("connect error\n");
+		exit(0);
+	}
+	exit(0);
+}

7.client-server-sendip/daytimecli.c~

@@ -0,0 +1,31 @@
+/* Client che interroga un daytime server */
+
+#include	"../basic.h"
+
+int main(int argc, char **argv) {
+	int			sockfd, n;
+	char			recvline[MAXLINE + 1];
+	struct sockaddr_in	servaddr;
+
+	if (argc != 3){
+		printf("usage: daytimecli <indirizzoIP> <porta> \n");
+		exit(0);
+}
+        if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ){
+			printf("socket error\n");
+			exit(0);
+}
+	bzero(&servaddr, sizeof(servaddr));
+	servaddr.sin_family = AF_INET;
+        servaddr.sin_port = htons(atoi(argv[2])); /* server port */ 
+
+        if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){
+                printf("inet_pton error for %s\n", argv[1]);
+		exit(0);
+}
+	if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0){
+		printf("connect error\n");
+		exit(0);
+	}
+	exit(0);
+}

7.client-server-sendip/daytimesrv.c

@@ -0,0 +1,45 @@
+/* stampa l'ip del client che si collega */
+
+#include	"../basic.h"
+#include	<time.h>
+
+int main(int argc, char **argv) {
+	int			listenfd, connfd, n;
+	struct sockaddr_in	servaddr;
+	char			buff[INET_ADDRSTRLEN];
+
+	if (argc != 2 ){
+		printf("usage: daytimesrv <porta>\n");
+		exit(0);
+}
+	if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
+		printf("socket error\n");
+		exit(0);
+}
+	bzero(&servaddr, sizeof(servaddr));
+	servaddr.sin_family      = AF_INET;
+	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   /* wildcard address */
+	servaddr.sin_port        = htons(atoi(argv[1])); /* server port */
+
+	if( (bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr))) < 0){
+		printf("bind error\n"); exit(0);
+}
+	if( listen(listenfd, 5) < 0 )
+		{ printf("listen error\n");
+		  exit(0);
+		}
+
+	struct sockaddr_in	client_addr;
+	int client_addr_len = sizeof(client_addr);
+
+	for ( ; ; ) {
+		if( (connfd = accept(listenfd, (struct sockaddr *) &client_addr, &client_addr_len)) < 0)
+		{ printf("accept error\n");
+		exit(0);
+		} 
+
+		inet_ntop(AF_INET, &(client_addr.sin_addr), buff, INET_ADDRSTRLEN);
+		fprintf (stdout,"%s\n",buff);
+		close(connfd);
+	}
+}

7.client-server-sendip/daytimesrv.c~

@@ -0,0 +1,41 @@
+/* stampa l'ip del client */
+
+#include	"../basic.h"
+#include	<time.h>
+
+int main(int argc, char **argv) {
+	int			listenfd, connfd, n;
+	struct sockaddr_in	servaddr;
+	char			buff[MAXLINE];
+	time_t			ticks;
+
+	if (argc != 2 ){
+		printf("usage: daytimesrv <porta>\n");
+		exit(0);
+}
+	if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
+		printf("socket error\n");
+		exit(0);
+}
+	bzero(&servaddr, sizeof(servaddr));
+	servaddr.sin_family      = AF_INET;
+	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   /* wildcard address */
+	servaddr.sin_port        = htons(atoi(argv[1])); /* server port */
+
+	if( (bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr))) < 0){
+		printf("bind error\n"); exit(0);
+}
+	if( listen(listenfd, 5) < 0 )
+		{ printf("listen error\n");
+		  exit(0);
+}
+	for ( ; ; ) {
+		if( (connfd = accept(listenfd, (struct sockaddr *) NULL, NULL)) < 0)
+		{ printf("accept error\n"); exit(0);} else {
+		}
+
+		n=read(connfd, buff, MAXLINE);
+		fprintf (stdout,%s\n,buff);
+		close(connfd);
+	}
+}

7.client-server-sendip/makefile

@@ -0,0 +1,9 @@
+all : server client
+server : daytimesrv.o ../fun-corso-reti.o
+	gcc -o server daytimesrv.o ../fun-corso-reti.o
+client : daytimecli.o ../fun-corso-reti.o
+	gcc -o client daytimecli.o ../fun-corso-reti.o
+daytimesrv.o : daytimesrv.c ../basic.h
+	gcc -c -o daytimesrv.o daytimesrv.c
+fun-corso-reti.o : ../fun-corso-reti.c ../basic.h
+	gcc -c -o ../fun-corso-reti.o ../fun-corso-reti.c

7.client-server-sendip/makefile~

@@ -0,0 +1,8 @@
+server : daytimesrv.o ../fun-corso-reti.o
+	gcc -o server daytimesrv.o ../fun-corso-reti.o
+client : daytimecli.o ../fun-corso-reti.o
+	gcc -o client daytimecli.o ../fun-corso-reti.o
+daytimesrv.o : daytimesrv.c ../basic.h
+	gcc -c -o daytimesrv.o daytimesrv.c
+fun-corso-reti.o : ../fun-corso-reti.c ../basic.h
+	gcc -c -o ../fun-corso-reti.o ../fun-corso-reti.c

7.client-server-sendip/readme

@@ -0,0 +1,2 @@
+il server attende una connessione dal client e stampa lip del client
+il client si connette soltanto al server

8.client-server-echo/echocli.c

@@ -0,0 +1,40 @@
+/* Client che interroga un echo server */
+
+#include	"basic.h"
+
+void client_echo(FILE *fp, int sockfd); 
+
+int main(int argc, char **argv) {
+	int			sockfd, n;
+	struct sockaddr_in	servaddr;
+
+	if (argc != 3)
+			{ printf("usage: echocli <IPaddress> <PORT>\n"); exit(1); }
+
+	if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
+		{ printf("socket error\n"); exit(1); }
+
+	bzero(&servaddr, sizeof(servaddr));
+	servaddr.sin_family = AF_INET;
+	servaddr.sin_port   = htons(atoi(argv[2]));	/* echo server port */
+	if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0)
+		{ printf("inet_pton error for %s", argv[1]); exit(1);}
+
+	if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
+		{ printf("connect error\n"); exit(1);}
+
+        client_echo(stdin, sockfd);	/* svolge tutto il lavoro del client */
+	exit(0);
+}
+
+
+void client_echo(FILE *fp, int sockfd) {
+        char    sendline[MAXLINE], recvline[MAXLINE];
+        while (fgets(sendline, MAXLINE, fp) != NULL) {
+                reti_writen(sockfd, sendline, strlen(sendline));
+                if (reti_readline(sockfd, recvline, MAXLINE) == 0)
+                        { printf("%s: server terminated prematurely",__FILE__); exit(1); }
+                fputs(recvline, stdout);
+        }
+}
+

8.client-server-echo/echosrv.c

@@ -0,0 +1,59 @@
+/* Implementa un echo server che risponde alla porta definita dall'utente */
+/* Crea un figlio per ogni client */
+
+#include	"../basic.h"
+
+void server_echo(int sockfd);
+
+int main(int argc, char **argv) {
+        pid_t			childpid;
+	int			listenfd, connfd;
+	struct sockaddr_in	servaddr, cliaddr;
+	socklen_t		cliaddr_len;
+
+        if( argc != 2){
+           printf("Usage: echosrv <PORT> \n"); exit(1); 
+}
+
+	if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
+		{ printf("socket error\n"); exit(1); }
+
+	bzero(&servaddr, sizeof(servaddr));
+	servaddr.sin_family      = AF_INET;
+	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  /* wildcard address */
+	servaddr.sin_port        = htons(atoi(argv[1]));	/* echo server */
+
+	if( (bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr))) < 0)
+		 { printf("bind error\n"); exit(1); }
+
+	if( listen(listenfd, BACKLOG) < 0 )
+		{ printf("listen error\n"); exit(1);}
+
+	for ( ; ; ) {
+		cliaddr_len = sizeof(cliaddr);
+		if( (connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &cliaddr_len)) < 0)
+			{ printf("accept error\n"); exit(1); }
+
+                if( (childpid = fork()) == 0 ) {
+		    close(listenfd);
+		    server_echo(connfd);      /* svolge tutto il lavoro del server */
+		    exit(0);
+		}
+
+		close(connfd);
+	}
+}
+
+void server_echo(int sockfd) {
+        ssize_t         n;
+        char            line[MAXLINE];
+        for ( ; ; ) {
+                if ( (n = reti_readline(sockfd, line, MAXLINE)) == 0)
+		{
+			printf("\n Connessione chiusa dal client \n");
+                        return;         /* connection closed by other end */
+		}
+	      reti_writen(sockfd, line, n);
+        }
+}
+

8.client-server-echo/echosrv.c~

@@ -0,0 +1,59 @@
+/* Implementa un echo server che risponde alla porta definita dall'utente */
+/* Crea un figlio per ogni client */
+
+#include	"/..basic.h"
+
+void server_echo(int sockfd);
+
+int main(int argc, char **argv) {
+        pid_t			childpid;
+	int			listenfd, connfd;
+	struct sockaddr_in	servaddr, cliaddr;
+	socklen_t		cliaddr_len;
+
+        if( argc != 2){
+           printf("Usage: echosrv <PORT> \n"); exit(1); 
+}
+
+	if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
+		{ printf("socket error\n"); exit(1); }
+
+	bzero(&servaddr, sizeof(servaddr));
+	servaddr.sin_family      = AF_INET;
+	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  /* wildcard address */
+	servaddr.sin_port        = htons(atoi(argv[1]));	/* echo server */
+
+	if( (bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr))) < 0)
+		 { printf("bind error\n"); exit(1); }
+
+	if( listen(listenfd, BACKLOG) < 0 )
+		{ printf("listen error\n"); exit(1);}
+
+	for ( ; ; ) {
+		cliaddr_len = sizeof(cliaddr);
+		if( (connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &cliaddr_len)) < 0)
+			{ printf("accept error\n"); exit(1); }
+
+                if( (childpid = fork()) == 0 ) {
+		    close(listenfd);
+		    server_echo(connfd);      /* svolge tutto il lavoro del server */
+		    exit(0);
+		}
+
+		close(connfd);
+	}
+}
+
+void server_echo(int sockfd) {
+        ssize_t         n;
+        char            line[MAXLINE];
+        for ( ; ; ) {
+                if ( (n = reti_readline(sockfd, line, MAXLINE)) == 0)
+		{
+			printf("\n Connessione chiusa dal client \n");
+                        return;         /* connection closed by other end */
+		}
+	      reti_writen(sockfd, line, n);
+        }
+}
+

8.client-server-echo/makefile

@@ -0,0 +1,6 @@
+server : echosrv.o ../fun-corso-reti.o
+	gcc -o server echosrv.o ../fun-corso-reti.o
+echosrv.o : echosrv.c ../basic.h
+	gcc -c -o echosrv.o echosrv.c
+fun-corso-reti.o : ../fun-corso-reti.c ../basic.h
+	gcc -c -o ../fun-corso-reti.o ../fun-corso-reti.c

8.client-server-echo/makefile~

@@ -0,0 +1,8 @@
+calcola : calcola.o funzioni1.o funzioni2.o
+	gcc -o calcola calcola.o funzioni1.o funzioni2.o
+calcola.o : funzioni.h calcola.c
+	gcc -c -o calcola.o calcola.c
+funzioni1.o : funzioni.h funzioni1.c
+	gcc -c -o funzioni1.o funzioni1.c
+funzioni2.o : funzioni.h funzioni2.c
+	gcc -c -o funzioni2.o funzioni2.c 

basic.h

@@ -0,0 +1,28 @@
+#ifndef __BASIC__ 
+#define __BASIC__
+
+#include	<sys/types.h>	/* basic system data types */
+#include	<sys/socket.h>	/* basic socket definitions */
+#include	<sys/time.h>	/* timeval{} for select() */
+#include	<time.h>		/* timespec{} for pselect() */
+#include	<netinet/in.h>	/* sockaddr_in{} and other Internet defns */
+#include	<arpa/inet.h>	/* inet(3) functions */
+#include	<errno.h>
+#include	<fcntl.h>		/* for nonblocking */
+#include	<netdb.h>
+#include	<signal.h>
+#include	<stdio.h>
+#include	<stdlib.h>
+#include	<string.h>
+#include	<sys/stat.h>	/* for S_xxx file mode constants */
+#include	<sys/uio.h>		/* for iovec{} and readv/writev */
+#include	<unistd.h>
+#include	<sys/wait.h>
+#include	<sys/un.h>		/* for Unix domain sockets */
+
+#define MAXLINE 256
+#define PORT  12345
+#define BACKLOG 5 
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+#endif

da_vedere~

@@ -1,13 +0,0 @@
-nel make file
-@echo compilazione di $< in $@
-
-FLAG1= -c
-
-FLAG2 = -o
-
-
-
-clear:
-	rm -f -- per esempio
-
-piu file di giannino per i socket

fun-corso-reti.c

@@ -0,0 +1,107 @@
+#include        "basic.h"
+
+/***************************************************************************
+ *  gestisci_zombie 
+ *  chiama waitpid per eliminare gli zombie. 
+ *  Deve essere registrata con signal per il segnale SIGCHLD 
+ ***************************************************************************/
+void gestisci_zombie(int signo) {
+        pid_t pid;
+        int stat;
+
+        while ( (pid = waitpid(-1,&stat,WNOHANG)) > 0) {
+        printf("Child %d terminated\n",pid);
+        }
+}
+
+
+/***************************************************************************
+ *  reti_read
+ *  legge tutti i dati disponibili nel buffer in una sola volta e poi li
+ *  esamina un byte per volta. La read, invece, legge un byte per volta. 
+ ***************************************************************************/
+ssize_t reti_read(int fd, char *ptr) {
+        static int      read_cnt = 0;  /* numero di byte letti */
+        static char     read_buf[MAXLINE]; /* buffer per mantenere i dati letti */
+        static char     *read_ptr; /* puntatore al prossimo byte da leggere */
+
+        if (read_cnt <= 0) {
+                /* se non ci sono byte disponibili nel buffer chiama la read. */
+                while ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) 
+                      /* se la read fallisce perch<63> non ci sono sufficienti
+                         dati riprova, altrimenti esce. */
+                      if (errno != EINTR)
+                          return(-1);
+                if (read_cnt == 0)
+                      return(0);
+                read_ptr = read_buf;
+        }
+
+        /* legge il prossimo byte dal buffer e decrementa il numero dei byte 
+           disponibili */
+        read_cnt--;
+        *ptr = *read_ptr++;
+        return(1);
+}
+
+
+/***************************************************************************
+ *  reti_readline
+ *  legge un'intera riga utilizzando la reti_read 
+ ***************************************************************************/
+ssize_t reti_readline(int fd, void *vptr, size_t maxlen) {
+        int     n, rc;
+        char    c, *ptr;
+
+        ptr = vptr;
+        for (n = 1; n < maxlen; n++) {
+            if ( (rc = reti_read(fd, &c)) == 1) {
+                *ptr++ = c;
+                if (c == '\n')
+                   break;       /* legge il newline, come la fgets() */
+            } 
+            else 
+                if (rc == 0) {
+                   if (n == 1)
+                        return(0);      /* EOF, non ha letto nulla */
+                   else
+                        break;          /* EOF, ha letto qualcosa */
+                } 
+                else
+                   return(-1);          /* errore, errno settato dalla read() */
+        }
+
+        *ptr = 0;       /* inserisce uno 0 per indicare la fine dell'input, coma la fgets() */
+        return(n);
+        /* restituisce il numero di byte letti */
+}
+
+
+/***************************************************************************
+ *  reti_writen 
+ *  scrive n byte sul descrittore fd. Riprova fino a quando i dati non
+ *  vengono effettivamenti scritti. 
+ ***************************************************************************/
+ssize_t reti_writen(int fd, const void *vptr, size_t n) {
+        size_t          nleft;    /* byte anora da scrivere */
+        ssize_t         nwritten; /* byte scritti dall'ultima write */
+        const char      *ptr;
+
+        ptr = vptr;
+        nleft = n;
+        while (nleft > 0) {
+                if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
+                   if (errno == EINTR)
+                      /* richiama la write se la funzione <20> fallita perch<63>
+                         nel buffer ptr non ci sono sufficienti byte. */
+                      nwritten = 0;
+                   else
+                      return(-1);
+                }
+
+                nleft -= nwritten;
+                ptr   += nwritten;
+        }
+        return(n);
+        /* restituisce il numero di byte scritti. */
+}