ഗുഡ് ആഫ്റ്റർനൂൺ "ലിനക്സ് എപിഐ" എന്ന പുസ്തകം ഞാൻ നിങ്ങളുടെ ശ്രദ്ധയിൽപ്പെടുത്തുന്നു. സമഗ്രമായ ഒരു ഗൈഡ്" (പുസ്തകത്തിന്റെ വിവർത്തനം ലിനക്സ് പ്രോഗ്രാമിംഗ് ഇന്റർഫേസ്). പ്രസാധകന്റെ വെബ്‌സൈറ്റിലും നിങ്ങൾ പ്രൊമോഷണൽ കോഡ് പ്രയോഗിക്കുകയാണെങ്കിൽ അത് ഓർഡർ ചെയ്യാവുന്നതാണ് LinuxAPI , നിങ്ങൾക്ക് 30% കിഴിവ് ലഭിക്കും.

റഫറൻസിനായി പുസ്തകത്തിൽ നിന്നുള്ള ഉദ്ധരണി:

സോക്കറ്റുകൾ: സെർവർ ആർക്കിടെക്ചർ

ഈ അധ്യായത്തിൽ, ആവർത്തനപരവും സമാന്തരവുമായ സെർവറുകൾ രൂപകൽപ്പന ചെയ്യുന്നതിന്റെ അടിസ്ഥാനകാര്യങ്ങൾ ഞങ്ങൾ ചർച്ച ചെയ്യും, കൂടാതെ ഇൻറർനെറ്റ് സെർവർ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നത് എളുപ്പമാക്കുന്ന inetd എന്ന പ്രത്യേക ഡെമണും നോക്കാം.

ആവർത്തനപരവും സമാന്തരവുമായ സെർവറുകൾ

രണ്ട് സാധാരണ സോക്കറ്റ് അടിസ്ഥാനമാക്കിയുള്ള നെറ്റ്‌വർക്ക് സെർവർ ആർക്കിടെക്ചറുകൾ ഉണ്ട്:

• ആവർത്തനം: സെർവർ ഒരു സമയം ക്ലയന്റുകൾക്ക് സേവനം നൽകുന്നു, ആദ്യം ഒരു ക്ലയന്റിൽ നിന്നുള്ള ഒരു അഭ്യർത്ഥന (അല്ലെങ്കിൽ നിരവധി അഭ്യർത്ഥനകൾ) പ്രോസസ്സ് ചെയ്യുന്നു, തുടർന്ന് അടുത്തതിലേക്ക് നീങ്ങുന്നു;

• സമാന്തരം: ഒന്നിലധികം ക്ലയന്റുകൾക്ക് ഒരേസമയം സേവനം നൽകുന്നതിനാണ് സെർവർ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.

FIFO ക്യൂകളെ അടിസ്ഥാനമാക്കിയുള്ള ഒരു ആവർത്തന സെർവറിന്റെ ഒരു ഉദാഹരണം ഇതിനകം തന്നെ സെക്ഷൻ 44.8-ൽ അവതരിപ്പിച്ചിട്ടുണ്ട്.

ക്ലയന്റ് അഭ്യർത്ഥനകൾ വളരെ വേഗത്തിൽ പ്രോസസ്സ് ചെയ്യാൻ കഴിയുന്ന സാഹചര്യങ്ങളിൽ മാത്രമേ ആവർത്തന സെർവറുകൾ അനുയോജ്യമാകൂ, കാരണം ഓരോ ക്ലയന്റിനും മുന്നിലുള്ള മറ്റേതെങ്കിലും ക്ലയന്റുകൾക്ക് സേവനം നൽകുന്നതുവരെ കാത്തിരിക്കാൻ നിർബന്ധിതരാകുന്നു. ഒരു ക്ലയന്റും സെർവറും തമ്മിലുള്ള ഒറ്റ അഭ്യർത്ഥനകളുടെയും പ്രതികരണങ്ങളുടെയും കൈമാറ്റമാണ് ഈ സമീപനത്തിനുള്ള ഒരു സാധാരണ ഉപയോഗ കേസ്.

