Habang ginagamit ang dlopen function, hindi sinusuri ng compiler ang mga potensyal na error dahil hindi nito alam ang mga uri at prototype na ginagamit namin. Ang deployment ng dlopen function para sa karaniwang paglo-load ay hindi lilitaw na pino-promote nito, maliban sa ilang maliliit na sitwasyon. Sa pamamagitan ng paraan, ito ay isang diskarte upang mapabuti ang introspection. Kapag ang nakabahaging module ay kasalukuyang ginagamit ng isa pang programa, ang pag-optimize ng layout ng memorya ay hindi partikular na interesado sa conditional loading. Hindi tataas ang memory footprint kapag na-load ang isang dating ginamit na library. Ang pag-iwas sa pagsubaybay sa compiler ay mapanganib at gumagawa para sa mahusay na pagsulat ng bug. Bukod pa rito, kulang kami sa posibleng pag-optimize ng compiler.
Halimbawa 1:
Ngayon, isaalang-alang ang sumusunod na halimbawa upang makita ang pag-andar ng dlopen function sa wikang C. Sa unang hakbang, naglo-load kami ng ilang C standard na library. Dito, nilo-load namin ang bagong library na 'dlfcn.h' na ginagamit upang tukuyin ang mga macro habang ginagawa ang argumento ng dlopen mode.
Pagkatapos, ipinakilala namin ang isa pang aklatan sa loob ng aming programang 'gnu/lib-name.h'. Ang mga shared library file na kasama sa GNU libc ay matatagpuan ng mga program ng user ayon sa mga macro na tinukoy nito. Nag-aalok ang GNU C Library ng mga pangunahing aklatan para sa mga operating system ng GNU at GNU/Linux pati na rin ang malawak na hanay ng iba pang mga sistemang nakabatay sa Linux. Pagkatapos nito, mayroon kaming pangunahing paraan ng pagpapatupad. Sa loob nito, ipinapahayag namin ang pointer object na 'hawakan' na may void na keyword. Nagdedeklara kami ng pointer sine function na may dobleng uri ng data. May isa pang deklarasyon ng pointer object na 'error' para sa paghawak ng error.
Pagkatapos nito, hinihiling namin ang dlopen function sa loob ng object na 'handle'. Ang dlopen ay tumatagal ng dalawang argumento: LIBM_SO at “RTLD_LAZY”. Dito, ang 'LIBM_SO' ay ang pangalan ng library file na nagbibigay ng mga mathematical function tulad ng trigonometric functions. Ang nakabahaging library na ito ay kinakailangan habang ginagamit namin ang function ng sine. Ang 'RTLD_LAZY' ay isa pang argumento na tumatawag sa dlopen function. Kapag ang isang ibinigay na simbolo ay tinukoy sa unang pagkakataon, ang mga relokasyon ay dapat isagawa sa oras na tinutukoy ng pagpapatupad.
Dahil ang isang proseso ay maaaring hindi sumangguni sa bawat simbolo sa isang executable object file, ang pagtukoy sa RTLD LAZY ay dapat na mapahusay ang pagganap sa mga pagpapatupad na nagbibigay-daan sa dynamic na pag-binding ng simbolo. Susunod, mayroon kaming kung-ibang kundisyon para sa paghawak ng error kapag nabigo ang handle object na gawin ang dlopen function. Tinatawag namin ang dlerror upang i-clear ang error.
Ang dlerror() function ay nagbibigay ng null-terminated string na nababasa ng tao at tinutukoy ang pag-uulat ng kamakailang error na sanhi ng isang tawag sa isa sa mga dlopen API na tawag mula noong huling tawag sa dlerror. Pagkatapos, ini-cast namin ang function na tulad nito: '(*void**)(&sine)= dlsym(handle, sin)'. Dahil kakaiba ito, ang paghahagis ay sumusunod sa ISO C na umiiwas sa mga babala mula sa compiler. Ginagamit namin ang dlsym function na nakakakuha ng path ng isang simbolo na tinukoy sa loob ng dynamic na link module na naa-access sa pamamagitan ng dlopen() function.
Gayundin, ginagawa namin muli ang if-else na operasyon para sa karaniwang error na nabuo kapag ang dlerror() ay hindi NULL. Pagkatapos, mayroon kaming printf statement kung saan tinukoy namin ang halaga ng sine na kukuwentahin. Sa huling hakbang, isinasara namin ang nakabahaging bagay na iyon sa pamamagitan ng paggamit ng dlclose para sa handle na ibinalik ng dlopen().
#include
#include
#include
#include
int
pangunahing ( int argc , char ** argv )
{
walang bisa * hawakan ;
doble ( * sa kanila ) ( doble ) ;
char * pagkakamali ;
hawakan = dlopen ( LIBM_SO , RTLD_LAZY ) ;
kung ( ! hawakan ) {
fprintf ( stderr , '%s \n ' , dlerror ( ) ) ;
labasan ( EXIT_FAILURE ) ;
}
dlerror ( ) ;
* ( walang bisa ** ) ( at sa kanila ) = dlsym ( hawakan , 'walang' ) ;
kung ( ( pagkakamali = dlerror ( ) ) != WALA ) {
fprintf ( stderr , '%s \n ' , pagkakamali ) ;
labasan ( EXIT_FAILURE ) ;
}
printf ( '%f \n ' , ( * sa kanila ) ( 4.0 ) ) ;
dclose ( hawakan ) ;
labasan ( EXIT_SUCCESS ) ;
}
Ginagamit namin ang -ldl na opsyon sa C compilation command dahil ito ang library para sa dlopen linked interface at kinakailangan ito. Kapag ginawa ang execution ng dlopen file, ipinapakita nito ang sine value ng dating ibinigay na value.
Halimbawa 2:
Ngayon, kumuha kami ng isa pang halimbawa ng paggamit ng dlopen function. Ni-load namin ang aming programa ng lahat ng kinakailangang C library para sa pagpapatupad ng dlopen code. Pagkatapos, sinisimulan namin ang aming programa sa loob ng pangunahing pamamaraan. Dito, tinutukoy namin ang string na may deklarasyon ng variable na 'src'. Pagkatapos ay idineklara namin ang mga variable ng pointer na 'strlen', 'handle' at 'error'.
Susunod, tinatawagan namin ang handle variable at i-deploy ang dlopen function. Ang dlopen function ay nag-input sa shared library na 'libstr.so' para sa string handling function at ang flag na 'RTLD_LAZY' na ipinakita na sa nakaraang halimbawa. Hinihimok namin ang dlerror function sa loob ng variable na 'error' upang i-clear ang error na nabuo ng dlopen function. Ang if-else ay ginagamit upang suriin ang mga error.
Pagkatapos, makuha namin ang address ng strlen function gamit ang dlsym function at i-verify ang mga error habang ginagawa ito. Pagkatapos nito, ginagamit namin ang printf function upang tawagan ang strnlen function upang ibalik ang haba ng ibinigay na string. Sa huli, isinasara namin ang nakabahaging library gamit ang dlclose function.
#include#include
#include
#include
int pangunahing ( walang bisa )
{
char * src = 'Hello Linux' ;
int ( * strlen ) ( const char * ) ;
walang bisa * hawakan ;
char * pagkakamali ;
hawakan = dlopen ( './libstr.so' , RTLD_LAZY ) ;
pagkakamali = dlerror ( ) ;
kung ( ! hawakan || pagkakamali != WALA ) { printf ( 'Nabigo ang Pag-load sa Library Attempt! \n %s \n ' , pagkakamali ) ;
bumalik - 1 ; }
strlen = dlsym ( hawakan , 'strlen' ) ;
pagkakamali = dlerror ( ) ;
kung ( ! strlen || pagkakamali == WALA ) { printf ( '%s \n ' , pagkakamali ) ; bumalik - 1 ; }
printf ( 'Ang Haba ng String ay:%d \n ' , strlen ( src ) ) ;
dclose ( hawakan ) ;
bumalik 0 ;
}
Ginagamit namin ang sumusunod na utos para sa pagpapatupad ng ibinigay na programa. Dito, ang -lstr flag ay ginagamit para sa string length function at ang ldl ay ginagamit para sa dlopen library file. Ang pinagsama-samang programa ay nagbibigay ng haba ng string tulad ng ipinapakita sa shell:
Konklusyon
Ang impormasyon ay ibinigay tungkol sa dlopen function ng C wika sa artikulong ito. Mayroon kaming maikling pagpapakilala ng dlopen function. Pagkatapos, ipinatupad namin ang dalawang halimbawa. Ang function ay nagbabalik ng isang identifier na tumutukoy sa binuksan na library. Ang mga address ng mga function sa loob ng binuksan na library ay tutukuyin gamit ang identifier na ito at ang dlsym function. Ang address ng function sa loob ng library na nabuksan na gamit ang dlopen ay makikita gamit ang dlsym function.