jackbenny/c-programmering-tredje-utgavan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Jack-Benny Persson
2021-10-01 20:24:05 +02:00
commit 860c025165
194 changed files with 4846 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
kapitel18/mygetip.c Normal file
View File

@@ -0,0 +1,61 @@
#define _XOPEN_SOURCE 700
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define MAXSIZE 100
int main(int argc, char *argv[])
{
struct addrinfo hints, *res, *result;
char addrstr[MAXSIZE];
char host[MAXSIZE];
void *ptr;
/* argument till programmet */
if (argc == 2)
{
strncpy(host, argv[1], MAXSIZE);
}
else
{
printf("Please specify a host to lookup\n");
return 1;
}
memset (&hints, 0, sizeof (hints)); /* nolla ut hints */
hints.ai_family = AF_UNSPEC; /* både IPv4 och IPv6 */
hints.ai_socktype = SOCK_STREAM;
/* hämta IP */
if ( getaddrinfo (host, NULL, &hints, &result) != 0 )
{
perror ("getaddrinfo");
return 1;
}
res = result;
while (res) /* loopa över alla IP-adresser */
{
switch (res->ai_family) /* IPv4 eller IPv6 */
{
case AF_INET: /* IPv4 */
ptr = &((struct sockaddr_in *) res->ai_addr)->sin_addr;
break;
case AF_INET6: /* IPv6 */
ptr = &((struct sockaddr_in6 *) res->ai_addr)->sin6_addr;
break;
}
/* omvandla binär-IP till läslig IP-adress */
inet_ntop (res->ai_family, ptr, addrstr, MAXSIZE);
printf ("%s\n", addrstr);
res = res->ai_next; /* nästa IP i listan */
}
freeaddrinfo(result); /* frigör minnet */
return 0;
}

91
kapitel18/tcp-client.c Normal file
View File

@@ -0,0 +1,91 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <signal.h>
#define MAXLINE 1024
#define SIZE 20
int sockfd;
void cleanUp(int signum);
int main(int argc, char* argv[])
{
char ipaddr[SIZE] = "127.0.0.1";
int port = 9000;
char buffer[MAXLINE];
char message[MAXLINE];
struct sockaddr_in servaddr;
int n;
socklen_t len;
/* skapa socket-filen */
if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
{
perror("socket creation failed");
return 1;
}
/* kontrollera om vi angav en adress */
if (argc == 2)
{
strncpy(ipaddr, argv[1], SIZE-1);
}
/* registrera signalhanterarna */
signal(SIGTERM, cleanUp);
signal(SIGABRT, cleanUp);
signal(SIGQUIT, cleanUp);
signal(SIGINT, cleanUp);
signal(SIGPIPE, cleanUp);
/* nolla ut strukturen med adressen */
memset(&servaddr, 0, sizeof(servaddr));
/* information om IP-adress och port */
servaddr.sin_family = AF_INET; /* IPv4 */
servaddr.sin_port = htons(port);
servaddr.sin_addr.s_addr = inet_addr(ipaddr);;
len = sizeof(servaddr); /* storleken på adressen */
if (connect(sockfd, (struct sockaddr *)&servaddr, len) != 0)
{
perror("connect");
return 1;
}
else
{
printf("Connected to the server..\n");
}
/* läs meddelanden och skicka till servern */
while(1)
{
printf("Type your message: ");
fgets(message, sizeof(message), stdin);
/* byt ut radbrytningstecknet mot null */
message[strcspn(message, "\n")] = '\0';
/* skicka meddelandandet till servern med 'sendto' */
write(sockfd, message, sizeof(message));
/* ta emot meddelande från servern med 'recvfrom' */
n = read(sockfd, buffer, sizeof(buffer));
buffer[n] = '\0'; /* avsluta strängen med null */
/* skriv ut svaret från servern */
printf("Server: %s\n", buffer);
}
close(sockfd);
return 0;
}
void cleanUp(int signum)
{
printf("\nQuitting gracefully and closing the socket\n");
close(sockfd);
exit(0);
}

113
kapitel18/tcp-server.c Normal file
View File

@@ -0,0 +1,113 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <signal.h>
#define MAXLINE 1024
#define SIZE 20
int sockfd;
int datafd;
void cleanUp(int signum);
int main(int argc, char* argv[])
{
char ipaddr[SIZE] = "127.0.0.1";
int port = 9000;
char buffer[MAXLINE];
char *confirmation = "Message received";
struct sockaddr_in servaddr, cliaddr;
int n;
socklen_t len;
/* skapa socket */
if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
{
perror("socket creation failed");
return 1;
}
/* kontrollera om vi angav en lyssnar-adress */
if (argc == 2)
{
strncpy(ipaddr, argv[1], SIZE-1);
}
/* registrera signalhanterarna */
signal(SIGTERM, cleanUp);
signal(SIGABRT, cleanUp);
signal(SIGQUIT, cleanUp);
signal(SIGINT, cleanUp);
signal(SIGPIPE, cleanUp); /* när klienten kopplar från servern
får den en SIGPIPE */
/* nolla adress-strukturerna innan vi använder dem */
memset(&servaddr, 0, sizeof(servaddr));
memset(&cliaddr, 0, sizeof(cliaddr));
/* information om IP-adress och port */
servaddr.sin_family = AF_INET; /* IPv4 */
servaddr.sin_addr.s_addr = inet_addr(ipaddr);
servaddr.sin_port = htons(port);
/* knyt ihop vår socket med adressen */
if ( bind(sockfd, (const struct sockaddr *)&servaddr,
sizeof(servaddr)) < 0 )
{
perror("bind");
return 1;
}
/* lyssna efter inkommande anslutningar */
if ( (listen(sockfd, 5)) != 0 )
{
perror("listen");
return 1;
}
else
{
printf("Server listening...\n");
}
len = sizeof(cliaddr); /* storleken på adressen */
/* acceptera inkommande anslutning */
datafd = accept(sockfd, (struct sockaddr *)&cliaddr, &len);
if (datafd < 0)
{
perror("accept");
return 1;
}
else
{
printf("Server accepted connection...\n");
}
/* ta emot paket och loopa tills klienten kopplar från */
while(1)
{
n = read(datafd, buffer, sizeof(buffer));
/* skriv ut meddelandet vi tog emot från klienten och
skicka en bekräftelse */
buffer[n] = '\0'; /* avsluta strängen med null */
printf("Client: %s\n", buffer);
write(datafd, confirmation, strlen(confirmation)+1);
printf("Confirmation message sent to client\n");
}
/* vi når aldrig hit - men fall i fall */
close(sockfd);
close(datafd);
return 0;
}
void cleanUp(int signum)
{
printf("Quitting gracefully and closing the socket\n");
close(sockfd);
close(datafd);
exit(0);
}

