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 reușește:

// ... $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 en) AppleWebKit/420+ (KHTML, ca Gecko) Versiune/3.0 Mobile/1A537a Safari/419.3", "language" => "en"), "franceză" => array ("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ă antetele 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 loc de ieșire curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); $output = curl_exec($ch); , $matches) ( echo " $test_name: redirecționează către $matches\n"; ) else ( echo "$test_name: no redirection\n"; ) ) echo "\n\n" )

Mai întâi, specificăm o listă de adrese URL ale site-urilor pe care le vom verifica. Mai exact, vom avea 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 = array ("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 operațiunea URL de solicitare așteaptă finalizarea, după care scriptul poate continua să ruleze. 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 not select db: " . mysql_error()); ) // selectează toate postările publicate cu link-uri $q = "SELECTează 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. 1. Creați un handler multiplu;
2. 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. 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. 4. Urmează bucla principală, care va rula atâta timp cât avem cel puțin o conexiune activă;
5. 5. curl_multi_select() se blochează așteptând finalizarea căutării URL;
6. 6. Încă o dată, trebuie să facem cURL să lucreze, și anume să preluăm datele răspunsului returnat;
7. 7. Informațiile sunt verificate aici. Ca urmare a executării cererii, va fi returnată o matrice;
8. 8. Matricea returnată conține un handler cURL. Îl vom folosi pentru a selecta informații despre o solicitare separată de cURL;
9. 9. Dacă linkul a fost mort sau scriptul a expirat, atunci nu ar trebui să căutăm niciun cod http;
10. 10. Dacă linkul ne-a returnat o pagină 404, atunci codul http va conține valoarea 404;
11. 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. 12. În continuare eliminăm handlerul cURL pentru că nu mai avem nevoie de el;
13. 13. Acum putem adăuga un alt URL și rula tot ce am vorbit înainte;
14. 14. La acest pas, scriptul își finalizează munca. Putem elimina tot ce nu avem nevoie și putem genera un raport;
15. 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 $fisier = fopen("/cale/la/fisier", "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"); ); 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ă!

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.

Odată cu numărul tot mai mare de aplicații care se deplasează pe web, 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ă știi deja unde să tastezi

# 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 când faceți clic pe butonul OK, veți fi dus la adresa URL „www.hotmail.com/when/junk.cgi? anul nașterii=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, de asemenea, 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 din sistemul 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 puteți pune orice în câmpul „referer” și astfel îl puteți face să facă ceea ce doriți.

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 este diferită de 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 îi spune browserului să redirecționeze 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 stocarea 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 îl puteți forța pe 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ă securiza comunicațiile 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 la 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 ca această abordare să fie 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

Viața unui dezvoltator web este tulburată de dificultăți. Este deosebit de neplăcut atunci când sursa acestor dificultăți este necunoscută. Este aceasta o problemă cu trimiterea cererii, sau cu răspunsul, sau cu o bibliotecă terță parte sau API-ul extern are erori? Există o mulțime de gadgeturi diferite care ne pot face viața mai ușoară. Iată câteva instrumente de linie de comandă pe care personal le găsesc de neprețuit.

răsuci
cURL este un program pentru transferul de date prin diferite protocoale, similar cu wget. Principala diferență este că, în mod implicit, wget salvează într-un fișier, în timp ce cURL iese în linia de comandă. Acest lucru face foarte ușor să vizualizați conținutul site-ului. De exemplu, iată cum să obțineți rapid IP-ul extern curent:

$ curl ifconfig.me 93.96.141.93
Opțiuni -i(arata titluri) si -Eu(afișați numai antetele) fac din cURL un instrument excelent pentru depanarea răspunsurilor HTTP și pentru a analiza exact ce vă trimite serverul:

$ curl -I habrahabr.ru HTTP/1.1 200 OK Server: nginx Data: Thu, 18 Aug 2011 14:15:36 GMT Content-Type: text/html; charset=utf-8 Conexiune: keep-alive Keep-alive: timeout=25
Parametru -L De asemenea, util, forțează cURL să urmărească automat redirecționările. cURL acceptă autentificare HTTP, cookie-uri, tunelare prin proxy HTTP, setări manuale în anteturi și multe, multe altele.

