Affina le tue abilità di cURL. CURL PHP: cos'è e come si usa? Php curl ottieni esempi di richiesta

cURL è uno strumento speciale per il trasferimento di file e dati utilizzando la sintassi URL. Questa tecnologia supporta molti protocolli come HTTP, FTP, TELNET e molti altri. CURL è stato originariamente progettato per essere uno strumento da riga di comando. Fortunatamente per noi, la libreria cURL è supportata dal linguaggio di programmazione PHP. In questo articolo, esamineremo alcune delle funzionalità avanzate di cURL e toccheremo anche l'applicazione pratica di questa conoscenza utilizzando gli strumenti PHP.

Perché curl?

In effetti ce ne sono tanti modi alternativi campionare il contenuto della pagina web. In molti casi, principalmente per pigrizia, ho usato semplici Funzioni PHP invece di cURL:

$ contenuto = file_get_contents ("http://www.nettuts.com"); // o $ righe = file ("http://www.netttuts.com"); // o readfile ("http://www.nettuts.com");

Tuttavia, queste funzioni non hanno praticamente alcuna flessibilità e presentano un numero enorme di carenze in termini di gestione degli errori, ecc. Inoltre, ci sono alcune attività che semplicemente non puoi risolvere grazie a queste funzioni standard: interazione con i cookie, autenticazione, invio di un modulo, caricamento di file, ecc.

cURL è una potente libreria che supporta molti diversi protocolli, opzioni e fornisce informazioni dettagliate sulle richieste URL.

Struttura basilare

• Inizializzazione
• Assegnazione dei parametri
• Esecuzione e recupero del risultato
• Liberare memoria

// 1.inizializzazione $ ch = curl_init (); // 2. specificare i parametri, incluso l'URL curl_setopt ($ ch, CURLOPT_URL, "http://www.nettuts.com"); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt ($ ch, CURLOPT_HEADER, 0); // 3. ottieni HTML come risultato $ output = curl_exec ($ ch); // 4. chiude la connessione curl_close ($ ch);

Il passaggio n. 2 (ovvero, chiamare curl_setopt ()) verrà discusso in questo articolo molto più di tutti gli altri passaggi, poiché in questa fase accadono tutte le cose più interessanti e utili che devi sapere. Ci sono molte diverse opzioni in cURL che devono essere specificate per poter configurare una richiesta URL nel modo più accurato. Non considereremo l'intero elenco nel suo insieme, ma ci concentreremo solo su ciò che ritengo necessario e utile per questa lezione. Puoi studiare tu stesso il resto se questo argomento ti interessa.

Verifica degli errori

Inoltre, puoi anche utilizzare le istruzioni condizionali per verificare il successo:

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

Qui, tieni presente un punto molto importante per te stesso: dobbiamo usare "=== falso" per il confronto, invece di "== falso". Per coloro che non lo sanno, questo ci aiuterà a distinguere un risultato vuoto da un valore booleano falso, che indicherà un errore.

Ricevere le informazioni

Un altro passaggio aggiuntivo consiste nell'ottenere i dati della richiesta cURL dopo che è stata eseguita.

// ... curl_exec ($ ch); $ info = curl_getinfo ($ ch); eco "Preso". $info ["tempo_totale"]. "secondi per URL". $info["url"]; // ...

L'array restituito contiene le seguenti informazioni:

• "URL"
• "Tipo di contenuto"
• "codice_HTTP"
• "Dimensione_intestazione"
• “Richiesta_dimensione”
• "Filetime"
• Ssl_verify_result
• "Redirect_count"
• "Tempo totale"
• "Nomelookup_time"
• “Connect_time”
• "Pretransfer_time"
• "Size_upload"
• Size_download
• “Velocità_download”
• “Velocità_caricamento”
• "Scarica_lunghezza_contenuto"
• "Upload_content_length"
• "Starttransfer_time"
• "Redirect_time"

Rilevamento reindirizzamento basato sul browser

In questo primo esempio, scriveremo codice in grado di rilevare reindirizzamenti URL in base a varie impostazioni del browser. Ad esempio, alcuni siti Web reindirizzano i browser del telefono cellulare o di qualsiasi altro dispositivo.

Utilizzeremo l'opzione CURLOPT_HTTPHEADER per determinare le nostre intestazioni HTTP in uscita, incluso il nome del browser dell'utente e le lingue disponibili. Alla fine saremo in grado di determinare quali siti ci stanno reindirizzando a URL diversi.

// prova l'URL $ urls = array ("http://www.cnn.com", "http://www.mozilla.com", "http://www.facebook.com"); // test dei browser $ 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 come Mac OS X; en) AppleWebKit / 420 + (KHTML, come Gecko) Versione / 3.0 Mobile / 1A537a Safari / 419.3 "," language "=>" en ")," french "=> array (" user_agent " => "Mozilla / 4.0 (compatibile; MSIE 7.0; Windows NT 5.1; GTB6; .NET CLR 2.0.50727)", "lingua" => "fr, fr-FR; q = 0.5")); foreach ($ urls as $ url) (echo "URL: $ url \ n"; foreach ($ browser as $ test_name => $ browser) ($ ch = curl_init (); // specifica l'url curl_setopt ($ ch, CURLOPT_URL, $ url); // imposta le intestazioni per il browser curl_setopt ($ ch, CURLOPT_HTTPHEADER, array ("User-Agent: ($ browser [" user_agent "])", "Accept-Language: ($ browser [" language "]) " )); // non è necessario il contenuto della pagina curl_setopt ($ ch, CURLOPT_NOBODY, 1); // è necessario ottenere le intestazioni HTTP curl_setopt ($ ch, CURLOPT_HEADER, 1); // restituisce i risultati invece dell'output curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); $ output = curl_exec ($ ch); curl_close ($ ch); // c'è stato un reindirizzamento HTTP? If (preg_match ("! Location: (. *)!", $ Output , $ corrispondenze)) (echo " $ nome_prova: reindirizza a $ corrispondenze \ n ";) else (echo" $ nome_prova: nessun reindirizzamento \ n ";)) echo" \ n \ n ";)