ഓരോ അഭ്യർത്ഥനയും പ്രോസസ്സ് ചെയ്യുന്നതിന് ഗണ്യമായ സമയമെടുക്കുന്ന സന്ദർഭങ്ങളിലോ ക്ലയന്റും സെർവറും ദീർഘമായ സന്ദേശ കൈമാറ്റങ്ങളിൽ ഏർപ്പെടുന്ന സാഹചര്യത്തിലോ സമാന്തര സെർവറുകൾ അനുയോജ്യമാണ്. ഈ അധ്യായത്തിൽ, സമാന്തര സെർവറുകൾ രൂപകൽപന ചെയ്യുന്നതിനുള്ള പരമ്പരാഗത (ഏറ്റവും ലളിതമായ) മാർഗത്തിൽ ഞങ്ങൾ പ്രധാനമായും ശ്രദ്ധ കേന്ദ്രീകരിക്കും, അതായത് ഓരോ പുതിയ ക്ലയന്റിനും ഒരു പ്രത്യേക ചൈൽഡ് പ്രോസസ് സൃഷ്ടിക്കുക എന്നതാണ്. ഈ പ്രക്രിയ ക്ലയന്റിനെ സേവിക്കുന്നതിനുള്ള എല്ലാ പ്രവർത്തനങ്ങളും നിർവഹിക്കുകയും തുടർന്ന് അവസാനിക്കുകയും ചെയ്യുന്നു. ഈ പ്രക്രിയകൾ ഓരോന്നും സ്വതന്ത്രമായി പ്രവർത്തിക്കുന്നതിനാൽ, ഒന്നിലധികം ക്ലയന്റുകളെ ഒരേസമയം സേവിക്കുന്നത് സാധ്യമാണ്. പ്രധാന സെർവർ പ്രക്രിയയുടെ (രക്ഷാകർതൃ) പ്രധാന ദൌത്യം ഓരോ പുതിയ ക്ലയന്റിനും ഒരു പ്രത്യേക കുട്ടിയെ സൃഷ്ടിക്കുക എന്നതാണ് (പകരം, പ്രോസസ്സുകൾക്ക് പകരം എക്സിക്യൂഷൻ ത്രെഡുകൾ സൃഷ്ടിക്കാൻ കഴിയും).

ഇനിപ്പറയുന്ന വിഭാഗങ്ങളിൽ, ആവർത്തനപരവും സമാന്തരവുമായ ഇന്റർനെറ്റ് ഡൊമെയ്ൻ സോക്കറ്റ് സെർവറുകളുടെ ഉദാഹരണങ്ങൾ ഞങ്ങൾ നോക്കും. ഈ രണ്ട് സെർവറുകളും എക്കോ സേവനത്തിന്റെ (RFC 862) ലളിതമായ പതിപ്പ് നടപ്പിലാക്കുന്നു, അത് ഒരു ക്ലയന്റ് അയച്ച സന്ദേശത്തിന്റെ പകർപ്പ് തിരികെ നൽകുന്നു.

ആവർത്തന UDP സെർവർ എക്കോ

ഇതിലും അടുത്ത വിഭാഗത്തിലും ഞങ്ങൾ എക്കോ സേവനത്തിനായി സെർവറുകൾ അവതരിപ്പിക്കും. ഇത് പോർട്ട് നമ്പർ 7-ൽ ലഭ്യമാണ്, കൂടാതെ UDP, TCP എന്നിവയിലും പ്രവർത്തിക്കുന്നു (ഈ പോർട്ട് റിസർവ് ചെയ്‌തതാണ്, അതിനാൽ എക്കോ സെർവർ അഡ്മിനിസ്‌ട്രേറ്റർ പ്രത്യേകാവകാശങ്ങളോടെ പ്രവർത്തിക്കണം).