Asediu
Siege este un instrument de testare a sarcinii. În plus, are o opțiune convenabilă -g, care este foarte asemănător cu curl –iL, dar în plus vă arată și antetele cererii http. Iată un exemplu de pe google.com (unele titluri au fost eliminate pentru concizie):

$ siege -g www.google.com GET / HTTP/1.1 Gazdă: www.google.com User-Agent: JoeDog/1.00 (X11; I; Siege 2.70) Conexiune: închide HTTP/1.1 302 Locație găsită: http:// www.google.co.uk/ Tip de conținut: text/html; charset=UTF-8 Server: gws Lungimea conținutului: 221 Conexiune: închide GET / HTTP/1.1 Gazdă: www.google.co.uk Agent utilizator: JoeDog/1.00 (X11; I; Siege 2.70) Conexiune: închide HTTP/ 1.1 200 OK Tip de conținut: text/html; set de caractere=ISO-8859-1 X-XSS-Protecție: 1; mode=block Conexiune: close
Dar ceea ce este cu adevărat excelent pentru Siege este testarea încărcării. Ca și benchmark-ul Apache ab, poate trimite multe solicitări paralele către site și poate vedea cum gestionează traficul. Următorul exemplu arată cum testăm Google cu 20 de interogări timp de 30 de secunde și apoi tipărim rezultatul:

$ siege -c20 www.google.co.uk -b -t30s ... Ridicarea asediului serverului... gata. Tranzacții: 1400 de accesări Disponibilitate: 100,00 % Timp scurs: 29,22 secunde Date transferate: 13,32 MB Timp de răspuns: 0,41 secunde Rata tranzacției: 47,91 trans/sec Debit: 0,46 MB/sec Concurență: 19,53 Tranzacții reușite: 40 tranzacții cu succes: 4,08 Cea mai scurtă tranzacție: 0,08
Una dintre cele mai utile caracteristici ale Siege este că poate funcționa nu numai cu o singură adresă, ci și cu o listă de adrese URL dintr-un fișier. Acest lucru este grozav pentru testarea de încărcare, deoarece puteți simula traficul real pe site, în loc să atingeți aceeași adresă URL din nou și din nou. De exemplu, iată cum să utilizați Siege pentru a încărca un server folosind adrese din jurnalul dvs. Apache:

$ cut -d " " -f7 /var/log/apache2/access.log > urls.txt $ siege -c -b -f urls.txt
Ngrep
Pentru o analiză serioasă a traficului, există Wireshark cu mii de setări, filtre și configurații. Există și o versiune de linie de comandă rechinul. Dar pentru sarcini simple, consider funcționalitatea Wireshark redundantă. Deci, dacă nu am nevoie de o armă puternică, folosesc . Vă permite să faceți același lucru cu pachetele de rețea ca grep face cu fișierele.

Pentru traficul web, aproape întotdeauna veți dori să utilizați parametrul -W pentru a păstra formatarea șirurilor, precum și opțiunea -q, care ascunde informații redundante despre pachetele nepotrivite. Iată un exemplu de comandă care interceptează toate pachetele cu o comandă GET sau POST:

Ngrep -q -W byline "^(GET|POST).*"
Puteți adăuga un filtru suplimentar pentru pachete, de exemplu, după o anumită gazdă, adresă IP sau port. Iată un filtru pentru tot traficul către și dinspre google.com, portul 80, care conține cuvântul „căutare”.

Ngrep -q -W gazdă „căutare” de la linia de bază www.google.com și portul 80

CURL este un pachet software format dintr-un utilitar de linie de comandă și o bibliotecă pentru transferul de date folosind sintaxa URL.

CURL acceptă multe protocoale, inclusiv DICT, FILE, FTP, FTPS, Gopher, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, POP3, POP3S, RTMP, RTSP, SCP, SFTP, SMTP, SMTPS, Telnet și TFTP.

Încărcați fișier separat
Următoarea comandă va obține conținutul URL-ului și îl va afișa pe ieșirea standard (adică terminalul dvs.).

Curl https://mi-al.ru/ > mi-al.htm % Total % primit % Xferd Viteza medie Timp Timp Descărcare curent Încărcare Total cheltuit Viteza stângă 100 14378 0 14378 0 0 5387 0 --: --:- - 0:00:02 --:--:-- 5387

