“ Ang popen() function ay isasagawa ang utos na ibinigay ng utos ng string. Dapat ibalik ng function ang isang pointer sa isang stream na ginagamit para magbasa o sumulat sa pipe habang gumagawa din ng pipe sa pagitan ng calling application at ng executed command. Ang Popen function ay available sa karaniwang library ng I/O function at nagpapalabas ng pangalawang proseso para magpatakbo ng terminal command. Ang open phase ng popen() ay kapareho ng open phase sa fopen() function. Ang popen() function ay nagpapasimula ng proseso sa pamamagitan ng forking, paggawa ng pipe, at pag-execute ng shell. Dahil ang isang tubo ay unidirectional bilang default; bilang resulta, ang stream ay read-only o write-only. Sa popen() function na matagumpay na pagpapatupad, ang isang bukas na stream ay nakuha na ginagamit para sa pipe na magbasa at magsulat.
Halimbawa 1
Gamit ang sumusunod na halimbawang programa, babasahin natin ang mga file na umiiral sa kasalukuyang direktoryo o folder gamit ang popen system call. Una, mayroon kaming input ng stdio.h header file ng C standard library. Pagkatapos, mayroon kaming program int main()function kung saan na-deploy namin ang popen function. Bago ito, itinatag namin ang pointer variable na 'FileOpen' mula sa klase na 'FILE'. Ang pointer variable ng file ay nagpapahiwatig ng kasunod na byte na babasahin o isulat.
Pagkatapos noon, itinalaga namin ang limit value ng character na babasahin. Ang variable na 'FileOpen' pagkatapos ay tinawag ang 'popen' function. Ang 'popen' function ay tumatagal ng 'ls -l' command ng Linux, na maglilista ng lahat ng mga file ng kasalukuyang direktoryo. Bukod dito, mayroon kaming input ng 'r' na parameter sa popen function, na nagpapahiwatig ng read mode.
Dito, nai-pipe namin ang proseso ng pagbabasa ng mga file sa pamamagitan ng paggamit ng popen function. Susunod, naproseso namin ang nilikha na tubo gamit ang while loop. Ang while loop ay gumagamit ng mga fgets na pamamaraan, na kumukuha ng mga argumentong 'linya', 'laki ng linya,' at 'FileOpen'. Binasa ng fgets ang piped na proseso at iniimbak ito sa '%s' na simbolo ng string. Ang partikular na simbolo na ito ay tinatawag sa loob ng paraan ng printf kasama ang argumentong 'linya'. Kapag nagawa na namin ang pipe na naproseso, gamit ang pclosed function, ang piped na proseso ay maaaring isara bilang na-deploy sa dulo ng programa sa ibaba.
#include
int pangunahing ( )
{
FILE * FileOpen;
linya ng char [ 130 ] ;
FileOpen = popen ( 'ls -l' , 'r' ) ;
habang ( fgets ( linya, laki ng linya, FileOpen ) )
{
printf ( '%s' , linya ) ;
}
pclose ( FileOpen ) ;
}
Ang popen function ng C program ay nag-forked sa proseso sa itaas at pagkatapos ay nilikha ang pipe. Ngayon, naisakatuparan na namin ang naprosesong tubo ng stream sa shell gamit ang C compilation command. Ang output ay nakalista ang lahat ng mga file sa 'Home' na direktoryo habang naisakatuparan namin ang programa sa direktoryong iyon.
Halimbawa 2
Sa nakaraang programa ng popen, mayroon kaming isang simpleng pagpapakita ng paggana ng programa ng popen na ginagamit para sa piping ng proseso ng streaming ng pagbabasa ng mga file. Ngayon, kumuha kami ng isa pang halimbawa ng popen function kung saan na-pipe namin ang proseso gamit ang write mode. Isaalang-alang natin ang programa na may pangunahing pag-andar. Binuo namin ang variable ng pointer ng file sa loob ng pangunahing function bilang 'file'. Ang file pointer ay na-deploy gamit ang popen function.
Ang popen function ay tumatagal ng 'cat' command at ang 'w' para sa write mode. Dito, ang bawat File argument ay sunud-sunod na binabasa at ipinapadala sa karaniwang output ng cat command. Sa for loop body, ginamit namin ang fprintf function para i-print ang mga numerical count value gaya ng tinukoy namin ang simbolo na “%d”. Pagkatapos ay isinara, ang proseso ng popen pipe na may pclose system call.
#includeint pangunahing ( int argc, char ** argv ) {
FILE * file = popen ( 'pusa' , 'sa' ) ;
int x = 0 ;
para sa ( x = 0 ;x < 5 ;x++ ) {
fprintf ( file , 'Aking Bilang = %d \n ' , x ) ;
}
pclose ( file ) ;
bumalik 0 ;
}
Kapag naisakatuparan namin ang prosesong ginawa sa itaas, na-print nito ang mga halaga ng bilang sa sumusunod na paraan.
Halimbawa 3
Ngayon, mayroon kaming isa pang programa na naglilipat ng data ng isang proseso sa isa pang proseso. Gagawin namin ito sa pipe mula sa popen function. Ipinatupad namin ang programa sa pamamagitan ng paggamit ng mga karaniwang aklatan ng C. Pagkatapos, mayroon kaming int na pangunahing function para sa pag-deploy ng isang programa. Dito, tinukoy namin ang string sa sprintf function na may 'buffer' na argumento. Pinapanatili ng sprintf() function ang resulta sa char buffer na ibinigay ng sprintf sa halip na ipadala ito sa prompt.
Pagkatapos nito, tinawag namin ang popen function sa loob ng variable na 'basahin'. Doon, mayroon kaming dalawang proseso sa loob ng popen function. Ang 'wc -c' ay ang unang proseso na ginagamit upang mabilang ang ibinigay na mga character, at ang pangalawang proseso ay ang 'w,' na nagpapahiwatig na ang pipe ay bukas sa writing mode. Pagkatapos nito, mayroon kaming function na 'fwrite' na gumagamit ng pipe upang magsulat ng data. Ang data ay matatanggap ng 'wc', pagkatapos ay mabibilang ang character at ipapakita sa shell.
#include#include
#include
#include
int pangunahing ( )
{
FILE * basahin ;
char buffer [ limampu ] ;
sprintf ( buffer, 'Linux System call' ) ;
basahin =popen ( 'wc -c' , 'sa' ) ;
fwrite ( buffer, laki ng ( char ) , strlen ( buffer ) , basahin ) ;
pclose ( basahin ) ;
}
Ang mga character na ipinapakita sa prompt ay '17' dahil ang string na tinukoy namin sa itaas ay naglalaman ng '17' na mga character. Binabasa ng prosesong 'wc -c' ang mga character na ito at ini-print ang mga ito bilang isang output.
Halimbawa 4
Ang halimbawa sa itaas ng popen ay nagpapadala ng data mula sa isang proseso patungo sa isa pa. Dito, matatanggap namin ang data mula sa isang proseso patungo sa isa pang proseso sa pamamagitan ng pipe. Ang pangunahing pag-andar ng programa ay ang pagbuo ng buffer, na tumatagal ng '50' na mga halaga. Pagkatapos, ginawa namin ang variable na 'r,' kung saan nilikha ng popen function ang proseso. Ang 'ls' na proseso ay ginagamit upang ilista ang mga file ng direktoryo, at ang 'r' na proseso para sa pagbabasa ng data mula sa pipe. Ang 'ls' na proseso ay nagpapadala ng data sa 'r' na proseso upang basahin. Pagkatapos nito, mayroon kaming function ng fread, na nagbabasa ng data at nag-iimbak ng data sa buffer. Pagkatapos, ipi-print ng print statement ang data na nakaimbak sa buffer.
#include#include
#include
#include
int pangunahing ( )
{
FILE * r;
char buffer [ limampu ] ;
r = popen ( 'ls' , 'r' ) ;
takot ( buffer, 1 , 25 , r ) ;
printf ( '%s \n ' , buffer ) ;
pclose ( r ) ;
}
Dito lamang '50' na mga character ng umiiral na mga file ang ipinapakita mula sa gumaganang direktoryo. Samakatuwid, ang output ay magkakaroon lamang ng 50 character.
Konklusyon
Nagbigay kami ng detalyadong pagpapakita ng mga tawag sa Linux popen system sa wikang C. Nagpatupad kami ng apat na halimbawa kung saan na-deploy namin ang popen function. Ibinabalik ng popen function ang pipe stream ayon sa mode na itinalaga namin. Sa mga halimbawa, ginamit namin ang parehong read at write mode na may mga function sa paghawak ng file fread at fwrite. Ginamit namin ang pangalan ng programa sa popen() function bilang unang argumento nito. Ang pangalawang argumento ay isang file na 'r' bilang read o 'w' bilang write mode.