എക്കോ യുഡിപി സെർവർ തുടർച്ചയായി ഡാറ്റാഗ്രാമുകൾ വായിക്കുകയും അയച്ചയാൾക്ക് അവയുടെ പകർപ്പുകൾ തിരികെ നൽകുകയും ചെയ്യുന്നു. സെർവറിന് ഒരു സമയം ഒരു സന്ദേശം മാത്രമേ പ്രോസസ്സ് ചെയ്യേണ്ടതുള്ളൂ എന്നതിനാൽ, ഒരു ആവർത്തന ആർക്കിടെക്ചർ മതിയാകും. സെർവറുകളുടെ ഹെഡ്ഡർ ഫയൽ ലിസ്റ്റിംഗ് 56.1-ൽ കാണിച്ചിരിക്കുന്നു.

പട്ടിക 56.1. id_echo_sv.c, id_echo_cl.c എന്നീ പ്രോഗ്രാമുകൾക്കുള്ള ഹെഡ്ഡർ ഫയൽ

#include "inet_sockets.h" /* ഞങ്ങളുടെ സോക്കറ്റ് ഫംഗ്‌ഷനുകൾ പ്രഖ്യാപിക്കുന്നു */
#"tlpi_hdr.h" ഉൾപ്പെടുത്തുക

#സേവനം "എക്കോ" നിർവചിക്കുക /* UDP സേവന നാമം */

#നിർവ്വചിക്കുക BUF_SIZE 500 /* ഡാറ്റാഗ്രാമുകളുടെ പരമാവധി വലുപ്പം
ക്ലയന്റിനും സെർവറിനും വായിക്കാൻ കഴിയും */
_____________________________________________________________________________________________________________________________________________

ലിസ്റ്റിംഗ് 56.2 സെർവർ നടപ്പിലാക്കൽ കാണിക്കുന്നു. ഇനിപ്പറയുന്ന പോയിന്റുകൾ ശ്രദ്ധിക്കേണ്ടതാണ്:

• സെർവറിനെ ഡെമൺ മോഡിലേക്ക് മാറ്റുന്നതിന്, സെക്ഷൻ 37.2-ൽ നിന്ന് ഞങ്ങൾ becomeDaemon() ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നു;

• പ്രോഗ്രാം കൂടുതൽ ഒതുക്കമുള്ളതാക്കുന്നതിന്, സെക്ഷൻ 55.12-ൽ വികസിപ്പിച്ച ഇന്റർനെറ്റ് ഡൊമെയ്ൻ സോക്കറ്റുകളിൽ പ്രവർത്തിക്കാൻ ഞങ്ങൾ ലൈബ്രറി ഉപയോഗിക്കുന്നു;

• സെർവറിന് ക്ലയന്റിന് ഒരു പ്രതികരണം നൽകാൻ കഴിയുന്നില്ലെങ്കിൽ, അത് syslog() കോൾ ഉപയോഗിച്ച് ലോഗിലേക്ക് ഒരു സന്ദേശം എഴുതുന്നു.

ഒരു യഥാർത്ഥ ആപ്ലിക്കേഷനിൽ, syslog() ഉപയോഗിച്ച് ലോഗിംഗ് സന്ദേശങ്ങളുടെ ആവൃത്തിയിൽ ഞങ്ങൾ ചില പരിധികൾ ഏർപ്പെടുത്തും. ഒരു ആക്രമണകാരി സിസ്റ്റം ലോഗ് കവിഞ്ഞൊഴുകാനുള്ള സാധ്യത ഇത് ഇല്ലാതാക്കും. കൂടാതെ, syslog() ലേക്കുള്ള ഓരോ കോളും വളരെ ചെലവേറിയതാണെന്ന് മറക്കരുത്, കാരണം അത് സ്ഥിരസ്ഥിതിയായി fsync() ഉപയോഗിക്കുന്നു.

പട്ടിക 56.2. UDP എക്കോ സേവനം നടപ്പിലാക്കുന്ന ആവർത്തന സെർവർ