Salvarea ieșirii cURL într-un fișier
Putem salva rezultatul comenzii curl într-un fișier folosind opțiunile -o/-O.

• -o(o litere mici) rezultatul va fi salvat în fișierul specificat în linia de comandă
• -O(O majusculă) numele fișierului va fi preluat de la adresa URL și va fi folosit pentru a salva datele primite.

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

Pagina gettext.html va fi acum salvată într-un fișier numit „mygettext.html”. Când curl este rulat cu opțiunea -o, acesta afișează bara de progres al descărcarii după cum urmează.

% Total % primit % Xferd Viteză medie Timp Timp Timp Descărcare curent Încărcare Total cheltuit Viteză rămasă 66 1215k 66 805k 0 0 33060 0 0:00:37 0:00:24 0:00:13 45900 100 12015k 12015k 0 0 39474 0 0:00:31 0:00:31 --:--:-- 68987

Când utilizați curl -O (O majusculă), acesta va salva în sine conținutul într-un fișier numit „gettext.html” pe computerul local.

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

Notă: Când curl trebuie să scrie date pe terminal, dezactivează bara de progres pentru a evita confuzia cu datele tipărite. Putem folosi opțiunile '>'|'-o'|'-O' pentru a transfera rezultatele într-un fișier.

Preluarea mai multor fișiere simultan
Putem descărca mai multe fișiere simultan, specificând toate adresele URL pe linia de comandă.

Curl -O URL1 -O URL2

Comanda de mai jos va descărca atât index.html, cât și gettext.html și le va salva cu aceleași nume în directorul curent.

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

Vă rugăm să rețineți că atunci când descarcăm mai multe fișiere de pe același server așa cum se arată mai sus, curl va încerca să refolosească conexiunea.

Urmați anteturile de locație HTTP cu opțiunea -L
În mod implicit, CURL nu urmează Locația HTTP în anteturi (redirecționări). Când pagina web solicitată este mutată într-o altă locație, răspunsul corespunzător va fi trimis în anteturile Locație HTTP.
De exemplu, când cineva introduce google.com în browser din țara sa, va fi redirecționat automat către „google.co.xx”. Acest lucru se face pe baza antetului Locație HTTP, așa cum se arată mai jos.

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

302 Mutat

Documentul a fost mutat aici.

Rezultatul de mai sus spune că documentul solicitat a fost mutat în „

Ascuns de oaspeți

.
Puteți spune lui curl să urmeze redirecționările, acest lucru se face folosind opțiunea -L așa cum se arată mai jos. Acum codul sursă html va fi descărcat de pe

Ascuns de oaspeți

.

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

Reînnoirea unei descărcări anterioare

Folosind opțiunea -C puteți continua o descărcare care a fost oprită dintr-un motiv oarecare. Acest lucru va fi util atunci când descărcarea fișierelor mari eșuează.
Dacă spunem „-C -”, atunci curl va căuta de unde să reia descărcarea. De asemenea, putem specifica '-C<смещение>’. Offset-ul de octeți specificat va fi omis de la începutul fișierului sursă.
Începeți o descărcare mare cu curl și apăsați Ctrl-C pentru a o opri la mijlocul descărcării.

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

Injectarea a fost oprită la 20,1%. Folosind „curl -C -” putem continua încărcarea de unde am rămas. Acum descărcarea va continua de la 20,1%.

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

Limita ratei de date
Puteți limita rata de transfer de date utilizând opțiunea –limit-rate. Puteți trece viteza maximă ca argument.

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

Comanda de mai sus va limita rata de transfer la 1000 de octeți/secundă. curl poate folosi viteze mai mari în vârfuri. Dar viteza medie va fi de aproximativ 1000 de octeți/secundă.
Mai jos este bara de progres pentru comanda de mai sus. Puteți vedea că viteza actuală este de aproximativ 1000 de octeți.

% Total % primit % Xferd Viteză medie Timp Timp Timp Descărcare curent Încărcare Total cheltuit Viteză rămasă 1 1215k 1 13601 0 0 957 0 0:21:40 0:00:14 0:21:26 999 1 1215k 1 14601 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

Încărcați un fișier numai dacă a fost modificat înainte/după o oră specificată
Puteți obține fișiere care s-au schimbat după un anumit timp folosind opțiunea -z din curl. Acest lucru va funcționa atât pentru FTP, cât și pentru HTTP.

