Exemple de get request curl php. Se trimit solicitări GET în cURL

Acest articol presupune că cunoașteți elementele de bază ale rețelelor și HTML.

Abilitatea de a scrie scripturi este esențială pentru construirea unui sistem informatic bun. Extensibilitatea sistemelor Unix cu scripturi shell și diverse programe care execută comenzi automate este unul dintre motivele pentru care au atât de mult succes.

Numărul tot mai mare de aplicații care se mută pe web a dus la faptul că subiectul scripturilor HTTP devine din ce în ce mai popular. Sarcinile importante din această zonă sunt preluarea automată a informațiilor de pe Internet, trimiterea sau descărcarea de date către servere web etc.

Curl este un instrument de linie de comandă care vă permite să faceți diferite tipuri de manipulare și transferuri URL. Acest articol se concentrează pe crearea de solicitări HTTP simple. Se presupune că știți deja unde să tastați

# curl --ajutor

# curl --manual

pentru informații despre curl.

Curl nu este un instrument care va face totul pentru tine. Acesta creează cereri, primește date și trimite date. Este posibil să aveți nevoie de un fel de „clei” pentru a ține totul împreună, poate un limbaj de scripting (cum ar fi bash) sau unele apeluri manuale.

1. Protocolul HTTP

HTTP este un protocol folosit la primirea datelor de la serverele web. Acesta este un protocol foarte simplu care este construit pe TCP/IP. Protocolul permite, de asemenea, să fie trimise informații către server de la client folosind mai multe metode, așa cum va fi arătat mai târziu.

HTTP sunt șiruri de text ASCII trimise de la un client la un server pentru a solicita o acțiune. La primirea unei cereri, serverul răspunde clientului cu mai multe linii de text de serviciu și apoi cu conținutul real.

Folosind comutatorul curl -v, puteți vedea ce comenzi trimite curl către server, precum și alt text informațional. Comutatorul -v este poate singura modalitate de a depana sau chiar de a înțelege interacțiunea dintre curl și serverul web.

2. URL

Formatul URL (Uniform Resource Locator) specifică adresa unei anumite resurse de pe Internet. Probabil știți asta, exemple de adrese URL: http://curl.haxx.se sau https://yourbank.com.

3. Obțineți pagina (GET).

Cea mai simplă și mai comună solicitare HTTP este obținerea conținutului unei adrese URL. O adresă URL poate trimite către o pagină web, o imagine sau un fișier. Clientul trimite o cerere GET către server și primește documentul solicitat. Dacă executați comanda

# curl http://curl.haxx.se

veți primi o ieșire a paginii web în fereastra terminalului dvs. Documentul HTML complet conținut la această adresă URL.

Toate răspunsurile HTTP conțin un set de anteturi care sunt de obicei ascunse. Pentru a le vedea împreună cu documentul în sine, utilizați opțiunea curl -i. De asemenea, puteți solicita doar anteturile folosind comutatorul -I (care va forța curl să facă o solicitare HEAD).

4. Forme

Formularele reprezintă modalitatea de bază de prezentare a unui site web ca pagină HTML cu câmpuri în care utilizatorul introduce date și apoi dă clic pe butonul „OK” sau „Trimite”, după care datele sunt trimise către server. Serverul folosește apoi datele primite și decide ce să facă în continuare: caută informațiile din baza de date, arată adresa introdusă pe o hartă, adaugă un mesaj de eroare sau folosește informațiile pentru autentificarea utilizatorului. Desigur, există un program pe partea de server care vă primește datele.

4.1 GET

Un formular GET folosește metoda GET, de exemplu astfel:

Dacă deschideți acest cod în browser, veți vedea un formular cu un câmp de text și un buton care spune „OK”. Dacă introduceți „1905” și faceți clic pe OK, browserul va crea o nouă adresă URL pe care o va urma. Adresa URL va fi reprezentată ca un șir format din calea adresei URL anterioare și un șir precum „junk.cgi?birthyear=1905&press=OK”.

De exemplu, dacă formularul a fost localizat la „www.hotmail.com/when/birth.html”, atunci făcând clic pe OK veți ajunge la adresa URL „www.hotmail.com/when/junk.cgi?birthyear=1905&press=OK " .

Majoritatea motoarelor de căutare funcționează astfel.

Pentru ca curl să genereze o solicitare GET, introduceți pur și simplu ceea ce vă așteptați de la formular:

# curl „www.hotmail.com/when/junk.cgi?birthyear=1905&press=OK”

4.2 POST

Metoda GET face ca toate informațiile introduse să apară în bara de adrese a browserului dumneavoastră. Acest lucru poate fi bun atunci când trebuie să marcați o pagină, dar este un dezavantaj evident când introduceți informații sensibile în câmpurile de formular sau când cantitatea de informații introduse în câmpuri este prea mare (rezultând o adresă URL de necitit).

Protocolul HTTP oferă metoda POST. Cu el, clientul trimite date separat de URL și, prin urmare, nu le vei vedea în bara de adrese.

Formularul care generează cererea POST este similar cu cel precedent:

Curl poate genera o solicitare POST cu aceleași date, după cum urmează:

# curl -d "birthyear=1905&press=%20OK%20" www.hotmail.com/when/junk.cgi

Această solicitare POST folosește „Content-Type application/x-www-form-urlencoded”, care este cea mai utilizată metodă.

Datele pe care le trimiteți către server trebuie să fie codificate corect, curl nu va face acest lucru pentru dvs. De exemplu, dacă doriți ca datele să conțină un spațiu, trebuie să înlocuiți spațiul cu %20 etc. Lipsa de atenție la această problemă este o greșeală comună, din cauza căreia datele nu sunt transferate așa cum ar trebui.

În 1995, a fost definită o modalitate suplimentară de transfer de date prin HTTP. Este documentată în RFC 1867, așa că această metodă este uneori numită RFC1867-posting.

Această metodă este concepută în principal pentru a sprijini mai bine încărcarea fișierelor. Formularul care permite utilizatorului să încarce un fișier arată cam așa în HTML:

Rețineți că Content-Type este setat la multipart/form-data.

Pentru a trimite date către acest formular folosind curl, introduceți comanda:

# curl -F upload=@localfilename -F apăsați=OK

4.4 Câmpuri ascunse

O modalitate obișnuită de a transmite informații de stare în aplicațiile HTML este utilizarea câmpurilor ascunse în formulare. Câmpurile ascunse nu sunt populate, sunt invizibile pentru utilizator și sunt transmise în același mod ca și câmpurile obișnuite.

Un exemplu simplu de formular cu un câmp vizibil, un câmp ascuns și un buton OK:

Pentru a trimite o solicitare POST folosind curl, nu trebuie să vă gândiți dacă câmpul este ascuns sau nu. Pentru bucle sunt toate la fel:

# curl -d "birthyear=1905&press=OK&person=daniel"

4.5 Aflați cum arată o solicitare POST

Când doriți să completați un formular și să trimiteți date către server folosind curl, probabil că doriți ca solicitarea POST să arate exact la fel ca și cea făcută folosind un browser.

O modalitate simplă de a vedea solicitarea dvs. POST este să salvați pagina HTML cu formularul pe disc, să schimbați metoda în GET și să faceți clic pe butonul „Trimiteți” (puteți schimba și adresa URL la care vor fi trimise datele).

Veți vedea datele atașate la adresa URL, separate prin caractere „?”, așa cum era de așteptat când utilizați formularele GET.

5. PUNE

Poate că cea mai bună modalitate de a încărca date pe un server HTTP este utilizarea PUT. Din nou, acest lucru necesită un program (script) pe backend care știe ce să facă și cum să accepte fluxul HTTP PUT.

Trimiteți un fișier către server folosind curl:

# curl -T uploadfile www.uploadhttp.com/receive.cgi

6. Autentificare

Autentificare - transmiterea unui nume de utilizator și a unei parole către server, după care verifică dacă aveți dreptul de a finaliza solicitarea solicitată. Autentificarea de bază (pe care curl o folosește în mod implicit) se bazează pe text simplu, ceea ce înseamnă că numele de utilizator și parola nu vor fi criptate, ci doar ușor „aburite” cu algoritmul Base64, lăsând posibil ca atacatorii de pe calea dintre tine și tine să aflați aceste informații pe serverul HTTP.

Spune-i lui Curl să folosească numele de utilizator și parola:

# curl -u nume:parolă www.secrets.com

Site-ul poate necesita utilizarea unei alte metode de autentificare (uitați-vă la ce scrie serverul în anteturi), în aceste cazuri puteți utiliza comutatoarele --ntlm, --digest, --negotiate sau chiar --anyauth. Uneori, accesul la serverele HTTP externe are loc prin intermediul unui proxy, acest lucru se face adesea în companii și firme. Un proxy HTTP poate necesita propriul nume de utilizator și parolă pentru a accesa Internetul. Cheia curl corespunzătoare:

# curl -U proxyuser:proxypassword curl.haxx.se

Dacă proxy-ul necesită autentificare folosind metoda NTLM, specificați --proxy-ntlm, dacă metoda Digest, atunci --proxy-digest.

Dacă nu specificați o parolă în opțiunile -u și -U, atunci curl vă va cere în mod interactiv.

Rețineți că atunci când curl rulează, șirul de pornire (și împreună cu el cheile și parolele) poate fi vizibil pentru alți utilizatori ai sistemului dvs. în lista de activități. Există modalități de a preveni acest lucru. Mai multe despre asta mai jos.

7. Referitor

O solicitare HTTP poate include un câmp „referer”, care indică de la ce adresă URL a ajuns utilizatorul la această resursă. Unele programe/scripturi verifică câmpul „referer” și nu execută cererea dacă utilizatorul provine de pe o pagină necunoscută. Deși acesta este un mod stupid de a verifica, multe scripturi încă îl folosesc. Cu curl poți pune orice în câmpul „referer” și astfel îl faci să facă ce vrei.

Acest lucru se face după cum urmează:

# curl -e http://curl.haxx.se daniel.haxx.se

8. Agent utilizator