_________________________________________________________________ സോക്കറ്റുകൾ/id_echo_sv.c
#ഉൾപ്പെടുന്നു
#"id_echo.h" ഉൾപ്പെടുത്തുക
#ഉൾപ്പെടുത്തുക "become_daemon.h"

int
പ്രധാന(int argc, char *argv[])
{
int sfd;
ssize_t numRead;
സോക്ക്ലെൻ_ടി ലെൻ;
സ്ട്രക്റ്റ് sockaddr_storage claddr;
ചാർ ബഫ്[BUF_SIZE];
char addrStr[IS_ADDR_STR_LEN];

എങ്കിൽ (ഡേമൻ (0) == -1)
errExit("becomeDaemon");

sfd = inetBind(SERVICE, SOCK_DGRAM, NULL);
എങ്കിൽ (sfd == -1) {
syslog(LOG_ERR, "സെർവർ സോക്കറ്റ് (%s) സൃഷ്ടിക്കാൻ കഴിഞ്ഞില്ല",
strerror (errno));
പുറത്തുകടക്കുക (EXIT_FAILURE);

/* ഡാറ്റാഗ്രാമുകൾ സ്വീകരിക്കുകയും അവയുടെ പകർപ്പുകൾ അയയ്ക്കുന്നവർക്ക് തിരികെ നൽകുകയും ചെയ്യുക */
}
വേണ്ടി (;;) {
ലെൻ = sizeof(sckaddr_storage);
numRead = recvfrom(sfd, buf, BUF_SIZE, 0, (struct sockaddr *) &claddr, &len);

എങ്കിൽ (എണ്ണം വായിക്കുക == -1)
errExit("recvfrom");
എങ്കിൽ (sendto(sfd, buf, numRead, 0, (struct sockaddr *) &claddr, len)
!= numRead)
syslog(LOG_WARNING, "%s (%s) നുള്ള പ്രതികരണം പ്രതിധ്വനിക്കുന്നതിൽ പിശക്",
inetAddressStr((സ്‌ട്രക്‌റ്റ് സോക്കാഡ്‌ആർ *) &ക്ലാഡ്‌ഡർ, ലെൻ,
addrStr, IS_ADDR_STR_LEN),
strerror (errno));
}
}
_________________________________________________________________ സോക്കറ്റുകൾ/id_echo_sv.c

സെർവറിന്റെ പ്രവർത്തനം പരിശോധിക്കുന്നതിന്, ഞങ്ങൾ ലിസ്റ്റിംഗ് 56.3-ൽ നിന്നുള്ള പ്രോഗ്രാം ഉപയോഗിക്കുന്നു. സെക്ഷൻ 55.12-ൽ വികസിപ്പിച്ച ഇന്റർനെറ്റ് ഡൊമെയ്ൻ സോക്കറ്റുകളിൽ പ്രവർത്തിക്കാൻ ഇത് ലൈബ്രറിയും ഉപയോഗിക്കുന്നു. ആദ്യത്തെ കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് എന്ന നിലയിൽ, ക്ലയന്റ് പ്രോഗ്രാം സെർവർ സ്ഥിതിചെയ്യുന്ന നെറ്റ്‌വർക്ക് നോഡിന്റെ പേര് എടുക്കുന്നു. ക്ലയന്റ് ഒരു ലൂപ്പിലേക്ക് പ്രവേശിക്കുന്നു, അവിടെ അവശേഷിക്കുന്ന ഓരോ ആർഗ്യുമെന്റുകളും പ്രത്യേക ഡാറ്റാഗ്രാമുകളായി സെർവറിലേക്ക് അയയ്ക്കുന്നു, തുടർന്ന് സെർവറിൽ നിന്ന് ലഭിക്കുന്ന ഡാറ്റാഗ്രാമുകൾ പ്രതികരണമായി വായിക്കുകയും പ്രിന്റ് ചെയ്യുകയും ചെയ്യുന്നു.