Innanzitutto, forniamo un elenco di URL del sito che controlleremo. Più precisamente, abbiamo bisogno degli indirizzi di questi siti. Successivamente, dobbiamo definire le impostazioni del browser per testare ciascuno di questi URL. Successivamente, utilizzeremo un ciclo in cui esamineremo tutti i risultati ottenuti.

Il trucco che usiamo in questo esempio per impostare le impostazioni cURL ci consentirà di ottenere non il contenuto della pagina, ma solo le intestazioni HTTP (memorizzate nell'output $). Successivamente, utilizzando una semplice espressione regolare, possiamo determinare se la riga "Location:" era presente nelle intestazioni ricevute.

Quando corri codice dato, dovresti ottenere qualcosa di simile al seguente:

Fare una richiesta POST a un URL specifico

Quando si forma una richiesta GET, i dati trasmessi possono essere trasferiti all'URL tramite la "stringa di query". Ad esempio, quando esegui una ricerca su Google, il termine di ricerca viene visualizzato nella barra degli indirizzi del nuovo URL:

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

per simulare richiesta data, non è necessario utilizzare le funzionalità cURL. Se la pigrizia ti prende completamente, usa la funzione file_get_contents () per ottenere il risultato.

Ma il punto è che alcuni moduli HTML inviano richieste POST. I dati di questi form vengono trasportati attraverso il corpo della richiesta HTTP, e non come nel caso precedente. Ad esempio, se hai compilato un modulo sul forum e hai fatto clic sul pulsante di ricerca, molto probabilmente verrà effettuata una richiesta POST:

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

Possiamo scrivere Script PHP che può imitare questo tipo di URL di richiesta. Innanzitutto, creiamo un semplice file per accettare e visualizzare i dati POST. Chiamiamolo post_output.php:

Stampa_r ($ _ POST);

Quindi creiamo uno script PHP per eseguire la richiesta cURL:

$ url = "http: //localhost/post_output.php"; $ post_data = array ("pippo" => "bar", "query" => "Nettuts", "action" => "Submit"); $ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); // indica che abbiamo una richiesta POST curl_setopt ($ ch, CURLOPT_POST, 1); // aggiungi le variabili curl_setopt ($ ch, CURLOPT_POSTFIELDS, $ post_data); $ output = curl_exec ($ ch); curl_close ($ ch); echo $ output;

Quando esegui questo script, dovresti ottenere un risultato simile:

Pertanto, la richiesta POST è stata inviata allo script post_output.php, che a sua volta ha prodotto l'array superglobale $ _POST, il cui contenuto è stato recuperato utilizzando cURL.

Upload di file

Per prima cosa, creiamo un file da generare e inviare a upload_output.php:

Stampa_r ($ _ FILES);

Ed ecco il codice dello script che esegue la funzionalità di cui sopra:

$ url = "http: //localhost/upload_output.php"; $ post_data = array ("pippo" => "bar", // file da caricare "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); $ output = curl_exec ($ ch); curl_close ($ ch); echo $ output;

Quando vuoi caricare un file, tutto ciò che devi fare è passarlo come una normale variabile di post, preceduta dal simbolo @. Quando esegui lo script che hai scritto, otterrai il seguente output:

cURL multipli

Uno dei maggiori punti di forza di cURL è la capacità di creare gestori di cURL "multipli". Ciò consente di aprire una connessione a più URL contemporaneamente e in modo asincrono.

Nella versione classica della richiesta cURL, l'esecuzione dello script viene messa in pausa e attende il completamento dell'operazione dell'URL di richiesta, dopodiché lo script può continuare. Se intendi interagire con un intero gruppo di URL, richiederà molto tempo, poiché nella versione classica puoi lavorare solo con un URL alla volta. Tuttavia, possiamo rimediare a questa situazione utilizzando gestori speciali.

Diamo un'occhiata ad un esempio di codice che ho preso da php.net:

// crea alcune risorse cURL $ ch1 = curl_init (); $ ch2 = curl_init (); // specifica l'URL e altri 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); // crea più gestori di cURL $ mh = curl_multi_init (); // aggiungi alcuni gestori curl_multi_add_handle ($ mh, $ ch1); curl_multi_add_handle ($ mh, $ ch2); $ attivo = nullo; // esecuzione do ($ mrc = curl_multi_exec ($ mh, $ attivo);) while ($ mrc == CURLM_CALL_MULTI_PERFORM); while ($ active && $ mrc == CURLM_OK) (if (curl_multi_select ($ mh)! = -1) (do ($ mrc = curl_multi_exec ($ mh, $ active);) while ($ mrc == CURLM_CALL_MULTI_PERFORM);) ) // chiude curl_multi_remove_handle ($ mh, $ ch1); curl_multi_remove_handle ($ mh, $ ch2); curl_multi_close ($ mh);

L'idea è che puoi usare più gestori di cURL. Utilizzando un semplice ciclo, puoi tenere traccia di quali richieste non sono ancora state completate.

Ci sono due loop principali in questo esempio. Il primo ciclo do-while chiama la funzione curl_multi_exec(). Questa funzione non è bloccabile. Funziona il più velocemente possibile e restituisce lo stato della richiesta. Finché il valore restituito è la costante 'CURLM_CALL_MULTI_PERFORM', significa che il lavoro non è ancora stato completato (ad esempio, in questo momento le intestazioni http vengono inviate all'URL); Questo è il motivo per cui continuiamo a controllare questo valore restituito finché non otteniamo un risultato diverso.

Nel ciclo successivo controlliamo la condizione mentre la variabile $ active = "true". È il secondo parametro della funzione curl_multi_exec(). Il valore di questa variabile sarà "vero" finché una delle modifiche esistenti è attiva. Successivamente, chiamiamo la funzione curl_multi_select(). La sua esecuzione è "bloccata" finché c'è almeno una connessione attiva, fino a quando non si riceve una risposta. Quando ciò accade, torniamo al ciclo principale per continuare l'esecuzione delle query.

Ora, applichiamo le conoscenze acquisite attraverso un esempio che sarà davvero utile per un gran numero di persone.

Controllare i collegamenti in WordPress

Immagina un blog con un numero enorme di post e post, ognuno dei quali ha collegamenti a risorse Internet esterne. Alcuni di questi collegamenti potrebbero essere già "morti" per vari motivi. La pagina potrebbe essere stata rimossa o il sito potrebbe non funzionare affatto.

Creeremo uno script che analizzerà tutti i collegamenti e troverà siti Web che non si caricano e pagine 404, quindi ci fornirà un rapporto dettagliato.

Devo dire subito che questo non è un esempio di creazione di un plugin per WordPress. Questo è solo un buon banco di prova per i nostri test.

Cominciamo finalmente. Per prima cosa, dobbiamo recuperare tutti i collegamenti dal database:

// configurazione $ db_host = "localhost"; $ db_user = "radice"; $ db_pass = ""; $ db_name = "wordpress"; $ domini_esclusi = array ("localhost", "www.miodominio.com"); $ max_connessioni = 10; // inizializza le variabili $ url_list = array (); $ working_urls = array (); $ dead_urls = array (); $ not_found_urls = array (); $ attivo = nullo; // connettersi a MySQL if (! mysql_connect ($ db_host, $ db_user, $ db_pass)) (die ("Could not connect:". mysql_error ());) if (! mysql_select_db ($ db_name)) (die ("Potrebbe not select db: ". mysql_error ());) // seleziona tutti i post pubblicati con collegamenti $ q =" SELECT post_content FROM wp_posts WHERE post_content LIKE "% href =%" AND post_status = "publish" AND post_type = "post "" ; $ r = mysql_query ($ q) o die (mysql_error ()); while ($ d = mysql_fetch_assoc ($ r)) (// recupera i collegamenti usando le espressioni regolari if (preg_match_all ("! href = \" (. *?) \ "!", $ d ["post_content"], $ corrisponde) ) (foreach ($ corrisponde a $ url) ($ tmp = parse_url ($ url); if (in_array ($ tmp ["host"], $ domini_esclusi)) (continue;) $ url_list = $ url;)) ) / / rimuovi i duplicati $ url_list = array_values ​​​​(array_unique ($ url_list)); if (! $ url_list) (die ("Nessun URL da controllare");)

Innanzitutto, generiamo i dati di configurazione per interagire con il database, quindi scriviamo un elenco di domini che non parteciperanno al controllo ($ domini_esclusi). Definiamo anche un numero che caratterizza il numero massimo di connessioni simultanee che utilizzeremo nel nostro script ($ max_connections). Quindi ci colleghiamo al database, selezioniamo i post che contengono collegamenti e li memorizziamo in un array ($ url_list).

Il codice seguente è un po' complicato, quindi capiscilo dall'inizio alla fine:

// 1.gestore multiplo $ mh = curl_multi_init (); // 2. aggiungi un insieme di URL per ($ 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; } }

Qui proverò a mettere tutto sugli scaffali. I numeri nell'elenco corrispondono ai numeri nel commento.

1. 1. Creare un gestore multiplo;
2. 2. Scriveremo la funzione add_url_to_multi_handle() un po' più tardi. Ogni volta che viene chiamato, inizierà a elaborare un nuovo URL. Inizialmente, aggiungiamo 10 ($ max_connections) URL;
3. 3. Per iniziare, dobbiamo eseguire la funzione curl_multi_exec(). Finché restituisce CURLM_CALL_MULTI_PERFORM, abbiamo ancora molto da fare. Ne abbiamo bisogno principalmente per creare connessioni;
4. 4. Segue il ciclo principale, che funzionerà finché avremo almeno una connessione attiva;
5. 5. curl_multi_select () si blocca in attesa del completamento della ricerca URL;
6. 6. Ancora una volta, dobbiamo far fare a cURL un po' di lavoro, vale a dire recuperare i dati della risposta restituita;
7. 7. Qui è dove vengono controllate le informazioni. Come risultato dell'esecuzione della richiesta, verrà restituito un array;
8. 8. L'array restituito contiene un gestore cURL. Lo useremo per recuperare informazioni su una singola richiesta cURL;
9. 9. Se il collegamento era morto, o l'esecuzione dello script era scaduta, allora non dovremmo cercare alcun codice http;
10. 10. Se il link ci ha restituito una pagina 404, allora il codice http conterrà il valore 404;
11. 11. Altrimenti, abbiamo un collegamento funzionante di fronte a noi. (Puoi aggiungere ulteriori controlli per codice errore 500, ecc...);
12. 12. Successivamente, rimuoviamo il gestore cURL perché non ne abbiamo più bisogno;
13. 13. Ora possiamo aggiungere un altro URL ed eseguire tutto ciò di cui abbiamo parlato prima;
14. 14. A questo punto, lo script termina il suo lavoro. Possiamo eliminare tutto ciò che non ci serve e generare un report;
15. 15. Infine, scriveremo una funzione che aggiungerà l'URL al gestore. La variabile statica $ index aumenterà ogni volta che questa funzione viene chiamata.

Ho usato questo script sul mio blog (con alcuni link non funzionanti che ho aggiunto apposta per testarlo) e ho ottenuto il seguente risultato:

Nel mio caso, lo script ha impiegato poco meno di 2 secondi per passare attraverso 40 URL. Il guadagno in termini di prestazioni è significativo quando si tratta di un numero ancora maggiore di URL. Se apri dieci connessioni contemporaneamente, lo script può essere eseguito dieci volte più velocemente.

Qualche parola su altre utili opzioni di cURL

Autenticazione HTTP

Se l'URL ha l'autenticazione HTTP, puoi facilmente utilizzare il seguente script:

$ url = "http://www.somesite.com/members/"; $ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); // specifica il nome e la password curl_setopt ($ ch, CURLOPT_USERPWD, "myusername: mypassword"); // se il reindirizzamento è consentito curl_setopt ($ ch, CURLOPT_FOLLOWLOCATION, 1); // quindi salva i nostri dati su cURL curl_setopt ($ ch, CURLOPT_UNRESTRICTED_AUTH, 1); $ output = curl_exec ($ ch); curl_close ($ ch);

Caricamento FTP

PHP ha anche una libreria per lavorare con FTP, ma nulla ti impedisce di usare gli strumenti cURL:

// apri il file $ file = fopen ("/ percorso / a / file", "r"); // url dovrebbe contenere il seguente contenuto $ url = "ftp: // username: [e-mail protetta]: 21 / percorso / a / nuovo / 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, filesize ("/ percorso / a / file")); // specifica il mod ASCII curl_setopt ($ ch, CURLOPT_FTPASCII, 1); $ curl output = curl ( $ ch); curl_close ($ ch);

Utilizzo dei proxy

Puoi eseguire la tua richiesta di URL tramite un proxy:

$ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, "http://www.example.com"); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); // specifica l'indirizzo curl_setopt ($ ch, CURLOPT_PROXY, "11.11.11.11:8080"); // se è necessario fornire un nome utente e una password curl_setopt ($ ch, CURLOPT_PROXYUSERPWD, "utente: pass"); $ output = curl_exec ($ ch); curl_close ($ ch);