Toate cererile HTTP acceptă un câmp „User-Agent”, care specifică aplicația client a utilizatorului. Multe aplicații web folosesc aceste informații pentru a reda pagina într-un fel sau altul. Programatorii web creează mai multe versiuni ale unei pagini pentru utilizatorii diferitelor browsere pentru a îmbunătăți aspectul, folosesc diverse scripturi javascript, vbscript etc.

Uneori, puteți descoperi că curl returnează o pagină care nu este aceeași cu ceea ce ați văzut în browser. În acest caz, este indicat să folosiți câmpul „Agent utilizator” pentru a înșela din nou serverul.

Deghizați curl ca Internet Explorer pe o mașină Windows 2000:

# curl -A „Mozilla/4.0 (compatibil; MSIE 5.01; Windows NT 5.0)”

De ce să nu deveniți Netscape 4.73 pe o mașină Linux (PIII):

# curl -A „Mozilla/4.73 (X11; U; Linux 2.2.15 i686)”

9. Redirecționări

Când răspunde la cererea dvs., serverul poate returna o indicație despre unde ar trebui să meargă browserul pentru a ajunge la pagina dorită în loc de pagina în sine. Antetul care indică o astfel de redirecționare către browser este „Locație:”.

În mod implicit, curl nu merge la adresa specificată în „Locație:”, ci pur și simplu afișează pagina ca de obicei. Dar o poți direcționa astfel:

# curl -L www.sitethatredirects.com

Dacă utilizați curl pentru a face solicitări POST către un site care redirecționează imediat către o altă pagină, puteți utiliza în siguranță combinația -L și -d/-F. Curl va genera o solicitare POST pentru prima pagină și apoi o solicitare GET pentru următoarea.

10. Cookie-uri

Cu cookie-uri, browserele web controlează starea din partea clientului. Un cookie este un nume cu conținut atașat. Prin trimiterea cookie-urilor, serverul spune clientului calea și numele gazdei către care cookie-urile ar trebui să fie trimise data viitoare, durata de viață a cookie-urilor și alți parametri.

Când un client se conectează la server la adresa specificată în cookie-ul acceptat, clientul trimite acel cookie către server (dacă durata de viață nu a expirat).

Multe aplicații și servere folosesc această metodă pentru a combina cereri multiple într-o singură sesiune logică. Pentru ca curl să îndeplinească și această funcție, trebuie să putem stoca și trimite cookie-uri, la fel cum fac browserele.

Cea mai simplă modalitate de a trimite un cookie către server atunci când primiți o pagină folosind curl este să adăugați comutatorul corespunzător pe linia de comandă:

# curl -b "nume=Daniel" www.cookiesite.com

Cookie-urile sunt trimise ca antete HTTP normale. Acest lucru permite curl să salveze cookie-uri prin păstrarea antetelor. Salvarea cookie-urilor folosind curl se face cu comanda:

# curl -D headers_and_cookies www.cookiesite.com

(apropo, pentru a salva cookie-uri este mai bine să utilizați comutatorul -c, mai multe despre asta mai jos).

curl are un handler complet de cookie-uri, care este util atunci când doriți să vă conectați din nou la server și să utilizați cookie-uri salvate ultima dată (sau modificate manual). Pentru a utiliza module cookie stocate într-un fișier, apelați curl astfel:

# curl -b cookie-uri stocate_în_fișier www.cookiesite.com

„Motorul cookie” al lui Curl este activat când specificați comutatorul -b. Dacă doriți doar ca curl să accepte module cookie, utilizați -b pentru a specifica un fișier care nu există. De exemplu, dacă doriți ca curl să accepte cookie-uri dintr-o pagină și apoi să urmeze o redirecționare (poate să renunțe la cookie-ul pe care tocmai l-a acceptat), puteți apela curl astfel:

# curl -b nada -L www.cookiesite.com

Curl poate citi și scrie cookie-uri în format Netscape și Mozilla. Aceasta este o modalitate convenabilă de a schimba module cookie între browsere și scripturi automate. Comutatorul -b detectează automat dacă un anumit cookie este cookie-ul browserelor specificate și îl gestionează în consecință, iar folosind comutatorul -c/--cookie-jar puteți forța curl să scrie un nou cookie când operațiunea se încheie:

# curl -b cookies.txt -c newcookies.txt www.cookiesite.com

11. HTTPS

Există mai multe moduri de a vă asigura transferurile HTTP. Cel mai cunoscut protocol care rezolvă această problemă este HTTPS sau HTTP peste SSL. SSL criptează toate datele trimise și primite prin rețea, crescând probabilitatea ca informațiile dvs. să rămână confidențiale.

Curl acceptă solicitări către serverele HTTPS folosind biblioteca gratuită OpenSSL. Solicitările apar în mod obișnuit:

# curl https://that.secure.server.com

11.1 Certificate

În lumea HTTPS, utilizați certificate pe lângă un nume de utilizator și o parolă pentru autentificare. Curl acceptă certificate la nivelul clientului. Toate certificatele sunt blocate cu o expresie de acces pe care trebuie să o introduceți înainte ca Curl să poată începe să lucreze cu ele. Fraza de acces poate fi specificată fie pe linia de comandă, fie introdusă interactiv. Certificatele în curl sunt utilizate după cum urmează:

# curl -E mycert.pem https://that.secure.server.com

Curl verifică, de asemenea, autenticitatea serverului prin verificarea certificatului serverului cu unul stocat local. Dacă există o discrepanță, curl va refuza să se conecteze. Pentru a ignora verificările de autentificare, utilizați comutatorul -k.

Mai multe informații despre certificate pot fi găsite la http://curl.haxx.se/docs/sslcerts.html.

12. Anteturi de solicitare personalizate

Este posibil să fie necesar să modificați sau să adăugați elemente ale solicitărilor individuale de curl.

De exemplu, puteți schimba solicitarea POST în PROPFIND și puteți trimite datele ca „Tip de conținut: text/xml” (în loc de tipul de conținut normal):

# curl -d " " -H "Tip de conținut: text/xml" -X PROPFIND url.com

Puteți elimina un titlu specificându-l fără conținut. De exemplu, ați putea elimina antetul „Gazdă:”, făcând astfel cererea „goală”:

# curl -H „Gazdă:” http://mysite.com

De asemenea, puteți adăuga titluri. Serverul dvs. poate avea nevoie de un antet „Destinație:”:

# curl -H „Destinație: http://moo.com/nowhere” http://url.com

13. Depanare

Se întâmplă adesea ca un site să răspundă la solicitările curl diferit decât la solicitările browserului. În acest caz, trebuie să faceți curl cât mai asemănător cu browserul:

Utilizați comutatorul --trace-ascii pentru a salva o înregistrare detaliată a interogărilor, astfel încât să le puteți examina în detaliu și să înțelegeți problema.
Asigurați-vă că verificați dacă există cookie-uri și le utilizați dacă este necesar (citiți -b și salvați -c)
Specificați unul dintre cele mai recente browsere populare în câmpul „user-agent”.
Completați câmpul „referer” așa cum o face browserul
Dacă utilizați solicitări POST, asigurați-vă că toate câmpurile sunt trimise în aceeași ordine ca browserul (vezi punctul 4.5 de mai sus)

Un bun ajutor în această sarcină dificilă este pluginul LiveHTTPHeader pentru Mozilla/Firefox, care vă permite să vizualizați toate anteturile pe care le trimite și le primește acest browser (chiar și atunci când utilizați HTTPS).

O abordare de nivel inferior este de a capta traficul HTTP în rețea folosind programe precum ethereal sau tcpdump și apoi analiza ce antete au fost primite și trimise de browser (HTTPS face această abordare ineficientă).

RFC 2616 este citit obligatoriu pentru oricine dorește să înțeleagă protocolul HTTP.

RFC 2396 explică sintaxa URL.

RFC 2109 definește modul în care funcționează cookie-urile.

RFC 1867 definește formatul Post pentru încărcare fișier.

http://openssl.planetmirror.com - Pagina principală a proiectului OpenSSL

http://curl.haxx.se - pagina principală a proiectului cURL

În ultimul articol am discutat cu tine. Cu toate acestea, uneori, scenariul acceptă doar solicitări GET(de obicei acestea sunt scripturi de căutare). Și pentru a procesa și a primi date din astfel de scripturi, trebuie să puteți trimiteți cereri GET în cURL de asemenea, ceea ce veți învăța citind acest articol.

Principiu trimiterea cererilor GET în cURL absolut la fel ca cu trimiterea folosind metoda POST: Există fișier sursă si aici este fișier destinație. Fișier sursă folosind modulul răsuci, trimite o solicitare GET la fișierul destinație. Fișierul destinație procesează această solicitare și returnează rezultatul, care este acceptat de fișierul sursă, folosind din nou capabilitățile răsuci.

Pentru a face totul absolut clar, să ne uităm la un exemplu simplu la care ne-am uitat când trimiterea cererilor POST. Adică, fișierul sursă trimite două numere, fișierul destinație returnează suma acestor numere, pe care fișierul sursă o primește și o scrie într-o variabilă, care este apoi scoasă în browser.

Pentru început, fișierul destinație (" receptor.php"):

$a = $_GET["a"];
$b = $_GET["b"];
eco $a + $b;
?>

Totul este foarte simplu aici: scriem în variabile $aȘi $b date de la cerere GET, iar apoi afișăm suma lor, care va fi acceptată de fișierul sursă.

Acum să creăm fișierul în sine -

În această postare, voi arăta cu exemple cum să utilizați cURL, unde este folosit și de ce ar trebui să îl înțelegeți dacă nu ați făcut-o deja.

Voi descrie pe scurt ce este și cu ce se mănâncă:

Guzzle a fost creat pentru a simplifica procesul de trimitere a cererilor HTTP. Adesea folosit pentru a trimite cereri către API si orice in general.

Exemplu real:

Aveți un API pe care l-ați dezvoltat recent și este timpul să începeți să lucrați cu el. Ai putea să-ți scrii propria bibliotecă sau chiar o mini-clasă pentru a lucra cu ea, dar (1) ți-ar lua mult timp și, chiar dacă nu ar fi, atunci cel mai probabil soluția nu ar fi cea mai bună, ( 2) trebuie susținut și îmbunătățit în mod constant. În acest caz, este mai bine să utilizați o soluție gata făcută, care este susținută de o comunitate mare, iar depozitul Guzzle are deja 12 mii de stele, ceea ce este foarte lăudabil.