പട്ടിക 56.3. UDP എക്കോ സേവനത്തിനുള്ള ക്ലയന്റ്

#"id_echo.h" ഉൾപ്പെടുത്തുക

int
പ്രധാന(int argc, char *argv[])
{
int sfd, j;
വലിപ്പം_ടി ലെൻ;
ssize_t numRead;
ചാർ ബഫ്[BUF_SIZE];

എങ്കിൽ (argc < 2 || strcmp(argv[1], "--help") == 0)
UseErr("%s ഹോസ്റ്റ് msg...n", argv[0]);

/* ആദ്യത്തെ കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റിനെ അടിസ്ഥാനമാക്കി സെർവർ വിലാസം രൂപപ്പെടുത്തുക */
sfd = inetConnect(argv[1], SERVICE, SOCK_DGRAM);
എങ്കിൽ (sfd == -1)
മാരകമായ ("സെർവർ സോക്കറ്റിലേക്ക് ബന്ധിപ്പിക്കാൻ കഴിഞ്ഞില്ല");

/* ശേഷിക്കുന്ന ആർഗ്യുമെന്റുകൾ പ്രത്യേക ഡാറ്റാഗ്രാമുകളുടെ രൂപത്തിൽ സെർവറിലേക്ക് അയയ്ക്കുക */
വേണ്ടി (j = 2; j < argc; j++) {
ലെൻ = strlen (argv[j]);
എങ്കിൽ (എഴുതുക(sfd, argv[j], len) != len)
മാരകമായ ("ഭാഗിക/പരാജയപ്പെട്ട എഴുത്ത്");

numRead = റീഡ് (sfd, buf, BUF_SIZE);
എങ്കിൽ (എണ്ണം വായിക്കുക == -1)
errExit ("വായിക്കുക");
printf("[%ld bytes] %.*sn", (നീണ്ട) numRead, (int) numRead, buf);
}
പുറത്തുകടക്കുക (EXIT_SUCCESS);
}
_________________________________________________________________ സോക്കറ്റുകൾ/id_echo_cl.c

സെർവർ പ്രവർത്തിപ്പിക്കുമ്പോൾ നമ്മൾ കാണുന്നതിന്റെ ഒരു ഉദാഹരണവും രണ്ട് ക്ലയന്റ് സംഭവങ്ങളും ചുവടെയുണ്ട്:

$su // ഒരു റിസർവ്ഡ് പോർട്ടിലേക്ക് ബന്ധിപ്പിക്കുന്നതിന് പ്രത്യേകാവകാശങ്ങൾ ആവശ്യമാണ്
രഹസ്യവാക്ക്:
# ./id_echo_sv // സെർവർ പശ്ചാത്തല മോഡിലേക്ക് പോകുന്നു
# പുറത്തുകടക്കുക // അഡ്മിനിസ്ട്രേറ്റർ അവകാശങ്ങൾ ഉപേക്ഷിക്കുക
$ ./id_echo_cl ലോക്കൽഹോസ്റ്റ് ഹലോ വേൾഡ് // ഈ ക്ലയന്റ് രണ്ട് ഡാറ്റാഗ്രാമുകൾ അയയ്ക്കുന്നു
[5 ബൈറ്റുകൾ] ഹലോ // സെർവറിൽ നിന്ന് ലഭിച്ച പ്രതികരണം ക്ലയന്റ് പ്രദർശിപ്പിക്കുന്നു
[5 ബൈറ്റുകൾ] ലോകം
$ ./id_echo_cl ലോക്കൽഹോസ്റ്റ് വിട // ഈ ക്ലയന്റ് ഒരു ഡാറ്റഗ്രാം അയയ്ക്കുന്നു
[7 ബൈറ്റുകൾ] വിട

ഞാൻ നിങ്ങൾക്ക് നല്ല വായന ആശംസിക്കുന്നു)

അവലംബം: linux.org.ru