ఈ ఆర్టికల్లో, నేను ఎగ్జిక్యూటివ్ ఫ్యామిలీ ఆఫ్ ఫంక్షన్స్ గురించి మాట్లాడబోతున్నాను మరియు సి లో ఈ ఎగ్జిక్యూట్ ఫ్యామిలీ ఫంక్షన్‌ని ఎలా ఉపయోగించాలో మీకు చూపుతాను. కాబట్టి, ప్రారంభిద్దాం.
Exec కుటుంబంలో సి సిస్టమ్ విధులు:
Exec ఫంక్షన్ కుటుంబాలు శీర్షికలో నిర్వచించబడ్డాయి unistd.h . కాబట్టి, మీరు ఈ ఫంక్షన్‌లను ఉపయోగించాలనుకుంటున్న సి ప్రోగ్రామ్‌లో ఈ హెడర్‌ని తప్పక ఉపయోగించాలి.
అందుబాటులో ఉన్న ఎగ్జిక్యూటివ్ ఫంక్షన్లు వాటి ఫంక్షన్ పారామితులతో పాటు క్రింద ఇవ్వబడ్డాయి:
- int execl (const char *path, const char *arg, ..., NULL);
- int execlp (const char *ఫైల్, const char *arg, ..., NULL);
- int execv (const char *path, char *const argv []);
- int execvp (const char *ఫైల్, char *const argv []);
- int execle (const char *path, const char *arg, ..., NULL, char *const envp []);
- int execve (const char *ఫైల్, char *const argv [], char *const envp []);
ఈ ప్రతి ఫంక్షన్ ఏమి చేస్తుందో మరియు వాటిని ఎలా ఉపయోగించాలో చూద్దాం.
execl () సిస్టమ్ ఫంక్షన్:
Execl () లో సిస్టమ్ ఫంక్షన్ ఎక్జిక్యూటబుల్ బైనరీ ఫైల్ (అంటే / బిన్ / ls ) మొదటి మరియు రెండవ వాదనగా. అప్పుడు, వాదనలు (అనగా -లెహ్ , /ఇంటికి ) ఆ తర్వాత మీరు ఎగ్జిక్యూటబుల్‌కు పాస్ అవ్వాలనుకుంటున్నారు శూన్య . అప్పుడు execl () సిస్టమ్ ఫంక్షన్ ఆదేశాన్ని అమలు చేస్తుంది మరియు అవుట్‌పుట్‌ను ప్రింట్ చేస్తుంది. ఏదైనా లోపం సంభవించినట్లయితే, execl () తిరిగి వస్తుంది -1. లేకపోతే, అది ఏమీ తిరిగి ఇవ్వదు.
వాక్యనిర్మాణం:
intexecl(కానిస్టేట్ చార్ *మార్గం, కానిస్టేట్ చార్ *కోపం,...,శూన్య);Execl () సిస్టమ్ ఫంక్షన్ యొక్క ఉదాహరణ క్రింద ఇవ్వబడింది:
#చేర్చండి
intప్రధాన(శూన్యం) {
చార్ *బైనరీపాత్= ' / bin / ls';
చార్ *ఆర్గ్ 1= '-lh';
చార్ *ఆర్గ్ 2= '/ఇల్లు';
execl(బైనరీపాత్,బైనరీపాత్,ఆర్గ్ 1,ఆర్గ్ 2,శూన్య);
తిరిగి 0;
}
నేను నడిచాను ls -lh / హోమ్ execl () సిస్టమ్ ఫంక్షన్ ఉపయోగించి కమాండ్. మీరు గమనిస్తే, సరైన ఫలితం ప్రదర్శించబడుతుంది.
execlp () సిస్టమ్ ఫంక్షన్:
execl () ఉపయోగించదు PATH పర్యావరణ వేరియబుల్. కాబట్టి, execl () తో అమలు చేయడానికి ఎగ్జిక్యూటబుల్ ఫైల్ యొక్క పూర్తి మార్గం అవసరం. execlp () PATH పర్యావరణ వేరియబుల్‌ను ఉపయోగిస్తుంది. కాబట్టి, PATH లో ఎక్జిక్యూటబుల్ ఫైల్ లేదా కమాండ్ అందుబాటులో ఉంటే, దానిని అమలు చేయడానికి కమాండ్ లేదా ఫైల్ పేరు సరిపోతుంది, పూర్తి మార్గం అవసరం లేదు.
వాక్యనిర్మాణం:
intexeclp(కానిస్టేట్ చార్ *ఫైల్, కానిస్టేట్ చార్ *కోపం,...,శూన్య);మేము ఈ విధంగా execlp () సిస్టమ్ ఫంక్షన్ ఉపయోగించి execl () ఉదాహరణను తిరిగి వ్రాయవచ్చు:
#చేర్చండిintప్రధాన(శూన్యం) {
చార్ *ప్రోగ్రామ్ పేరు= 'ls';
చార్ *ఆర్గ్ 1= '-lh';
చార్ *ఆర్గ్ 2= '/ఇల్లు';
execlp(ప్రోగ్రామ్ పేరు,ప్రోగ్రామ్ పేరు,ఆర్గ్ 1,ఆర్గ్ 2,శూన్య);
తిరిగి 0;
}
నేను కమాండ్ పేరు మాత్రమే పాస్ చేసాను ls , పూర్తి మార్గం కాదు / బిన్ / ls . మీరు గమనిస్తే, నాకు మునుపటిలాగానే అవుట్‌పుట్ వచ్చింది.
execv () సిస్టమ్ ఫంక్షన్:
Execl () ఫంక్షన్‌లో, ఎగ్జిక్యూటబుల్ ఫైల్ యొక్క పారామితులు ఫంక్షన్‌కు వివిధ ఆర్గ్యుమెంట్‌లుగా పంపబడతాయి. Execv () తో, మీరు అన్ని పారామితులను NULL ముగించిన శ్రేణిలో పాస్ చేయవచ్చు argv . శ్రేణి యొక్క మొదటి మూలకం ఎక్జిక్యూటబుల్ ఫైల్ యొక్క మార్గం. లేకపోతే, execv () ఫంక్షన్ execl () ఫంక్షన్ వలె పనిచేస్తుంది.
వాక్యనిర్మాణం:
intexecv(కానిస్టేట్ చార్ *మార్గం, చార్ *కానిస్టేట్argv[]);మేము execl () ఉదాహరణను ఈ క్రింది విధంగా తిరిగి వ్రాయవచ్చు:
#చేర్చండిintప్రధాన(శూన్యం) {
చార్ *బైనరీపాత్= ' / bin / ls';
చార్ *వాదిస్తుంది[] = {బైనరీపాత్, '-lh', '/ఇల్లు',శూన్య};
execv(బైనరీపాత్,వాదిస్తుంది);
తిరిగి 0;
}
మీరు గమనిస్తే, నేను సరైన అవుట్‌పుట్ పొందుతున్నాను.
execvp () సిస్టమ్ ఫంక్షన్:
Execv () సిస్టమ్ ఫంక్షన్ వలె పనిచేస్తుంది. కానీ, PATH ఎన్విరాన్మెంట్ వేరియబుల్ ఉపయోగించబడుతుంది. కాబట్టి, execlp () లో వలె ఎక్జిక్యూటబుల్ ఫైల్ యొక్క పూర్తి మార్గం అవసరం లేదు.
వాక్యనిర్మాణం:
intexecvp(కానిస్టేట్ చార్ *ఫైల్, చార్ *కానిస్టేట్argv[]);మేము execv () ఉదాహరణను ఈ క్రింది విధంగా తిరిగి వ్రాయవచ్చు:
#చేర్చండిintప్రధాన(శూన్యం) {
చార్ *ప్రోగ్రామ్ పేరు= 'ls';
చార్ *వాదిస్తుంది[] = {ప్రోగ్రామ్ పేరు, '-lh', '/ఇల్లు',శూన్య};
execvp(ప్రోగ్రామ్ పేరు,వాదిస్తుంది);
తిరిగి 0;
}
మీరు గమనిస్తే, సరైన అవుట్‌పుట్ ప్రదర్శించబడుతుంది.
execle () సిస్టమ్ ఫంక్షన్:
Execl () లాగా పనిచేస్తుంది, కానీ మీరు దానితో పాటు మీ స్వంత పర్యావరణ వేరియబుల్స్ అందించవచ్చు. పర్యావరణ వేరియబుల్స్ శ్రేణిగా పంపబడతాయి ఎన్విపి . చివరి అంశం ఎన్విపి శ్రేణి శూన్యంగా ఉండాలి. అన్ని ఇతర మూలకాలు కీ-విలువ జతలను స్ట్రింగ్‌గా కలిగి ఉంటాయి.
వాక్యనిర్మాణం:
intఅమలు(కానిస్టేట్ చార్ *మార్గం, కానిస్టేట్ చార్ *కోపం,...,శూన్య, చార్ * కానిస్టేట్ఎన్విపి[] );ఎగ్జిక్యూల్ () సిస్టమ్ ఫంక్షన్ యొక్క ఉదాహరణ క్రింద ఇవ్వబడింది:
#చేర్చండిintప్రధాన(శూన్యం) {
చార్ *బైనరీపాత్= '/బిన్/బాష్';
చార్ *ఆర్గ్ 1= '-c';
చార్ *ఆర్గ్ 2= 'విసిరివేయబడింది'$ HOSTNAME ని సందర్శించండి:మీ బ్రౌజర్ నుండి $ PORT.'';
చార్ *కానిస్టేట్ఎన్వి[] = {'HOSTNAME = www.linuxhint.com', 'పోర్ట్ = 8080',శూన్య};
అమలు(బైనరీపాత్,బైనరీపాత్,ఆర్గ్ 1,ఆర్గ్ 2,శూన్య,ఎన్వి);
తిరిగి 0;
}
నేను రెండు పర్యావరణ వేరియబుల్స్ పాస్ అయ్యాను HOSTNAME మరియు పోర్ట్ execle () ఫంక్షన్‌కు. మీరు చూడగలిగినట్లుగా, నేను వాటిని ఎక్జిక్యూటబుల్ నుండి యాక్సెస్ చేయగలను /బిన్/బాష్ .
execve () సిస్టమ్ ఫంక్షన్:
Execle () లాగా మీరు execve () తో పాటు మీ స్వంత పర్యావరణ వేరియబుల్స్ కూడా అందించవచ్చు. మీరు execv () లో చేసినట్లుగా మీరు ఆర్గ్యుమెంట్‌లను కూడా శ్రేణులుగా పాస్ చేయవచ్చు.
వాక్యనిర్మాణం:
intఅమలు(కానిస్టేట్ చార్ *ఫైల్, చార్ *కానిస్టేట్argv[], చార్ *కానిస్టేట్ఎన్విపి[]);Execle () ఉదాహరణను ఈ క్రింది విధంగా తిరిగి వ్రాయవచ్చు:
#చేర్చండిintప్రధాన(శూన్యం) {
చార్ *బైనరీపాత్= '/బిన్/బాష్';
చార్ *కానిస్టేట్వాదిస్తుంది[] = {బైనరీపాత్, '-c', 'విసిరివేయబడింది'$ HOSTNAME ని సందర్శించండి:$ పోర్ట్
మీ బ్రౌజర్ నుండి.'',శూన్య};
చార్ *కానిస్టేట్ఎన్వి[] = {'HOSTNAME = www.linuxhint.com', 'పోర్ట్ = 8080',శూన్య};
అమలు(బైనరీపాత్,వాదిస్తుంది,ఎన్వి);
తిరిగి 0;
}
మీరు చూడగలిగినట్లుగా, execle () ఉదాహరణలో అదే అవుట్‌పుట్ మాకు లభిస్తుంది.
కాబట్టి, మీరు Linux లో సిస్టమ్ ప్రోగ్రామింగ్ కోసం C లో exec ఫంక్షన్ ఫ్యామిలీని ఎలా ఉపయోగిస్తున్నారు. ఈ కథనాన్ని చదివినందుకు ధన్యవాదాలు.