Vă puteți întreba: De ce este necesar acest lucru dacă există deja o grămadă de biblioteci?

Guzzle a adunat tot ce este mai bun în sine, l-a făcut și mai bun și este acum cea mai populară bibliotecă PHP pentru lucrul cu solicitări HTTP. Este foarte tare, doar uită-te la simplitatea cererii:

// Creează un client cu un URI de bază $client = new GuzzleHttp\Client(["base_uri" => "http://site/"]); // Acum puteți trimite o solicitare la http://bologe.. Guzzle își amintește linkul de bază și acum puteți specifica doar paginile ulterioare pentru comoditate $response = $client->request("GET", "about");

Misto? Iubesc.

Documentația lui Guzzle este destul de extinsă, este imposibil să descrii fiecare opțiune, iar asta necesită o postare întreagă, pe care cu siguranță o voi scrie în curând :)

Postfaţă

Dacă aveți întrebări, scrieți-le mai jos la această postare și voi fi bucuros să vă ajut. De asemenea, dacă ai vreo corectură la articol și ai văzut o eroare pe undeva sau vrei să adaugi ceva, voi fi bucuros să te ascult.

cURL este un instrument special conceput pentru a transfera fișiere și date folosind sintaxa URL. Această tehnologie acceptă multe protocoale, cum ar fi HTTP, FTP, TELNET și multe altele. cURL a fost conceput inițial pentru a fi un instrument de linie de comandă. Din fericire pentru noi, biblioteca cURL este suportată de limbajul de programare PHP. În acest articol ne vom uita la unele dintre funcțiile avansate ale cURL și vom aborda, de asemenea, aplicarea practică a cunoștințelor dobândite folosind PHP.

De ce cURL?

De fapt, există destul de multe modalități alternative de a proba conținutul paginii web. În multe cazuri, în principal din cauza lenei, am folosit funcții PHP simple în loc de cURL:

$content = file_get_contents("http://www.nettuts.com"); // sau $linii = fisier("http://www.nettuts.com"); // sau readfile ("http://www.nettuts.com");

Cu toate acestea, aceste funcții practic nu au flexibilitate și conțin un număr mare de deficiențe în ceea ce privește gestionarea erorilor etc. În plus, există anumite sarcini pe care pur și simplu nu le puteți îndeplini cu aceste caracteristici standard: interacțiunea cookie-urilor, autentificarea, trimiterea formularelor, încărcarea fișierelor etc.

cURL este o bibliotecă puternică care acceptă multe protocoale și opțiuni diferite și oferă informații detaliate despre solicitările URL.

Structură de bază

Inițializare
Atribuirea parametrilor
Rezultatul execuției și preluarea
Eliberarea memoriei

// 1. initializare $ch = curl_init(); // 2. specificați parametrii, inclusiv url curl_setopt($ch, CURLOPT_URL, "http://www.nettuts.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_HEADER, 0); // 3. obține HTML ca rezultat $output = curl_exec($ch); // 4. închide conexiunea curl_close($ch);

Pasul #2 (adică apelarea curl_setopt()) va fi discutat mult mai mult în acest articol decât toți ceilalți pași, deoarece În această etapă, se întâmplă toate cele mai interesante și utile lucruri pe care trebuie să le știi. În cURL există un număr mare de opțiuni diferite care trebuie specificate pentru a putea configura solicitarea URL în cel mai atent mod. Nu vom lua în considerare întreaga listă, ci ne vom concentra doar pe ceea ce consider necesar și util pentru această lecție. Puteți studia singur orice altceva dacă acest subiect vă interesează.

Verificarea erorilor

În plus, puteți utiliza, de asemenea, instrucțiuni condiționale pentru a testa dacă o operațiune s-a finalizat cu succes:

// ... $ieșire = curl_exec($ch); if ($ieșire === FALSE) ( echo "cURL Error: " . curl_error($ch); ) // ...

Aici vă rog să rețineți un punct foarte important: trebuie să folosim „=== false” pentru comparație, în loc de „== fals”. Pentru cei care nu cunosc, acest lucru ne va ajuta să distingem între un rezultat gol și o valoare booleană false, ceea ce va indica o eroare.

Primirea informațiilor

Un alt pas suplimentar este obținerea datelor despre cererea cURL după ce aceasta a fost executată.

// ... curl_exec($ch); $info = curl_getinfo($ch); ecou „Luat” . $info["total_time"] . „secunde pentru url”. $info["url"]; //...

Matricea returnată conține următoarele informații:

"url"
"tipul de conținut"
„http_code”
„header_size”
„request_size”
"filetime"
„ssl_verify_result”
„redirect_count”
"timpul total"
„namelookup_time”
„connect_time”
„pretransfer_time”
„size_upload”
„size_download”
„viteză_descărcare”
„speed_upload”
„download_content_length”
„încărcare_conținut_lungime”
„starttransfer_time”
„redirect_time”

Detectarea redirecționării în funcție de browser