Comanda de mai sus va încărca yy.html numai dacă a fost modificată mai recent decât data și ora dată.

Comanda de mai sus va încărca file.html dacă a fost modificat înainte de data și ora dată. Tastați „man curl_getdate” pentru a afla mai multe despre diferitele sintaxe acceptate pentru expresiile de dată.

Se trece autentificarea HTTP în cURL
Uneori, site-urile web necesită un nume de utilizator și o parolă pentru a le vizualiza conținutul. Folosind opțiunea -u, puteți transmite aceste acreditări de la cURL la serverul web, așa cum se arată mai jos.

$ curl -u nume utilizator:parolă URL

Notă: În mod implicit, curl utilizează autentificarea de bază HTTP. Putem seta alte metode de autentificare folosind –ntlm | -digera.

cURL poate fi folosit și pentru a descărca fișiere de pe serverele FTP. Dacă calea FTP specificată este un director, atunci în mod implicit va fi afișată o listă de fișiere din acesta.

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

Comanda de mai sus va descărca fișierul xss.php de pe serverul ftp și îl va salva într-un director local.

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

Aici URL-ul se referă la un director. Prin urmare, cURL va lista fișiere și directoare la adresa URL dată.

CURL acceptă intervalele specificate în adrese URL. Când este dat un interval, fișierele corespunzătoare din acel interval vor fi încărcate. Acest lucru va fi util atunci când descărcați pachete de pe site-urile oglindă FTP.

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

Comanda de mai sus va lista toate pachetele din intervalul a-z din terminal.

Încărcarea fișierelor pe un server FTP
Curl poate fi folosit și pentru a încărca pe un server FTP cu opțiunea -T.

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

Comanda de mai sus va încărca un fișier numit myfile.txt pe serverul FTP. De asemenea, puteți încărca mai multe fișiere simultan folosind intervale.

$ curl -u ftpuser:ftppass -T "(fișier1, fișier2)" ftp://ftp.testserver.com

Opțional putem folosi „.” pentru a primi de la intrarea standard și a o transmite mașinii de la distanță.

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

Comanda de mai sus va primi rezultatul de la utilizator de la intrarea standard și va stoca conținutul pe serverul ftp ca „fișierul_1.txt”.
Puteți specifica „-T” pentru fiecare adresă URL, iar fiecare pereche adresă-fișier va determina ce să încarce unde

Mai multe informații cu o nivel de verbozitate crescută și opțiune de urmărire
Puteți afla ce se întâmplă folosind opțiunea -v. Opțiunea -v activează modul verbal și va imprima detalii.

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

Comanda de mai sus va scoate următoarele

* Adresa URL reconstruită la: https://www.google.co.th/?gws_rd=ssl * Numele de gazdă NU a fost găsit în memoria cache DNS * Încercând 27.123.17.49... * Conectat la www.google.co.th (27.123. 17.49) portul 80 (#0) > GET / HTTP/1.1 > User-Agent: curl/7.38.0 > Gazdă: www.google.co.th > Accept: */* >< 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 ... ... ...

Dacă aveți nevoie de informații mai detaliate, atunci puteți utiliza opțiunea –trace. Opțiunea –trace va permite un dump complet de urmărire a tuturor datelor de intrare/ieșire pentru un anumit fișier

De multe ori trebuie să descărcam diverse fișiere de pe Internet, de exemplu, fișiere de program executabile, fișiere script, arhive sursă. Dar acest lucru nu trebuie făcut întotdeauna prin intermediul browserului. În multe situații este mult mai ușor să efectuați toate acțiunile prin intermediul terminalului. Pentru că astfel poți automatiza procesul. Pe de altă parte, webmasterii din când în când trebuie să testeze accesibilitatea site-ului web, să verifice anteturile trimise și primite și multe altele.

Pentru a rezolva astfel de probleme și probleme dintr-o gamă similară, puteți utiliza utilitarul curl. Vă permite să rezolvați o gamă mult mai largă de probleme, inclusiv simularea acțiunilor utilizatorului pe site. În acest articol ne vom uita la cum să folosiți curl, ce este și de ce este necesar acest program.

