క్లయింట్-సర్వర్ మోడల్‌ను ఏర్పాటు చేస్తోంది
సాకెట్ ప్రోగ్రామింగ్ అనేది సాకెట్లను ఉపయోగించి సర్వర్ మరియు క్లయింట్ మధ్య కమ్యూనికేషన్ ఛానెల్‌ని నిర్మించే ప్రక్రియ. కింది ఉదాహరణ కోడ్‌లో, క్లయింట్ సర్వర్‌తో పరిచయాన్ని ప్రారంభిస్తుంది మరియు క్లయింట్ కనెక్షన్‌లను ఆమోదించడానికి సర్వర్ సెటప్ చేయబడింది. నెట్‌వర్క్ కమ్యూనికేషన్‌లో వాటి ప్రధాన పనిని ప్రదర్శించడం ద్వారా సర్వర్ మరియు క్లయింట్ కోడ్ విభాగాలను అర్థం చేసుకుందాం. కిందిది సర్వర్ సైడ్ కోడ్. ముందుగా కోడ్‌ని చూసి, ఆపై పాయింట్‌లవారీగా కోడ్‌ని వివరంగా వివరిస్తాము.
1. సర్వర్ సైడ్
మోడల్ యొక్క సర్వర్ వైపు కోడ్ క్రింది వాటిలో ఇవ్వబడింది. కోడ్‌లో ఏమి జరుగుతుందో చూద్దాం:
#
#
#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
#పోర్ట్ 8080ని నిర్వచించండి
#MAX_BUF_SIZE 1024ని నిర్వచించండి
int ప్రధాన ( ) {
int ser_socket, cli_socket ;
నిర్మాణం sockaddr_in ser_address, cli_address ;
చార్ buf [ MAX_BUF_SIZE ] = { 0 } ;
ఉంటే ( ( ser_socket = సాకెట్ ( AF_INET, SOCK_STREAM, 0 ) ) == - 1 ) {
తప్పు ( 'సాకెట్ సృష్టిలో లోపం' ) ;
బయటకి దారి ( EXIT_FAILURE ) ;
}
ser_చిరునామా. పాపం_కుటుంబం = OF_INET ;
ser_చిరునామా. sin_addr . s_addr = INADDR_ఏదైనా ;
ser_చిరునామా. sin_port = htons ( పోర్ట్ ) ;
ఉంటే ( కట్టు ( బీ_సాకెట్, ( నిర్మాణం sockaddr * ) & సెర్_చిరునామా, పరిమాణం ( సెర్_చిరునామా ) ) == - 1 ) {
తప్పు ( 'బంధంలో వైఫల్యం' ) ;
బయటకి దారి ( EXIT_FAILURE ) ;
}
ఉంటే ( వినండి ( బీ_సాకెట్, 3 ) == - 1 ) {
తప్పు ( 'వినడంలో విఫలమైంది' ) ;
బయటకి దారి ( EXIT_FAILURE ) ;
}
కోట్ << 'పోర్టులో సర్వర్ వినడం' << పోర్ట్ << '... \n ' ;
socklen_t cli_address_len = పరిమాణం ( cli_చిరునామా ) ;
ఉంటే ( ( cli_socket = అంగీకరించు ( బీ_సాకెట్, ( నిర్మాణం sockaddr * ) & cli_చిరునామా, & cli_address_len ) ) == - 1 ) {
తప్పు ( 'అంగీకరించడంలో విఫలమైంది' ) ;
బయటకి దారి ( EXIT_FAILURE ) ;
}
చదవండి ( cli_socket, buf, MAX_BUF_SIZE ) ;
కోట్ << 'క్లయింట్ సందేశం:' << buf << endl ;
పంపండి ( cli_socket, 'సర్వర్ సందేశం' , strlen ( 'సర్వర్ సందేశం' ) , 0 ) ;
దగ్గరగా ( cli_socket ) ;
దగ్గరగా ( ser_socket ) ;
తిరిగి 0 ;
}
ఇచ్చిన ఉదాహరణ C++ ప్రోగ్రామ్ యొక్క సర్వర్-సైడ్ కోడ్. ఈ కోడ్ ఒక నిర్దిష్ట పోర్ట్‌లో కనెక్షన్‌ల కోసం వినడానికి సాధారణ TCP సర్వర్ కోసం పని చేస్తుంది. కనెక్షన్ విజయవంతంగా సృష్టించబడినప్పుడు, సర్వర్ క్లయింట్ నుండి పంపబడిన సందేశాన్ని అందుకుంటుంది. ఆ తర్వాత, అది కన్సోల్‌లో ప్రింట్ చేసి క్లయింట్‌కు ప్రతిస్పందన సందేశాన్ని పంపుతుంది. కోడ్ యొక్క ప్రతి పంక్తిని అర్థం చేసుకుందాం.
ప్రోగ్రామ్ లైబ్రరీలతో సహా ప్రారంభమవుతుంది: ప్రామాణిక ఇన్‌పుట్/అవుట్‌పుట్ నిర్వచనాల కోసం “iostream”, స్ట్రింగ్ హ్యాండ్లింగ్ ఫంక్షన్‌ల కోసం “cstring”, POSIX ఆపరేటింగ్ సిస్టమ్ APIకి యాక్సెస్‌ను అందించడానికి “unistd.h” మరియు “arpa/inet.h” ఇంటర్నెట్ కార్యకలాపాలను నిర్వహించండి. “#define PORT 8080” స్టేట్‌మెంట్ అంటే ఇది సర్వర్ వినే పోర్ట్ నంబర్ 8080ని నిర్వచిస్తుంది. “#define MAX_BUF_SIZE 1024” అంటే ఇన్‌కమింగ్ డేటాకు గరిష్ట బఫర్ పరిమాణం 1024.
ప్రధాన ఫంక్షన్‌లో, సర్వర్ మరియు క్లయింట్ రెండింటినీ సూచించడానికి “ser_socket” మరియు “cli_socket” అనే రెండు వేరియబుల్స్ ప్రారంభించబడ్డాయి. “sockaddr_in”, “ser_address” మరియు “cli_address” రకం “struct” అనే ఇతర మూడు వేరియబుల్‌లు సర్వర్ మరియు క్లయింట్ కోసం చిరునామా నిర్మాణాలుగా ప్రారంభించబడ్డాయి. ఆ తర్వాత, క్లయింట్ నుండి వచ్చే డేటాను స్టోర్ చేసే “బఫ్” అనే బఫర్ ప్రారంభించబడుతుంది.
'if' కండిషన్‌లోని సాకెట్() ఫంక్షన్ కొత్త TCP సాకెట్‌ను సృష్టిస్తుంది. AF_INET IPv4ని సూచిస్తుంది, SOCK_STREAM అనేది కనెక్షన్-ఆధారిత మరియు విశ్వసనీయ TCP సాకెట్‌ని సూచిస్తుంది, డిఫాల్ట్ TCP ప్రోటోకాల్‌ను ఎంచుకోవడానికి చివరి ఆర్గ్యుమెంట్ 0 ఇవ్వబడుతుంది, INADDR_ANY ఏదైనా IP చిరునామాపై కనెక్షన్‌లను అంగీకరిస్తుంది మరియు htons (PORT) పోర్ట్ నంబర్‌ను దీని నుండి మారుస్తుంది నెట్‌వర్క్ బైట్ ఆర్డర్‌కి హోస్ట్ బైట్ ఆర్డర్.
ప్రతిదీ సరిగ్గా నిర్వచించబడినందున, ఇచ్చిన పోర్ట్‌లో సర్వర్‌ను లిస్టర్‌గా సెటప్ చేయడం మరియు ఏదైనా నెట్‌వర్క్ ఇంటర్‌ఫేస్‌లో కనెక్షన్‌లను అంగీకరించడం తదుపరి దశ. బైండ్() పద్ధతి ద్వారా “ser_address”లో సమాచారంతో సాకెట్ ఇవ్వబడుతుంది. మేము లోపాన్ని ప్రింట్ చేస్తాము మరియు బైండింగ్ విఫలమైతే ప్రక్రియను ముగించాము. అంగీకరించు() ఫంక్షన్ క్లయింట్‌తో కనెక్షన్ కోసం ఒక కొత్త సాకెట్‌ను తెరుస్తుంది, అయితే వినండి() ఫంక్షన్ ఇన్‌కమింగ్ కనెక్షన్‌ల కోసం వేచి ఉండమని సర్వర్‌ని నిర్దేశిస్తుంది. అంగీకరించు() ఫంక్షన్ విఫలమైతే, దోష సందేశం ముద్రించబడుతుంది మరియు ఫంక్షన్ నిష్క్రమిస్తుంది.
తరువాత, సర్వర్ 'బఫ్' బఫర్‌లో రీడ్() ఫంక్షన్‌తో క్లయింట్ సందేశాన్ని చదివి, ఆపై దానిని కన్సోల్‌కు ప్రింట్ చేస్తుంది. సెండ్() ఫంక్షన్ క్లయింట్‌కు ప్రతిస్పందనగా సందేశాన్ని పంపడానికి సర్వర్చే ఉపయోగించబడుతుంది. చివరగా, క్లోజ్() ఉపయోగించి, సర్వర్ క్లయింట్ యొక్క సాకెట్‌ను మూసివేస్తుంది, ప్రోగ్రామ్‌ను ముగించడం వలన అన్ని కనెక్షన్‌లు సరిగ్గా మూసివేయబడతాయి మరియు డేటా ఉల్లంఘన సంభావ్యత ఉండదు.
2. క్లయింట్ వైపు
ఇప్పుడు, క్లయింట్ మోడల్‌లో ఏమి జరుగుతుందో చూద్దాం:
##
#
#
#పోర్ట్ 8080ని నిర్వచించండి
#SERVER_IP '127.0.0.1'ని నిర్వచించండి
int ప్రధాన ( ) {
int cli_socket ;
నిర్మాణం sockaddr_in ser_address ;
స్థిరంగా చార్ * సందేశం = 'క్లయింట్ శుభాకాంక్షలు పంపుతున్నాడు!' ;
ఉంటే ( ( cli_socket = సాకెట్ ( AF_INET, SOCK_STREAM, 0 ) ) == - 1 ) {
తప్పు ( 'సాకెట్ సృష్టిలో లోపం' ) ;
బయటకి దారి ( EXIT_FAILURE ) ;
}
ser_చిరునామా. పాపం_కుటుంబం = OF_INET ;
ser_చిరునామా. sin_port = htons ( పోర్ట్ ) ;
ఉంటే ( inet_pton ( AF_INET, SERVER_IP, & ser_చిరునామా. sin_addr ) <= 0 ) {
తప్పు ( 'తప్పు చిరునామా' ) ;
బయటకి దారి ( EXIT_FAILURE ) ;
}
ఉంటే ( కనెక్ట్ చేయండి ( cli_socket, ( నిర్మాణం sockaddr * ) & సెర్_చిరునామా, పరిమాణం ( సెర్_చిరునామా ) ) == - 1 ) {
తప్పు ( 'కనెక్షన్ వైఫల్యం' ) ;
బయటకి దారి ( EXIT_FAILURE ) ;
}
పంపండి ( cli_socket, mesg, strlen ( సందేశం ) , 0 ) ;
చార్ buf [ 1024 ] = { 0 } ;
చదవండి ( cli_socket, బఫ్, పరిమాణం ( buf ) ) ;
std :: కోట్ << 'సర్వర్ ప్రతిస్పందన:' << buf << std :: endl ;
దగ్గరగా ( cli_socket ) ;
తిరిగి 0 ;
}
ప్రోగ్రామ్ ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి కోడ్ యొక్క ప్రతి పంక్తిని చూద్దాం.
అదే నాలుగు లైబ్రరీలు - iostream, cstring, unistd.h మరియు arpa/inet.h - క్లయింట్ వైపు కూడా చేర్చబడ్డాయి. స్థానిక హోస్ట్ 127.0.0.1 యొక్క IP చిరునామాతో పాటు పోర్ట్ నంబర్ కూడా నిర్వచించబడింది. సర్వర్‌కు అందించాల్సిన సందేశం అందించబడింది. క్లయింట్ మరియు సర్వర్ కింది దశగా కనెక్షన్‌ని ఏర్పాటు చేయాలి:
ఒకవేళ ((క్లయింట్_సాకెట్ = సాకెట్(AF_INET, SOCK_STREAM, 0)) == -1);' స్ట్రీమ్ రకం మరియు డిఫాల్ట్ ప్రోటోకాల్ TCPతో IPv4 కోసం సాకెట్‌ను సృష్టిస్తుంది. సాకెట్() ఫంక్షన్ కనెక్షన్‌ని ఏర్పాటు చేయడంలో విఫలమైతే మరియు ప్రోగ్రామ్ నుండి నిష్క్రమిస్తే perror() దోష వివరాలను ముద్రిస్తుంది.
“server_address.sin_port = htons(PORT);” నెట్‌వర్క్ బైట్ ఆర్డర్‌కి మార్చిన తర్వాత పోర్ట్ నంబర్‌ను సెట్ చేస్తుంది. ఆ తర్వాత, 'రాంగ్ అడ్రస్' అనే మరో ఫెయిల్యూర్ మెసేజ్ ఇక్కడ ఇవ్వబడింది, అది చిరునామాలో ఏదైనా తప్పు ఉంటే ముద్రించబడుతుంది. “ser_address”లో చిరునామాను గుర్తించడం ద్వారా, క్లయింట్ సర్వర్‌కి కనెక్ట్ అవుతుంది. కనెక్షన్ విఫలమైతే, లోపం వివరాలు ముద్రించబడతాయి. పంపు() ఫంక్షన్ సందేశాన్ని సర్వర్‌కు బదిలీ చేస్తుంది, అది ఎటువంటి ఫ్లాగ్‌ను కలిగి లేదని నిర్ధారిస్తుంది.
సర్వర్ నుండి ప్రతిస్పందనను స్వీకరించడానికి మరియు నిల్వ చేయడానికి, 'char' రకం యొక్క 'buf' అనే బఫర్ ప్రారంభించబడింది. రీడ్() ఫంక్షన్ సర్వర్ ప్రతిస్పందనను బఫర్‌లోకి చదువుతుంది. చివరగా, సర్వర్ ప్రతిస్పందన కన్సోల్‌కు ముద్రించబడుతుంది. చివరగా, సాకెట్‌ను ముగించడానికి క్లోజ్() స్టేట్‌మెంట్‌ని ఉపయోగించి కనెక్షన్ మూసివేయబడుతుంది. ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ క్రిందిది:
ముగింపు
కంప్యూటర్ సైన్స్‌లో నెట్‌వర్క్ కమ్యూనికేషన్‌లో సాకెట్ ప్రోగ్రామింగ్ ఒక ముఖ్యమైన భాగం. ఇది నెట్‌వర్క్ ద్వారా కమ్యూనికేట్ చేయగల అప్లికేషన్‌ల అభివృద్ధిని ప్రారంభిస్తుంది, సాధారణ క్లయింట్-సర్వర్ ఆర్కిటెక్చర్‌ల నుండి నిర్మాణాత్మక పంపిణీ వ్యవస్థల వరకు విస్తృత అవకాశాలను అనుమతిస్తుంది. ప్రోగ్రామింగ్ సందర్భంలో సాకెట్ సృష్టించబడినప్పుడు, ప్రోగ్రామ్ తప్పనిసరిగా ప్రోటోకాల్‌లు, TCP లేదా UDP మరియు IP చిరునామా మరియు పోర్ట్ నంబర్ వంటి నెట్‌వర్క్ చిరునామా వంటి దాని ముగింపు బిందువు లక్షణాలను కాన్ఫిగర్ చేయాలి. ఈ సాకెట్లు సర్వర్‌లను డేటాను పంపడానికి మరియు స్వీకరించడానికి అనుమతిస్తాయి. సాకెట్ ప్రోగ్రామింగ్‌లోని క్లయింట్-సర్వర్ మోడల్ ఎలా పనిచేస్తుందనే దానిపై ఈ కథనం ఒక ఆచరణాత్మక ఉదాహరణను ప్రదర్శిస్తుంది.