În acest prim exemplu, vom scrie cod care poate detecta redirecționările URL pe baza diferitelor setări ale browserului. De exemplu, unele site-uri web redirecționează browserele unui telefon mobil sau ale oricărui alt dispozitiv.

Vom folosi opțiunea CURLOPT_HTTPHEADER pentru a defini antetele noastre HTTP de ieșire, inclusiv numele browserului utilizatorului și limbile disponibile. În cele din urmă, vom putea determina ce site-uri ne redirecționează către adrese URL diferite.

// testează URL-ul $urls = array("http://www.cnn.com", "http://www.mozilla.com", "http://www.facebook.com"); // testarea browserelor $browsers = array("standard" => 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" => array ("user_agent" => "Mozilla/5.0 (iPhone; U); ; CPU ca Mac OS X; ro) AppleWebKit/420+ (KHTML, cum ar fi Gecko) Versiunea/3.0 Mobile/1A537a Safari/419.3", "limba" => "ro"), "franceză" => matrice ("user_agent" => "Mozilla/4.0 (compatibil; MSIE 7.0; Windows NT 5.1; GTB6; .NET CLR 2.0.50727)", "limba" => "fr,fr-FR;q=0.5"); foreach ($urls ca $url) ( echo "URL: $url\n"; foreach ($browsers ca $test_name => $browser) ( $ch = curl_init(); // specificați adresa URL curl_setopt($ch, CURLOPT_URL , $url); // se specifică anteturile pentru browser curl_setopt($ch, CURLOPT_HTTPHEADER, array("User-Agent: ($browser["user_agent"])", "Accept-Language: ($browser["language"] )" )); // nu avem nevoie de conținutul paginii curl_setopt($ch, CURLOPT_NOBODY, 1); // trebuie să obținem antete HTTP curl_setopt($ch, CURLOPT_HEADER, 1); // returnăm rezultate în schimb de ieșire curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); $output = curl_exec($ch); curl_close($ch); // a existat o redirecționare HTTP? if (preg_match("!Location: (.*)!"), $ieșire, $potriviri)) ( echo " $nume_test: redirecționează către $potriviri\n"; ) else ( echo "$nume_test: fără redirecționare\n"; ) ) echo "\n\n"; )

Mai întâi, specificăm o listă de adrese URL ale site-urilor pe care le vom verifica. Mai exact, avem nevoie de adresele acestor site-uri. În continuare, trebuie să definim setările browserului pentru a testa fiecare dintre aceste adrese URL. După aceasta, vom folosi o buclă în care vom parcurge toate rezultatele obținute.

Trucul pe care îl folosim în acest exemplu pentru a seta setările cURL ne va permite să obținem nu conținutul paginii, ci doar anteturile HTTP (stocate în $output). Apoi, folosind o regex simplă, putem determina dacă șirul „Locație:” a fost prezent în anteturile primite.

Când rulați acest cod, ar trebui să obțineți ceva de genul acesta:

Crearea unei cereri POST la o anumită adresă URL

Când se formează o solicitare GET, datele transmise pot fi transmise la adresa URL printr-un „șir de interogare”. De exemplu, când efectuați o căutare pe Google, termenul de căutare este plasat în bara de adrese a noii adrese URL:

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

Nu trebuie să utilizați cURL pentru a simula această solicitare. Dacă lenea te învinge complet, folosește funcția „file_get_contents()” pentru a obține rezultatul.

Dar chestia este că unele formulare HTML trimit solicitări POST. Datele acestor formulare sunt transportate prin corpul cererii HTTP, și nu ca în cazul precedent. De exemplu, dacă ați completat un formular pe un forum și ați făcut clic pe butonul de căutare, atunci cel mai probabil va fi făcută o solicitare POST:

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

Putem scrie un script PHP care poate simula acest tip de solicitare URL. Mai întâi să creăm un fișier simplu pentru a accepta și afișa datele POST. Să-i spunem post_output.php:

Print_r($_POST);

Apoi creăm un script PHP pentru a face cererea cURL:

$url = "http://localhost/post_output.php"; $post_data = array ("foo" => "bar", "query" => "Nettuts", "action" => "Submit"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // indică faptul că avem o cerere POST curl_setopt($ch, CURLOPT_POST, 1); // adaugă variabile curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $ieșire = curl_exec($ch); curl_close($ch); echo $ieșire;

Când rulați acest script, ar trebui să obțineți un rezultat ca acesta:

Astfel, cererea POST a fost trimisă către scriptul post_output.php, care la rândul său scoate matricea superglobală $_POST, al cărui conținut l-am obținut folosind cURL.

Încărcarea unui fișier

Mai întâi, să creăm un fișier pentru a-l genera și a-l trimite în fișierul upload_output.php:

Print_r($_FILES);

Și iată codul de script care realizează funcționalitatea de mai sus:

$url = "http://localhost/upload_output.php"; $post_data = matrice ("foo" => "bar", // fișier pentru a încărca "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); $ieșire = curl_exec($ch); curl_close($ch); echo $ieșire;

Când doriți să încărcați un fișier, tot ce trebuie să faceți este să îl transmiteți ca o variabilă post normală, precedată de simbolul @. Când rulați scriptul scris, veți obține următorul rezultat:

CURL multiple

Unul dintre cele mai mari puncte forte ale cURL este capacitatea de a crea „mai multe” handlere de cURL. Acest lucru vă permite să deschideți o conexiune la mai multe adrese URL simultan și asincron.

În versiunea clasică a cererii cURL, execuția scriptului este suspendată și așteaptă finalizarea operației de solicitare URL, după care scriptul poate continua. Dacă intenționați să interacționați cu o mulțime de adrese URL, aceasta va duce la o investiție destul de semnificativă de timp, deoarece în versiunea clasică puteți lucra doar cu o singură adresă URL la un moment dat. Cu toate acestea, putem corecta această situație utilizând handlere speciali.

Să ne uităm la exemplul de cod pe care l-am luat de la php.net:

// creează mai multe resurse cURL $ch1 = curl_init(); $ch2 = curl_init(); // specificați URL-ul și alți parametri 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); //creez un handler cURL multiplu $mh = curl_multi_init(); //adăugați mai mulți handlere curl_multi_add_handle($mh,$ch1); curl_multi_add_handle($mh,$ch2); $activ = nul; //execuți do ($mrc = curl_multi_exec($mh, $activ); ) while ($mrc == CURLM_CALL_MULTI_PERFORM); while ($activ && $mrc == CURLM_OK) ( dacă (curl_multi_select($mh) != -1) ( do ( $mrc = curl_multi_exec($mh, $activ); ) while ($mrc == CURLM_CALL_MULTI_PERFORM); ) ) //închidere curl_multi_remove_handle($mh, $ch1); curl_multi_remove_handle($mh, $ch2); curl_multi_close($mh);

Ideea este că puteți utiliza mai mulți handlere cURL. Folosind o buclă simplă, puteți urmări ce solicitări nu au fost încă finalizate.

Există două bucle principale în acest exemplu. Prima buclă do-while apelează curl_multi_exec(). Această funcție nu este blocabilă. Acesta rulează cât de repede poate și returnează starea cererii. Atâta timp cât valoarea returnată este constanta „CURLM_CALL_MULTI_PERFORM”, aceasta înseamnă că munca nu este încă finalizată (de exemplu, anteturile http sunt trimise în prezent la adresa URL); De aceea continuăm să verificăm această valoare returnată până când obținem un rezultat diferit.

În bucla următoare verificăm condiția în timp ce variabila $activ = „adevărat”. Este al doilea parametru al funcției curl_multi_exec(). Valoarea acestei variabile va fi „adevărată” atâta timp cât oricare dintre modificările existente este activă. Apoi apelăm funcția curl_multi_select(). Execuția acestuia este „blocata” cât timp există cel puțin o conexiune activă, până când se primește un răspuns. Când se întâmplă acest lucru, ne întoarcem la bucla principală pentru a continua să executăm interogări.

Acum să aplicăm aceste cunoștințe la un exemplu care va fi cu adevărat util pentru un număr mare de oameni.

Verificarea linkurilor în WordPress

Imaginați-vă un blog cu un număr mare de postări și mesaje, fiecare dintre acestea conținând link-uri către resurse externe de internet. Unele dintre aceste link-uri ar putea fi deja moarte din diverse motive. Este posibil ca pagina să fi fost ștearsă sau este posibil ca site-ul să nu funcționeze deloc.

Vom crea un script care va analiza toate linkurile și va găsi site-uri web care nu se încarcă și 404 pagini, apoi ne va furniza un raport detaliat.

Permiteți-mi să spun imediat că acesta nu este un exemplu de creare a unui plugin pentru WordPress. Acesta este un teren de testare absolut bun pentru testele noastre.

Să începem în sfârșit. Mai întâi trebuie să preluăm toate linkurile din baza de date:

// configurare $db_host = "localhost"; $db_user = „rădăcină”; $db_pass = ""; $db_name = "wordpress"; $excluded_domains = array("localhost", "www.mydomain.com"); $max_connections = 10; // inițializarea variabilelor $url_list = array(); $working_urls = array(); $dead_urls = array(); $not_found_urls = array(); $activ = nul; // se conectează la MySQL dacă (!mysql_connect($db_host, $db_user, $db_pass)) ( die("Nu s-a putut conecta: " . mysql_error()); ) if (!mysql_select_db($db_name)) ( die("Poate nu selectează db: " . mysql_error()); ) // selectează toate postările publicate care au legături $q = "SELECTAȚI post_content FROM wp_posts WHERE post_content LIKE "%href=%" AND post_status = "publish" AND post_type = "post" "; $r = mysql_query($q) sau die(mysql_error()); while ($d = mysql_fetch_assoc($r)) ( // preia link-uri folosind expresii regulate if (preg_match_all("!href=\"(.*?)\"!", $d["post_content"], $ potriviri) ) ( foreach ($se potrivește ca $url) ( $tmp = parse_url($url); if (in_array($tmp["gazdă"], $excluded_domains)) (continuare; ) $url_list = $url; ) ) ) / / elimina duplicatele $url_list = array_values(array_unique($url_list)); if (!$url_list) ( die("Fără URL de verificat"); )

Mai întâi, generăm date de configurare pentru interacțiunea cu baza de date, apoi scriem o listă de domenii care nu vor participa la verificare ($excluded_domains). De asemenea, definim un număr care caracterizează numărul maxim de conexiuni simultane pe care le vom folosi în scriptul nostru ($max_connections). Apoi ne alăturăm bazei de date, selectăm postările care conțin link-uri și le acumulăm într-o matrice ($url_list).

Următorul cod este puțin complicat, așa că parcurgeți-l de la început până la sfârșit:

// 1. handler multiplu $mh = curl_multi_init(); // 2. adăugați un set de adrese URL pentru ($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; } }

Aici voi încerca să explic totul în detaliu. Numerele din listă corespund numerelor din comentariu.

1. Creați un handler multiplu;
2. Vom scrie funcția add_url_to_multi_handle() puțin mai târziu. De fiecare dată când este apelat, va începe procesarea unei noi adrese URL. Inițial, adăugăm 10 ($max_connections) URL-uri;
3. Pentru a începe, trebuie să rulăm funcția curl_multi_exec(). Atâta timp cât returnează CURLM_CALL_MULTI_PERFORM, mai avem ceva de făcut. Avem nevoie de asta în principal pentru a crea conexiuni;
4. Urmează bucla principală, care va rula atâta timp cât avem cel puțin o conexiune activă;
5. curl_multi_select() se blochează așteptând finalizarea căutării URL;
6. Încă o dată, trebuie să obținem cURL pentru a lucra, și anume să preluăm datele răspunsului returnat;
7. Informațiile sunt verificate aici. Ca urmare a executării cererii, va fi returnată o matrice;
8. Matricea returnată conține un handler cURL. Îl vom folosi pentru a selecta informații despre o solicitare separată de cURL;
9. Dacă linkul a fost mort sau scriptul a expirat, atunci nu ar trebui să căutăm niciun cod http;
10. Dacă linkul ne-a returnat o pagină 404, atunci codul http va conține valoarea 404;
11. În caz contrar, avem o legătură de lucru în fața noastră. (Puteți adăuga verificări suplimentare pentru codul de eroare 500, etc...);
12. În continuare eliminăm handlerul cURL pentru că nu mai avem nevoie de el;
13. Acum putem adăuga o altă adresă URL și rula tot ce am vorbit înainte;
14. La acest pas, scriptul își finalizează munca. Putem elimina tot ce nu avem nevoie și putem genera un raport;
15. În cele din urmă, vom scrie o funcție care va adăuga url la handler. Variabila statică $index va fi incrementată de fiecare dată când această funcție este apelată.

Am folosit acest script pe blogul meu (cu câteva link-uri rupte pe care le-am adăugat intenționat pentru a-l testa) și am obținut următorul rezultat:

În cazul meu, scriptul a durat puțin mai puțin de 2 secunde pentru a se accesa cu crawlere prin 40 de adrese URL. Creșterea performanței este semnificativă atunci când lucrați cu și mai multe adrese URL. Dacă deschideți zece conexiuni în același timp, scriptul se poate executa de zece ori mai repede.

Câteva cuvinte despre alte opțiuni utile de cURL

Autentificare HTTP

Dacă adresa URL are autentificare HTTP, atunci puteți utiliza cu ușurință următorul script:

$url = "http://www.somesite.com/members/"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // specificam numele de utilizator si parola curl_setopt($ch, CURLOPT_USERPWD, "myusername:mypassword"); // dacă redirecționarea este permisă curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // apoi salvăm datele noastre în cURL curl_setopt($ch, CURLOPT_UNRESTRICTED_AUTH, 1); $ieșire = curl_exec($ch); curl_close($ch);

Încărcare FTP

PHP are și o bibliotecă pentru lucrul cu FTP, dar nimic nu vă împiedică să utilizați instrumentele cURL aici:

// deschide fisierul $file = fopen("/path/to/file", "r"); // URL-ul ar trebui să conțină următorul conținut $url = "ftp://nume utilizator: [email protected]:21/path/to/new/file"; $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")); // specificați modul ASCII curl_setopt($ch, CURLOPT_FTPASCII, 1); $output = curl_exec ($ch); curl_close($ch);

Folosind Proxy

Puteți efectua solicitarea URL printr-un proxy:

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://www.example.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // specifica adresa curl_setopt($ch, CURLOPT_PROXY, "11.11.11.11:8080"); // dacă trebuie să furnizați un nume de utilizator și o parolă curl_setopt($ch, CURLOPT_PROXYUSERPWD,"user:pass"); $ieșire = curl_exec($ch); curl_close($ch);

Funcții de apel invers

De asemenea, este posibil să specificați o funcție care va fi declanșată chiar înainte de finalizarea cererii cURL. De exemplu, în timp ce conținutul răspunsului se încarcă, puteți începe să utilizați datele fără a aștepta să se încarce complet.

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

O funcție ca aceasta TREBUIE să returneze lungimea șirului, ceea ce este o cerință.

Concluzie

Astăzi am învățat cum puteți folosi biblioteca cURL în propriile scopuri egoiste. Sper că v-a plăcut acest articol.

Mulțumesc! Să aveţi o zi bună!