De fapt, curl este mai mult decât un utilitar de linie de comandă pentru Linux sau Windows. Acesta este un set de biblioteci care implementează capabilitățile de bază de lucru cu pagini URL și transfer de fișiere. Biblioteca acceptă lucrul cu protocoale: FTP, FTPS, HTTP, HTTPS, TFTP, SCP, SFTP, Telnet, DICT, LDAP, precum și POP3, IMAP și SMTP. Este excelent pentru a simula acțiunile utilizatorului pe pagini și alte operațiuni cu adrese URL.

Suportul pentru biblioteca curl a fost adăugat la multe limbaje și platforme de programare diferite. Utilitarul curl este un înveliș independent pentru această bibliotecă. Este acest utilitar pe care ne vom concentra în acest articol.

comanda curl

Înainte de a trece la o descriere a modului în care poate fi utilizată comanda curl linux, să ne uităm la utilitarul în sine și la opțiunile sale principale de care vom avea nevoie. Sintaxa utilitarului este foarte simplă:

link pentru opțiuni curl $

Acum să ne uităm la opțiunile principale:

• -# - afișarea unei simple bare de progres în timpul încărcării;
• -0 - utilizați protocolul http 1.0;
• -1 - utilizați protocolul de criptare tlsv1;
• -2 - utilizați sslv2;
• -3 - utilizați sslv3;
• -4 - utilizați ipv4;
• -6 - utilizați ipv6;
• -A- indicați USER_AGENT;
• -b- salvați cookie într-un fișier;
• -c- trimite Cookie către server dintr-un fișier;
• -C- continua descărcarea fișierului de la punctul de întrerupere sau offset specificat;
• -m- timp maxim de asteptare pentru un raspuns de la server;
• -d- trimite datele folosind metoda POST;
• -D- salvați anteturile returnate de server într-un fișier;
• -e- setați câmpul Referer-uri, indicând de ce site provine utilizatorul;
• -E- utilizați un certificat SSL extern;
• -f- nu afisati mesaje de eroare;
• -F- trimite datele sub forma unui formular;
• -G- daca aceasta optiune este activata, atunci toate datele specificate in optiunea -d vor fi transmise folosind metoda GET;
• -H- transfera antete pe server;
• -Eu- primiți doar antetul HTTP și ignorați întregul conținut al paginii;
• -j- citește și trimite cookie-uri dintr-un fișier;
• -J- eliminați antetul din cerere;
• -L- acceptă și procesează redirecționări;
• -s- numărul maxim de redirecționări folosind Locație;
• -o- scoaterea conținutului paginii într-un fișier;
• -O- salvarea conținutului într-un fișier cu numele paginii sau al fișierului de pe server;
• -p- utilizați un proxy;
• --proto- indicați protocolul care trebuie utilizat;
• -R- salvați ultima oră de modificare a unui fișier de la distanță;
• -s- afișarea unui minim de informații despre erori;
• -S- afișarea mesajelor de eroare;
• -T- încărcați fișierul pe server;
• -v- rezultatul cel mai detaliat;
• -y- viteza minima de download;
• -Y- viteza maxima de download;
• -z- descărcați fișierul numai dacă a fost modificat mai târziu decât ora specificată;
• -V- afișați versiunea.

Acestea nu sunt în niciun caz toate opțiunile pentru curl linux, dar listează elementele de bază pe care va trebui să le utilizați.

Cum se folosește curl?

Am acoperit tot ce ține de teoria lucrului cu utilitarul curl, acum este timpul să trecem la practică și să privim exemple ale comenzii curl.

Cea mai comună sarcină este aceasta. Descărcarea fișierului este foarte simplă. Pentru a face acest lucru, trebuie doar să transmiteți numele fișierului sau pagina html utilitarului în parametri:

curl https://raw.githubusercontent.com/curl/curl/master/README.md

Dar aici vă așteaptă o surpriză: întregul conținut al fișierului va fi trimis la ieșire standard. Pentru a-l scrie în orice fișier, utilizați:

curl -o readme.txt https://raw.githubusercontent.com/curl/curl/master/README.md

Și dacă doriți ca fișierul rezultat să fie numit la fel ca fișierul de pe server, utilizați opțiunea -O:

curl -O https://raw.githubusercontent.com/curl/curl/master/README.md

curl -# -C - -O https://cdn.kernel.org/pub/linux/kernel/v4.x/testing/linux-4.11-rc7.tar.xz