Funzioni di richiamata

È anche possibile specificare una funzione che verrà attivata anche prima del completamento della richiesta cURL. Ad esempio, durante il caricamento del contenuto della risposta, è possibile iniziare a utilizzare i dati senza attendere il caricamento completo.

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

Una funzione come questa DEVE restituire la lunghezza di una stringa, che è obbligatoria.

Conclusione

Oggi abbiamo appreso come utilizzare la libreria cURL per i tuoi scopi egoistici. Spero che questo articolo ti sia piaciuto.

Grazie! Buona giornata!

Questo articolo presuppone che tu abbia familiarità con le basi della rete e l'HTML.

Lo scripting è essenziale per costruire un buon sistema informatico. L'estensibilità dei sistemi Unix con script di shell e vari programmi che eseguono comandi automatici è uno dei motivi per cui hanno tanto successo.

Il numero crescente di applicazioni che si stanno spostando sul Web ha reso l'argomento dello scripting HTTP sempre più richiesto. Compiti importanti in quest'area sono il recupero automatico di informazioni da Internet, l'invio o il download di dati a server Web, ecc.

Curl è uno strumento da riga di comando che ti consente di eseguire tutti i tipi di manipolazioni e trasferimenti di URL. Questo articolo si concentra sull'esecuzione di semplici richieste HTTP. Si presume che tu sappia già dove digitare

# curl --help

# curl --manual

per informazioni sull'arricciatura.

Curl non è uno strumento che farà tutto per te. Crea richieste, riceve dati e invia dati. Potrebbe essere necessario un qualche tipo di colla per mettere tutto insieme, forse un linguaggio di scripting (come bash) o alcune chiamate manuali.

1. Protocollo HTTP

HTTP è il protocollo utilizzato per la ricezione di dati dai server web. È un protocollo molto semplice che si basa su TCP/IP. Il protocollo consente inoltre di inviare informazioni al server da un client utilizzando diversi metodi, come verrà mostrato di seguito.

HTTP sono stringhe di testo ASCII inviate dal client al server per richiedere un'azione. Quando viene ricevuta una richiesta, il server risponde al client con diverse righe di testo di servizio, quindi il contenuto effettivo.

Usando l'opzione curl -v, puoi vedere quali comandi curl sta inviando al server, così come altro testo informativo. L'opzione -v è forse l'unico modo per eseguire il debug o anche per comprendere l'interazione tra curl e il server web.

2. URL

Il formato URL (Uniform Resource Locator) specifica l'indirizzo di una risorsa specifica su Internet. Probabilmente lo sai, ad esempio URL: http://curl.haxx.se o https://yourbank.com.

3. Ottieni (GET) pagina

La richiesta HTTP più semplice e più comune è ottenere il contenuto dell'URL. L'URL può collegarsi a una pagina Web, un'immagine o un file. Il client invia una richiesta GET al server e riceve il documento richiesto. Se esegui il comando

# curl http://curl.haxx.se

otterrai una pagina web visualizzata nella finestra del tuo terminale. Il documento HTML completo contenuto in questo URL.

Tutte le risposte HTTP contengono una serie di intestazioni che di solito sono nascoste. Per vederli insieme al documento stesso, usa l'opzione curl -i. Puoi anche richiedere solo le intestazioni con l'opzione -I (che farà in modo che curl effettui una richiesta HEAD).

4. Moduli

I moduli sono il modo principale per presentare un sito Web come una pagina HTML con campi in cui l'utente inserisce i dati e quindi fa clic sul pulsante "OK" o "Invia", dopodiché i dati vengono inviati al server. Il server utilizza quindi i dati ricevuti e decide come procedere: cercare informazioni nel database, mostrare l'indirizzo inserito su una mappa, aggiungere un messaggio di errore o utilizzare le informazioni per autenticare l'utente. Naturalmente, c'è qualche programma sul lato server che accetta i tuoi dati.

4.1 OTTIENI

Il modulo GET utilizza Metodo GET, ad esempio come segue:

Se apri questo codice nel tuo browser, vedrai un modulo con una casella di testo e un pulsante che dice "OK". Se inserisci "1905" e fai clic su OK, il browser creerà un nuovo URL da seguire. L'URL sarà rappresentato come una stringa composta dal percorso dell'URL precedente e da una stringa come "junk.cgi? Birthyear = 1905 & press = OK".

Ad esempio, se il modulo si trovava in "www.hotmail.com/quando/birth.html", facendo clic su OK verrai indirizzato all'URL "www.hotmail.com/quando/junk.cgi?birthyear=1905&press=OK "...

Maggioranza motori di ricerca lavorare in quel modo.

Per rendere curl form una richiesta GET, è sufficiente inserire ciò che ci si aspetta dal form:

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

4.2 POST

Il metodo GET fa in modo che tutte le informazioni immesse vengano visualizzate nella barra degli indirizzi del browser. Questo può andare bene quando è necessario aggiungere una pagina ai segnalibri, ma è un ovvio svantaggio quando si immettono informazioni sensibili nei campi del modulo o quando la quantità di informazioni immesse nei campi è troppo grande (con conseguente URL illeggibile).

Il protocollo HTTP fornisce un metodo POST. Con esso, il client invia i dati separatamente dall'URL e quindi non lo vedrai nella barra degli indirizzi.

Il form che genera la richiesta POST è simile al precedente:

Curl può formare una richiesta POST con gli stessi dati come questo:

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

Questa richiesta POST utilizza "Content-Type application / x-www-form-urlencoded", che è il metodo più utilizzato.

I dati che invii al server devono essere codificati correttamente, curl non lo farà per te. Ad esempio, se vuoi che i tuoi dati contengano uno spazio, devi sostituire quello spazio con% 20, ecc. La mancanza di attenzione a questo problema è un errore comune, a causa del quale i dati non vengono trasferiti come dovrebbero.

Nel 1995 è stato definito un modo aggiuntivo per trasferire dati su HTTP. È documentato in RFC 1867, motivo per cui a volte viene indicato come pubblicazione RFC1867.

Questo metodo è progettato principalmente per supportare meglio i caricamenti di file. Il modulo che consente all'utente di caricare un file si presenta così in HTML:

Nota che Content-Type è impostato su multipart / form-data.

Per inviare dati a un modulo di questo tipo utilizzando curl, inserisci il comando:

# curl -F [e-mail protetta]-F premere = OK

4.4 Campi nascosti

Un modo comune per comunicare le informazioni sullo stato nelle applicazioni HTML consiste nell'utilizzare i campi nascosti nei moduli. I campi nascosti non vengono compilati, sono invisibili all'utente e vengono passati allo stesso modo dei campi normali.

Un semplice esempio di form con un campo visibile, uno nascosto e un pulsante OK:

Per inviare una richiesta POST utilizzando curl, non devi pensare se il campo è nascosto o meno. Per il ricciolo, sono tutti uguali:

# curl -d "anno di nascita = 1905 & premi = OK & persona = daniel"

4.5 Scopri come appare una richiesta POST

Quando si desidera compilare un modulo e inviare dati al server utilizzando curl, probabilmente si desidera che la richiesta POST appaia esattamente uguale a quella eseguita utilizzando il browser.

