Sockets
При модела клиент-сървер сърверът предлага дадена услуга. При инициализация на услугата сърверът създава socket. Socket e софтуерен мрежови интерфейс, който се използва за междумашинна комуникация в мрежовата среда и се определя от IP адреса и от номера на порта, който е число между 0 и 65535 (0-1024 –системни портове).
#include
struct sockaddr {
unsigned short sa_family; // socket address family
char sa_data[14]; // 14 байта е максималният размер за всичките
// различни sockaddr структури
}
struct sockaddr_in {
short sin_family; // адресна фамилия – AF_INET
unsigned short sin_port; // номер на порт
struct in_addr sin_addr; // Интернет адрес
char sin_zero[8]; // padding, за да се изравни размера на структурата // sockaddr_int с този на sockaddr
}
struct in_addr {
unsigned long s_addr;
}
sockaddr е структура, описваща един сокет. sockaddr_in е вид sockaddr, специфична за Интернет сокетите, и може да бъде cast-вана към sockaddr.
#include
in_addr_t inet_addr(const char *cp);
Функцията inet_addr преобразува даден интернет адрес от dot notation в integer. Преобразуваният адрес е в network byte order (байтовете са подредени отляво надясно).
#include
#include
int socket(int domain, int type, int protocol);
Функцията socket инициализира сокет и връща дескриптор на този новосъздаден сокет. Параметърът domain определя адресната фамилия и може да бъде AF_INET (нас това ни интересува, за Интернет адреси), AF_INET6, AF_UNIX, AF_LOCAL, AF_ISO и т.н. Параметърът type определя семантиката на предаваните данни и може да бъде SOCK_STREAM (за TCP/IP), SOCK_DGRAM (за UDP/IP), SOCK_SEQ_PACKET и др. Параметърът protocol определя протокола, който да се използва; за TCP/IP трябва да е 0.
int bind(int sockfd, struct sockaddr *my_addr, int addrlen);
Функцията bind наименува сокета (с дескриптор sockfd), т.е. му задава локален адрес my_addr (указател към структура sockaddr). Параметърът addrlen показва размера на структурата my_addr. При успех връща 0, а при грешка връща -1.
int listen(int sockfd, int backlog);
Чрез функцията listen се посочва, че даден сокет (с дескриптор sockfd) трябва да започне да слуша за конекции. Работи само със сокети от тип SOCK_STREAM и SOCK_SEQ_PACKET (connection-based socket types). Параметърът backlog указва максималната дължина на опашката от чакащи конекции. При успех функцията връща 0, а при грешка връща -1.
int accept(int sockfd, struct sockaddr *addr, int addrlen);
Функцията accept също работи само със сокети, установяващи конекция, т.е. със SOCK_STREAM и SOCK_SEQ_PACKET. Чрез нея сървърът приема чакащи на опашката конекции. sockfd трябва да е сокет, създаден със socket, свързан с bind и слушащ за конекции с listen. Взима се първата заявка за конекция от опашката, създава се нов свързан сокет и се връща файлов дескриптор на този сокет. Новият сокет не е в слушащо състояние. sockfd не се повлиява и остава непроменен. Функцията връща файлов дескриптор на новия сокет при успех и -1 при грешка.
int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
За да се свърже един клиент с даден сървър, трябва да изпълни функцията connect (свързва клиентския сокет с дескриптор sockfd с адреса serv_addr). Функцията връща 0 при успех и -1 при грешка.
1. Прост клиент/ сървър
· Протокол lnc: клиента изпраща цяло число. Сървърът връща на клиента това число, увеличено с едно. Клиента разпечатва увеличеното число.
Прост клиент/сървър
Пример за комуникация между клиент и сървър – клиентът изпраща цяло число; сървърът връща на клиента това число, увеличено с едно; клиентът разпечатва увеличеното число:
/*****************/
/* Simple server */г
/*****************/
/* Make the necessary includes and set up the variables. */
#include
#include
#include
#include
#include
#include
#include
int main()
{
int server_sockfd, client_sockfd;
int server_len, client_len;
struct sockaddr_in server_address;
struct sockaddr_in client_address;
int n;
char buff[1024];
int chislo;
char dest[2];
/* Create an unnamed socket for the server. */
server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
/* Name the socket. */
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = inet_addr("127.0.0.1");
server_address.sin_port = htons(9734);
server_len = sizeof(server_address);
bind(server_sockfd, (struct sockaddr *)&server_address, server_len);
/* Create a connection queue and wait for clients. */
listen(server_sockfd, 5);
while(1) {
printf("server waiting\n");
/* Accept a connection. */
client_len = sizeof(client_address);
client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_address, &client_len);
/* We can now read/write to client on client_sockfd. */
while (n = read(client_sockfd, buff, 1024) > 0) {
write(1, "server receives: ", 17);
write(1, buff, n);
write(1, "\n", 1);
dest[2];
strncpy(dest, buff, n + 1);
dest[n] = 0;
chislo = atoi(dest) + 1;
snprintf(dest, 2, "%d", chislo);
write(client_sockfd, dest, 2);
close(client_sockfd);
}
}
printf("server closes\n");
return 0;
}
/*****************/
/* Simple client */
/*****************/
/* Make the necessary includes and set up the variables. */
#include
#include
#include
#include
#include
#include
int main()
{
int sockfd;
int client_len;
int i;
struct sockaddr_in client_address;
int result;
char ch = '5';
int n;
char buff[1024];
/* Create a socket for the client. */
sockfd = socket(AF_INET, SOCK_STREAM, 0);
/* Name the socket, as agreed with the server. */
client_address.sin_family = AF_INET;
client_address.sin_addr.s_addr = inet_addr("127.0.0.1");
client_address.sin_port = htons(9734);
client_len = sizeof(client_address);
/* Now connect our socket to the server's socket. */
result = connect(sockfd, (struct sockaddr *)&client_address, client_len);
if(result == -1) {
perror("oops: client");
return 1;
}
/* We can now read/write via sockfd. */
printf("client sends: %c\n", ch);
write(sockfd, &ch, 1);
while(n = read(sockfd, buff, 1024) > 0) {
write(1, "client receives: ", 17);
write(1, buff, n);
write(1, "\n", 1);
}
close(sockfd);
return 0;
}
Различните видове компютри използват различни конвенции за подредбата на байтовете в рамките на една дума. Някои слагат най-важния байт първо (т.нар. big-endian подредба), а други – последно (т.нар. little-endian подредба). За да могат да си комуникират машини с различна подредба на байтовете, Интернет протоколите определят конвенция за подредба на байтовете при предаване по мрежата – network byte order. При установяването на Интернет връзка чрез сокети, трябва полетата sin_port и sin_addr от структурата sockaddr_in да са в network byte order. Ако се задават целочислени стойности, трябва да се преобразуват в network byte order. Ако се използва някоя от функциите getservbyname, gethostbyname или inet_addr за получаване на номер на порт и адрес на хост, стойностите вече са в network byte order и няма нужда да се преобразуват допълнително. В противен случай обаче трябва да се използват функциите htons и ntohs за преобразуване на номера на порт, а htonl и ntohl – за преобразуване на IPv4 адреси. Тук h означава host, а n – network; s – short (16-битови числа, портове), l – long (32-битови числа, Интернет адреси).
#include
#include
#include
int gethostname(char *name, size_t namelen);
Чрез функцията gethostname в аргумента name се получава стандартното име на текущата система. namelen указва размера в байтове на масива, към който сочи name. Функцията връща 0 при успех, -1 при грешка.
Чрез структурата hostent се описва даден хост:
#include
struct hostent {
char *h_name; // официалното име на хоста
char **h_aliases; // zero-terminated списък от псевдо-
// ними/алтернативни имена на хоста
int h_addrtype; // адресна фамилия – AF_INET
int h_length; // дължина на адреса в байтове
char **h_addr_list; // zero-terminated списък от адреси
// на хоста в network byte order
}
#define h_addr h_addr_list[0]; // I-ият адрес от h_addr_list
// за backward compatibility
#include
#include
struct hostent *gethostbyname(const char *name);
struct hostent *gethostbyaddr(const char *addr, int addr_len, int addr_type);
Функцията gethostbyname връща указател към структура от тип hostent за даденото име name. Това име name може да бъде или име на хост, или IPv4 адрес в dot notation, или IPv6 адрес в colon notation. Ако е IPv4 или IPv6 адрес, то не се извършва lookup.
Функцията gethostbyaddr връща структура hostent по зададен Интернет адрес. Въпреки че addr е char *, всъщност се иска указател към структура от тип in_addr. addr_len трябва да е sizeof(struct in_addr), т.е. дължината в байтове на този Интернет адрес, а addr_type трябва да е AF_INET.
Както е споменато по-горе, във файла /etc/services се извършва map-ване на портове и протоколи към имена на услуги. Всеки ред от този файл представлява запис за една услуга и има следната структура:
service_name port/protocol [aliases …]
service_name е името на услугата и е case sensitive, т.е. има значение дали буквите са малки или главни. port е десетично число, представляващо номер на порт, на който работи услугата. protocol е име на протокол (например tcp, udp), с който работи услугата, и трябва да съответства със запис от файла protocols. aliases е опционален списък от псевдоними, т.е. алтернативни имена на тази услуга, които също са case sensitive.
Файлът /etc/protocols пък представя наличните протоколи и всеки запис (т.е. всеки ред) от него има следния вид:
protocol number [aliases …]
protocol е името на протокола (ip, tcp, udp, …). number е официалното число, съответстващо на този протокол, такова, каквото се изписва в IP header-а. aliases е опционален списък от псевдоними на протокола.
Структурата servent представя запис за дадена услуга:
#include
struct servent {
char *s_name; // официалното име на услугата
char **s_aliases; // zero-terminated списък от
// алтернативни имена на услугата
int s_port; // номер на порт в network byte order
char *s_proto; // име на протокол
}
struct servent *getservent(void);
struct servent *getservbyname(const char *name,
const char *proto);
struct servent *getservbyport(int port, const char *proto);
Функцията getservent прочита следващия ред от файла /etc/services и връша структура servent, описваща тази услуга. Ако се налага, файлът /etc/services първо се отваря за четене.
Функцията getservbyname връща структура servent за някой ред от файла /etc/services, който съответства на указаното име на услуга name и протокол proto. Ако proto е null, то няма ограничение за протокола.
Функцията getservbyport връща структура servent за някоя услуга от файла /etc/services, която съответства на порта port в network byte order и на протокола proto. Отново, ако proto е null, то протоколът няма значение.
Ако има грешка или се достигне края на файла /etc/services, функциите getservent, getservbyname и getservbyport връщат null.
- Клиент на стандартната услуга daytime
· Клиента получава от сървъра един символен низ с текущото време.(Използвайте името на услугата и името на сървъра.)
Клиент на стандартната услуга daytime
/******************/
/* Daytime client */
/******************/
/* Start with the usual includes and declarations. */
#include
#include
#include
#include
#include
int main(int argc, char *argv[])
{
char *host;
int sockfd;
int len, result;
struct sockaddr_in address;
struct hostent *hostinfo;
struct servent *servinfo;
char buffer[128];
if(argc == 1)
host = "localhost";
else
host = argv[1];
/* Find the host address and report an error if none is found. */
hostinfo = gethostbyname(host);
if(!hostinfo) {
fprintf(stderr, "no host: %s\n", host);
exit(1);
}
/* Check that the daytime service exists on the host. */
servinfo = getservbyname("daytime", "tcp");
if(!servinfo) {
fprintf(stderr,"no daytime service\n");
exit(1);
}
printf("daytime port is %d\n", ntohs(servinfo -> s_port));
/* Create a socket. */
sockfd = socket(AF_INET, SOCK_STREAM, 0);
/* Construct the address for use with connect... */
address.sin_family = AF_INET;
address.sin_port = servinfo -> s_port;
address.sin_addr = *(struct in_addr *)*hostinfo -> h_addr_list;
len = sizeof(address);
/* ...then connect and get the information. */
result = connect(sockfd, (struct sockaddr *)&address, len);
if(result == -1) {
perror("oops: getdate");
exit(1);
}
result = read(sockfd, buffer, sizeof(buffer));
buffer[result] = '\0';
printf("read %d bytes: %s", result, buffer);
close(sockfd);
exit(0);
}
2. Клиент и съврър за отдалечено разпечатване на съдържанието на директория.
· Клиента изпраща име на директория. Той получава от сървъра съдържанието на директорията и го извежда на стандартния си изход.
Клиент и сървър за отдалечено разпечатване на директория
Пример за комуникация между клиент и сървър, при която клиентът изпраща име на директория, получава от сървъра съдържанието на директорията и го извежда на стандартния си изход:
/***************/
/* "ls" server */
/***************/
/* Make the necessary includes and set up the variables. */
#include
#include
#include
#include
#include
#include
int main()
{
int server_sockfd, client_sockfd;
int server_len, client_len;
struct sockaddr_in server_address;
struct sockaddr_in client_address;
int n;
char dir[1024];
/* Create an unnamed socket for the server. */
server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
/* Name the socket. */
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = inet_addr("127.0.0.1");
server_address.sin_port = htons(9999);
server_len = sizeof(server_address);
bind(server_sockfd, (struct sockaddr *)&server_address, server_len);
/* Create a connection queue and wait for clients. */
listen(server_sockfd, 5);
while(1) {
printf("server waiting\n");
/* Accept a connection. */
client_len = sizeof(client_address);
client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_address, &client_len);
/* We can now read/write to client on client_sockfd. */
while (n = read(client_sockfd, dir, 1024) > 0) {
write(1, "server receives: ", 17);
write(1, dir, 3);
write(1, "\n", 1);
close(1);
dup(client_sockfd);
close(client_sockfd);
execlp("ls", "ls", dir, "-l", 0);
}
printf ("server closes\n");
}
return 0;
}
/***************/
/* "ls" client */
/***************/
/* Make the necessary includes and set up the variables. */
#include
#include
#include
#include
#include
#include
int main()
{
int sockfd;
int client_len;
int i;
struct sockaddr_in client_address;
int result, n;
char dir[3] = "bla";
char buff[1024];
/* Create a socket for the client. */
sockfd = socket(AF_INET, SOCK_STREAM, 0);
/* Name the socket, as agreed with the server. */
client_address.sin_family = AF_INET;
client_address.sin_addr.s_addr = inet_addr("127.0.0.1");
client_address.sin_port = htons(9999);
client_len = sizeof(client_address);
/* Now connect our socket to the server's socket. */
result = connect(sockfd, (struct sockaddr *) &client_address, client_len);
if(result == -1) {
perror("oops: client");
return 1;
}
/* We can now read/write via sockfd. */
printf("client sends: %s\n", dir);
write(sockfd, dir, sizeof(dir));
while(n = read(sockfd, buff, 1024) > 0) {
printf("client receives:\n%s", buff);
}
close(sockfd);
return 0;
}
Няма коментари:
Публикуване на коментар