85
kapitel18/udp-client.c Normal file
View File

@@ -0,0 +1,85 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <signal.h>
#define MAXLINE 1024
#define SIZE 20
int sockfd;
void cleanUp(int signum);
int main(int argc, char* argv[])
{
char ipaddr[SIZE] = "127.0.0.1";
int port = 9000;
char buffer[MAXLINE];
char message[MAXLINE];
struct sockaddr_in servaddr;
int n;
socklen_t len;
/* skapa socket-filen */
if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 )
{
perror("socket creation failed");
return 1;
}
/* kontrollera om vi angav en adress */
if (argc == 2)
{
strncpy(ipaddr, argv[1], SIZE-1);
}
/* registrera signalhanterarna */
signal(SIGTERM, cleanUp);
signal(SIGABRT, cleanUp);
signal(SIGQUIT, cleanUp);
signal(SIGINT, cleanUp);
/* nolla ut strukturen med adressen */
memset(&servaddr, 0, sizeof(servaddr));
/* information om IP-adress och port */
servaddr.sin_family = AF_INET; /* IPv4 */
servaddr.sin_port = htons(port);
servaddr.sin_addr.s_addr = inet_addr(ipaddr);;
len = sizeof(servaddr); /* storleken på adressen */
/* läs meddelanden och skicka till servern */
while(1)
{
printf("Type your message: ");
fgets(message, sizeof(message), stdin);
/* byt ut radbrytningstecknet mot null */
message[strcspn(message, "\n")] = '\0';
/* skicka meddelandandet till servern med 'sendto' */
sendto(sockfd, (const char *)message, strlen(message),
0, (const struct sockaddr *) &servaddr, len);
/* ta emot meddelande från servern med 'recvfrom' */
n = recvfrom(sockfd, (char *)buffer, MAXLINE,
MSG_WAITALL, (struct sockaddr *) &servaddr, &len);
buffer[n] = '\0'; /* avsluta strängen med null */
/* skriv ut svaret från servern */
printf("Server: %s\n", buffer);
}
/* vi når aldrig hit - men fall i fall */
close(sockfd);
return 0;
}
void cleanUp(int signum)
{
printf("\nQuitting gracefully and closing the socket\n");
close(sockfd);
exit(0);
}

90
kapitel18/udp-server.c Normal file
View File

@@ -0,0 +1,90 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <signal.h>
#define MAXLINE 1024
#define SIZE 20
int sockfd;
void cleanUp(int signum);
int main(int argc, char* argv[])
{
char ipaddr[SIZE] = "127.0.0.1";
int port = 9000;
char buffer[MAXLINE];
char *confirmation = "Message received";
struct sockaddr_in servaddr, cliaddr;
int n;
socklen_t len;
/* skapa socket */
if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 )
{
perror("socket creation failed");
return 1;
}
/* kontrollera om vi angav en lyssnar-adress */
if (argc == 2)
{
strncpy(ipaddr, argv[1], SIZE-1);
}
/* registrera signalhanterarna */
signal(SIGTERM, cleanUp);
signal(SIGABRT, cleanUp);
signal(SIGQUIT, cleanUp);
signal(SIGINT, cleanUp);
/* nolla adress-strukturerna innan vi använder dem */
memset(&servaddr, 0, sizeof(servaddr));
memset(&cliaddr, 0, sizeof(cliaddr));
/* information om IP-adress och port */
servaddr.sin_family = AF_INET; /* IPv4 */
servaddr.sin_addr.s_addr = inet_addr(ipaddr);
servaddr.sin_port = htons(port);
/* knyt ihop vår socket med adressen */
if ( bind(sockfd, (const struct sockaddr *)&servaddr,
sizeof(servaddr)) < 0 )
{
perror("bind failed");
return 1;
}
len = sizeof(cliaddr); /* storleken på adressen */
/* ta emot udp-paket och loopa för evigt */
while(1)
{
n = recvfrom(sockfd, (char *)buffer, MAXLINE,
MSG_WAITALL, ( struct sockaddr *) &cliaddr,
&len);
buffer[n] = '\0'; /* avsluta strängen med null */
/* skriv ut meddelandet vi tog emot från klienten och skicka en
bekräftelse */
printf("Client: %s\n", buffer);
sendto(sockfd, (const char *)confirmation,
strlen(confirmation), 0,
(const struct sockaddr *) &cliaddr, len);
printf("Confirmation message sent to client\n");
}
/* vi når aldrig hit - men fall i fall */
close(sockfd);
return 0;
}
void cleanUp(int signum)
{
printf("Quitting gracefully and closing the socket\n");
close(sockfd);
exit(0);
}