Un modo semplice per visualizzare la tua richiesta POST è salvare la pagina HTML con il modulo su disco, modificare il metodo in GET e fare clic sul pulsante Invia (puoi anche modificare l'URL a cui verranno inviati i dati).

Vedrai i dati aggiunti all'URL, separati da "?" caratteri, come previsto quando si utilizzano i moduli GET.

5. PUT

Forse, Il modo migliore per caricare i dati su un server HTTP, questo è usare PUT. Di nuovo, ciò richiede un programma (script) sul back-end che sappia cosa fare e come ricevere un flusso HTTP PUT.

Invia il file al server usando curl:

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

6. Autenticazione

Autenticazione: passa il nome utente e la password al server, quindi verifica se hai il diritto di effettuare la richiesta richiesta. L'autenticazione di base (utilizzata da curl per impostazione predefinita) è un testo in chiaro, il che significa che il nome utente e la password non verranno crittografati, ma solo leggermente oscurati da Base64, il che lo lascia aperto agli aggressori sulla strada tra te e il server HTTP.

Dire a curl di utilizzare un nome utente e una password:

# curl -u nome: password www.secrets.com

Il sito potrebbe richiedere l'utilizzo di un diverso metodo di autenticazione (vedi cosa scrive il server nelle intestazioni), in questi casi puoi usare le chiavi --ntlm, --digest, --negotiate, o anche --anyauth. A volte l'accesso a server HTTP esterni avviene tramite un proxy, come spesso avviene in aziende e aziende. Un proxy HTTP potrebbe richiedere il proprio nome utente e password per accedere a Internet. Tasto curl corrispondente:

# curl -U proxyuser: password proxy curl.haxx.se

Se il proxy richiede l'autenticazione NTLM, specificare --proxy-ntlm, se il metodo Digest, quindi --proxy-digest.

Se non specifichi una password nelle opzioni -u e -U, curl te la chiederà in modo interattivo.

Nota che quando curl è in esecuzione, la riga di avvio (insieme a chiavi e password) potrebbe essere visibile ad altri utenti sul tuo sistema nell'elenco delle attività. Ci sono modi per prevenire questo. Maggiori informazioni su questo di seguito.

7. Referente

Una richiesta HTTP può includere un campo "referer" che indica da quale URL l'utente è arrivato a questa risorsa. Alcuni programmi/script controllano il campo "referer" e non eseguono la richiesta se l'utente proviene da una pagina sconosciuta. Sebbene questo sia un modo stupido di controllare, molti script lo usano. Con curl, puoi mettere qualsiasi cosa nel campo "referer" e fargli fare quello che vuoi che faccia.

Questo viene fatto come segue:

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

8. Agente utente

Tutte le richieste HTTP supportano il campo "User-Agent", che specifica l'applicazione client dell'utente. Molte applicazioni web utilizzano queste informazioni per visualizzare la pagina in un modo o nell'altro. I programmatori Web creano più versioni di una pagina per consentire agli utenti di browser diversi di migliorare aspetto esteriore, utilizzando vari script javascript, vbscript, ecc.

A volte potresti scoprire che curl restituisce una pagina diversa da quella che hai visto nel tuo browser. In questo caso, è opportuno utilizzare il campo "User Agent" per ingannare nuovamente il server.

Travestimento arricciato come Internet Explorer su un computer Windows 2000:

# curl -A "Mozilla / 4.0 (compatibile; MSIE 5.01; Windows NT 5.0)"

Perché non diventare Netscape 4.73 su un box Linux (PIII):

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

9. Reindirizzamenti

Rispondendo alla tua richiesta, il server, al posto della pagina stessa, può restituire un'indicazione di dove deve andare il browser per arrivare alla pagina desiderata. L'intestazione che indica al browser questo reindirizzamento è "Posizione:".

Per impostazione predefinita, curl non va nella posizione specificata in "Posizione:", ma visualizza semplicemente la pagina come al solito. Ma puoi dirigerlo come segue:

# curl -L www.sitethatredirects.com

Se stai utilizzando curl per le richieste POST a un sito che reindirizza immediatamente a un'altra pagina, puoi tranquillamente utilizzare la combinazione -L e -d / -F. Curl formerà una richiesta POST per la prima pagina e poi una richiesta GET per la successiva.

10. Cookie

Con i cookie, i browser Web controllano lo stato lato client. Cookie è un nome con contenuto allegato. Il server, inviando i cookie, comunica al client il percorso e il nome host a cui inviare i cookie la prossima volta, indica la durata del cookie e alcuni altri parametri.

Quando un client si connette al server all'indirizzo specificato nel cookie accettato, il client invia quel cookie al server (a meno che la durata non sia scaduta).

Molte applicazioni e server utilizzano questa tecnica per combinare più richieste in un'unica sessione logica. Affinché curl possa svolgere anche questa funzione, dobbiamo essere in grado di salvare e inviare cookie, proprio come fanno i browser.

Il modo più semplice per inviare un cookie al server quando viene ricevuta una pagina utilizzando curl è aggiungere l'opzione appropriata sulla riga di comando:

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

I cookie vengono inviati come normali intestazioni HTTP. Ciò consente a curl di salvare i cookie preservando le intestazioni. Il salvataggio dei cookie utilizzando curl viene eseguito con il comando:

# curl -D headers_and_cookies www.cookiesite.com

(a proposito, per salvare i cookie è meglio usare l'opzione -c, di più su quello sotto).

Curl ha un gestore di cookie completamente funzionale, utile quando si desidera connettersi nuovamente al server e utilizzare i cookie che sono stati salvati l'ultima volta (o elaborati manualmente). Per utilizzare i cookie memorizzati in un file, chiama curl in questo modo:

# curl -b stored_cookies_in_file www.cookiesite.com

Il motore dei cookie curl è abilitato quando si specifica l'opzione -b. Se vuoi che curl accetti solo i cookie, usa -b con un file che non esiste. Ad esempio, se vuoi che curl accetti i cookie da una pagina e poi segua il reindirizzamento (magari restituendo il cookie che hai appena accettato), puoi chiamare curl in questo modo:

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

Curl può leggere e scrivere cookie di Netscape e Mozilla. È un modo conveniente per scambiare cookie tra browser e script automatici. L'opzione -b rileva automaticamente se questa vita cookie dei browser specificati e lo gestisce in modo appropriato, e utilizzando l'opzione -c / - cookie-jar, puoi forzare curl a scrivere un nuovo cookie al termine dell'operazione:

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

11. HTTPS

Esistono diversi modi per proteggere i tuoi trasferimenti HTTP. Il protocollo più noto per questa attività è HTTPS o HTTP su SSL. SSL crittografa tutti i dati inviati e ricevuti sulla rete, il che aumenta la probabilità che le tue informazioni vengano mantenute segrete.

Curl supporta le richieste ai server HTTPS grazie alla libreria OpenSSL gratuita. Le richieste si verificano nel solito modo:

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

11.1 Certificati

Nel mondo HTTPS, usi i certificati oltre al tuo nome utente e password per l'autenticazione. Curl supporta i certificati lato client. Tutti i certificati sono bloccati con una passphrase che è necessario immettere prima che curl possa iniziare a utilizzarli. La passphrase può essere specificata sulla riga di comando o immessa in modo interattivo. Curl usa certificati come questo:

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

Curl verifica anche l'identità del server confrontando il certificato del server con uno archiviato localmente. Se viene rilevata una mancata corrispondenza, curl rifiuterà di connettersi. Per ignorare l'autenticazione, utilizzare l'opzione -k.

Di più informazioni dettagliate sui certificati può essere trovato su http://curl.haxx.se/docs/sslcerts.html.

12. Intestazioni richieste arbitrarie

Potrebbe essere necessario modificare o aggiungere elementi di singole richieste curl.

Ad esempio, puoi modificare la richiesta POST in PROPFIND e inviare i dati come "Content-Type: text / xml" (invece del solito Content-Type):

# curl -d " "-H" Tipo di contenuto: testo / xml "-X PROPFIND url.com

Puoi rimuovere qualsiasi intestazione specificandola senza contenuto. Ad esempio, puoi rimuovere l'intestazione "Host:", rendendo così la richiesta "vuota":

# curl -H "Host:" http://mysite.com

Inoltre puoi aggiungere titoli. Il tuo server potrebbe aver bisogno di un'intestazione "Destinazione:":

# curl -H "Destinazione: http://moo.com/nowhere" http://url.com

13. Debug

Capita spesso che un sito risponda alle richieste curl in modo diverso dalle richieste del browser. In questo caso, devi assomigliare il più possibile a curl al browser:

• Utilizzare l'opzione --trace-ascii per salvare un rapporto dettagliato delle richieste in modo da poterle successivamente esaminare in dettaglio e comprendere il problema.
• Assicurati di controllare i cookie e di utilizzarli se necessario (leggi switch -b e save -c)
• Inserisci uno degli ultimi browser più diffusi nel campo "user-agent"
• Compila il campo "referer" come fa il browser
• Se stai utilizzando richieste POST, assicurati che tutti i campi siano passati nello stesso ordine del browser (vedi sopra, punto 4.5)

Un valido aiuto in questo difficile compito è il plugin LiveHTTPHeader per Mozilla/Firefox, che consente di visualizzare tutte le intestazioni che questo browser invia e riceve (anche quando si utilizza HTTPS).

Un approccio di livello inferiore consiste nell'acquisire il traffico HTTP sulla rete utilizzando programmi come ethereal o tcpdump e quindi analizzare quali intestazioni sono state ricevute e inviate dal browser (HTTPS rende questo approccio inefficace).

RFC 2616 è una lettura obbligata per chiunque voglia comprendere il protocollo HTTP.

RFC 2396 spiega la sintassi per gli URL.

RFC 2109 definisce come funzionano i cookie.

L'RFC 1867 definisce il formato del post di caricamento file.

http://openssl.planetmirror.com - Homepage Progetto OpenSSL

http://curl.haxx.se - home page del progetto cURL

La libreria CURL (Client URLs) consente di trasferire file su un computer remoto utilizzando una varietà di protocolli Internet. Ha una configurazione molto flessibile e consente di eseguire quasi tutte le richieste remote.

CURL supporta i protocolli HTTP, HTTPS, FTP, FTPS, DICT, TELNET, LDAP, FILE e GOPHER, nonché HTTP-post, HTTP-put, cookie, upload FTP, trasferimenti di file interrotti, password, numeri di porta, certificati SSL , Kerberos e proxy.

Utilizzando CURL, un server Web può fungere da client completo per qualsiasi servizio basato su HTTP, come XML-RPC, SOAP o WebDAV.

In generale, l'utilizzo della libreria si riduce a quattro passaggi:

1. Crea una risorsa CURL usando la funzione curl_init.
2. Impostazione dei parametri utilizzando la funzione curl_setopt.
3. Esecuzione di una richiesta utilizzando la funzione curl_exec.
4. Liberare una risorsa CURL usando la funzione curl_close.

Un semplice esempio di utilizzo di CURL

// Inizializza la libreria curl
if ($ ch = @ curl_init ())
{
// Imposta l'URL della richiesta
@ curl_setopt ($ ch, CURLOPT_URL, "http://server.com/");
// Se vero, CURL include le intestazioni nell'output
@
// Dove inserire il risultato della query:
// false - al flusso di output standard,
// true - come valore restituito dalla funzione curl_exec.
@
// Tempo massimo di attesa in secondi
@
// Imposta il valore del campo User-agent
@ curl_setopt ($ ch, CURLOPT_USERAGENT, "PHP Bot (http://blog.yousoft.ru)");
// Esegui la richiesta
$ data = @ curl_exec ($ ch);
// Visualizza i dati ricevuti
echo $ dati;
// Specializzazione della risorsa
@ curl_close ($ ch);
}
?>

Un esempio di utilizzo di una richiesta GET

$ ch = curl_init ();
// La richiesta GET è specificata nella stringa dell'URL
curl_setopt ($ ch, CURLOPT_URL, "http://server.com/?s=CURL");
curl_setopt ($ ch, CURLOPT_HEADER, falso);
curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, vero);
curl_setopt ($ ch, CURLOPT_CONNECTTIMEOUT, 30);

$ data = curl_exec ($ ch);
curl_close ($ ch);
?>

L'invio di una richiesta GET non è diverso dal ricevere una pagina. È importante notare che la stringa di query è formata come segue:

Http://server.com/index.php?name1=value1&name2=value2&name3=value3

dove http://server.com/index.php è l'indirizzo della pagina, nomeX è il nome della variabile, valoreX è il valore della variabile.

Un esempio di utilizzo di una richiesta POST

$ ch = curl_init ();
curl_setopt ($ ch, CURLOPT_URL, "http://server.com/index.php");
curl_setopt ($ ch, CURLOPT_HEADER, falso);
curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, vero);
// Devi indicare esplicitamente che ci sarà una richiesta POST
curl_setopt ($ ch, CURLOPT_POST, vero);
// I valori delle variabili vengono passati qui
curl_setopt ($ ch, CURLOPT_POSTFIELDS, "s = CURL");
curl_setopt ($ ch, CURLOPT_CONNECTTIMEOUT, 30);
curl_setopt ($ ch, CURLOPT_USERAGENT, "Bot PHP (http://mysite.ru)");
$ data = curl_exec ($ ch);
curl_close ($ ch);
?>