Dacă este necesar, puteți descărca mai multe fișiere cu o singură comandă:

curl -O https://raw.githubusercontent.com/curl/curl/master/README.md -O https://raw.githubusercontent.com/curl/curl/master/README

Un alt lucru care poate fi util pentru un administrator este să descarce un fișier numai dacă acesta a fost modificat:

curl -z 21-Dec-17 https://raw.githubusercontent.com/curl/curl/master/README.md -O https://raw.githubusercontent.com/curl/curl/master/README

Limită de viteză

Puteți limita viteza de descărcare la limita necesară pentru a nu supraîncărca rețeaua folosind opțiunea -Y:

curl --limit-rate 50K -O https://cdn.kernel.org/pub/linux/kernel/v4.x/testing/linux-4.11-rc7.tar.xz

Aici trebuie să specificați numărul de kiloocteți pe secundă care pot fi descărcați. De asemenea, puteți închide conexiunea dacă viteza nu este suficientă, utilizați opțiunea -Y pentru a face acest lucru:

curl -Y 100 -O https://raw.githubusercontent.com/curl/curl/master/README.md

Transferarea fișierelor

curl -T login.txt ftp://speedtest.tele2.net/upload/

Sau să verificăm dacă fișierul este trimis prin HTTP, există un serviciu special pentru aceasta:

curl -T ~/login.txt http://posttestserver.com/post.php

În răspuns, utilitarul vă va spune unde puteți găsi fișierul descărcat.

Se trimit date POST

Puteți trimite nu numai fișiere, ci și orice date folosind metoda POST. Permiteți-mi să vă reamintesc că această metodă este folosită pentru a trimite date de diferite forme. Pentru a trimite o astfel de solicitare, utilizați opțiunea -d. Pentru testare vom folosi același serviciu:

curl -d "field1=val&fileld2=val1"http://posttestserver.com/post.php

Dacă nu sunteți mulțumit de această opțiune de trimitere, puteți pretinde că trimiteți formularul. Există o opțiune pentru aceasta -F:

curl -F "parolă=@pass;type=text/plain" http://posttestserver.com/post.php

Aici trecem campul de parola cu formularul ca text simplu, la fel poti trece mai multi parametri.

Trimiterea și primirea cookie-urilor

Cookie-urile sunt folosite de site-uri web pentru a stoca anumite informații din partea utilizatorului. Acest lucru poate fi necesar, de exemplu, pentru autentificare. Puteți accepta și trimite cookie-uri folosind curl. Pentru a salva cookie-urile primite într-un fișier, utilizați opțiunea -c:

curl -c cookie.txt http://posttestserver.com/post.php

Apoi puteți trimite cookie-ul curl înapoi:

curl -b cookie.txt http://posttestserver.com/post.php

Transmiterea și analiza antetului

Nu întotdeauna avem nevoie de conținutul paginii. Uneori doar titlurile pot fi interesante. Pentru a le afișa numai acestea există opțiunea -I:

curl -I https://site

Și opțiunea -H vă permite să trimiteți mai multe sau mai multe către server, de exemplu, puteți trece antetul If-Modified-Since astfel încât pagina să fie returnată doar dacă a fost modificată:

autentificare curl

Dacă serverul necesită unul dintre tipurile comune de autentificare, cum ar fi HTTP Basic sau FTP, atunci curl poate gestiona această sarcină foarte ușor. Pentru a specifica detaliile de autentificare, pur și simplu le specificați separate prin două puncte în opțiunea -u:

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

Autentificarea pe serverele HTTP va fi efectuată în același mod.

Folosind un proxy

Dacă trebuie să utilizați un server proxy pentru a descărca fișiere, atunci și acest lucru este foarte simplu. Este suficient să specificați adresa serverului proxy în opțiunea -x:

curl -x proxysever.test.com:3128 http://google.co.in

concluzii

În acest articol, am analizat cum să folosiți curl, de ce este necesar acest utilitar și principalele sale capacități. În ciuda asemănării lor cu, ele sunt foarte diferite. Comanda curl linux este concepută mai mult pentru analiza și simularea diferitelor acțiuni pe server, în timp ce wget este mai potrivit pentru descărcarea fișierelor și accesarea cu crawlere a site-urilor.