L'invio di una richiesta POST non è molto diverso dall'invio di una richiesta GET. Tutti i passaggi di base rimangono gli stessi. Anche le variabili sono impostate in coppia: nome1 = valore1 & nome2 = valore2.

Esempio di autorizzazione HTTP

// Autorizzazione HTTP
$ url = "http://server.com/protetto/";
$ ch = curl_init ();


curl_setopt ($ ch, CURLOPT_USERPWD, "mionomeutente: miapassword");
$ risultato = curl_exec ($ ch);
curl_close ($ ch);
echo $ risultato;
?>

Esempio di sessione FTP

$ fp = fopen (__FILE__, "r");
$ url = "ftp: // nome utente: [e-mail protetta]: 21/percorso/a/nuovofile.php ";
$ 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_FTPASCII, 1);
curl_setopt ($ ch, CURLOPT_INFILESIZE, dimensione del file (__FILE__));
$ risultato = curl_exec ($ ch);
curl_close ($ ch);
?>

Se hai problemi con cURL, devi aggiungere le seguenti righe prima di chiamare curl_close per ottenere un rapporto sull'ultima richiesta eseguita:

print_r (curl_getinfo ($ ch));
echo "numero errore cURL:". curl_errno ($ ch). "
" ;
echo "errore cURL:". curl_error ($ ch). "
" ;
curl_close ($ ch);
?>

Perché abbiamo bisogno di PHP CURL?
Per inviare richieste HTTP GET, possiamo semplicemente usare file_get_contents () metodo.

File_get_contents ("http: // sito")

Ma l'invio di richieste POST e la gestione degli errori non sono facili con file_get_contents ().

Inviare richieste HTTP è molto semplice con PHP CURL, devi seguire i quattro passaggi per inviare la richiesta.

passo 1)... Inizializza la sessione CURL

$ ch = curl_init ();

passo 2)... Fornisci opzioni per la sessione CURL

Curl_setopt ($ ch, CURLOPT_URL, "http: // sito"); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, vero); // curl_setopt ($ ch, CURLOPT_HEADER, vero); // se vuoi le intestazioni

URL_CURLOPT-> URL da recuperare
CURLOPT_HEADER-> per includere l'intestazione / non
CURLOPT_RETURNTRANSFER-> se è impostato su true, i dati vengono restituiti come stringa invece di emetterli.

passaggio 3). Esegui la sessione CURL

$ output = curl_exec ($ ch);

passaggio 4). Chiudi la sessione

Curl_close ($ ch);

Nota: Puoi verificare se CURL è abilitato o meno con il seguente codice.

If (is_callable ("curl_init")) (echo "Abilitato";) else (echo "Non abilitato";)

1.PHP CURL GET Esempio

Puoi utilizzare il codice sottostante per inviare una richiesta GET.

Funzione httpGet ($ url) ($ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, true); // curl_setopt ($ ch, CURLOPT_HEADER, false) curl_exec ($ ch ); curl_close ($ ch); return $ output;) echo httpGet ("http: // sito");

2.PHP CURL POST Esempio

Puoi utilizzare il codice seguente per inviare il modulo utilizzando PHP CURL.

Funzione httpPost ($ url, $ params) ($ postData = ""; // crea coppie di valori nome separate da & foreach ($ params as $ k => $ v) ($ postData. = $ K. "=". $ v. "&";) $ postData = rtrim ($ postData, "&"); $ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, vero); curl_setopt ( $ ch, CURLOPT_HEADER, false); curl_setopt ($ ch, CURLOPT_POST, count ($ postData)); curl_setopt ($ ch, CURLOPT_POSTFIELDS, $ postData); $ output = curl_exec ($ ch); curl_close ($ ch); return output ;)

Come utilizzare la funzione:

$ params = array ("nome" => "Ravishanker Kusuma", "età" => "32", "luogo" => "India"); echo httpPost ("http: //site/examples/php/curl-examples/post.php", $ params);

3. Invia agente utente casuale nelle richieste

È possibile utilizzare la funzione seguente per ottenere l'agente utente casuale.

Funzione getRandomUserAgent () ($ userAgents = array ("Mozilla / 5.0 (Windows; U; Windows NT 5.1; en-GB; rv: 1.8.1.6) Gecko / 20070725 Firefox / 2.0.0.6", "Mozilla / 4.0 (compatibile; MSIE 7.0; Windows NT 5.1) "," Mozilla / 4.0 (compatibile; MSIE 7.0; Windows NT 5.1; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30) "," Opera / 9.20 (Windows NT 6.0; U; en) "," Mozilla / 4.0 (compatibile; MSIE 6.0; Windows NT 5.1; en) Opera 8.50 "," Mozilla / 4.0 (compatibile; MSIE 6.0; MSIE 5.5; Windows NT 5.1) Opera 7.02 "," Mozilla / 5.0 (Macintosh; U; PPC Mac OS X Mach-O; fr; rv: 1.7) Gecko / 20040624 Firefox / 0.9 "," Mozilla / 5.0 (Macintosh; U; PPC Mac OS X; en) AppleWebKit / 48 (come Gecko) Safari / 48 "); $ random = rand (0, count ($ userAgents) -1); return $ userAgents [$ random];)

Usando CURLOPT_USERAGENT, puoi impostare la stringa User-Agent.

Curl_setopt ($ ch, CURLOPT_USERAGENT, getRandomUserAgent ());

4. Gestire i reindirizzamenti (HTTP 301.302)

Per gestire i reindirizzamenti URL, imposta CURLOPT_FOLLOWLOCATION su TRUE. Il numero massimo di reindirizzamenti può essere controllato utilizzando CURLOPT_MAXREDIRS.

Curl_setopt ($ ch, CURLOPT_FOLLOWLOCATION, TRUE); curl_setopt ($ ch, CURLOPT_MAXREDIRS, 2); // solo 2 reindirizzamenti

5.Come gestire gli errori CURL

possiamo usare i metodi curl_errno(), curl_error(), per ottenere gli ultimi errori per la sessione corrente.
curl_error ($ ch)-> restituisce l'errore come stringa
curl_errno ($ ch)-> restituisce il numero di errore
È possibile utilizzare il codice seguente per gestire gli errori.

Funzione httpGetWithErros ($ url) ($ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, true); $ output = curl_exec ($ ch=); if ($ output = = false) (echo "Numero errore:". curl_errno ($ ch). "
"; echo" Stringa di errore: ". curl_error ($ ch);) curl_close ($ ch); return $ output;)