2006. február 16. Jeff Felling
A Curl segít a weben közzétett adatok kezelésében Ez a cikk az ingyenes Curl eszközt tárgyalja, amely lehetővé teszi weblapok küldését és fogadását a parancssorból. A Curl-nek köszönhetően sokakat könnyű automatizálni
Ez a cikk az ingyenes Curl eszközt tárgyalja, amely lehetővé teszi weblapok küldését és fogadását a parancssorból. A Curl-nek köszönhetően számos műveletet könnyű automatizálni információvédelemés adminisztráció, például egy weboldal kibontása elemzés céljából vagy biztonsági javítás letöltése az internetről.
A Curl számos Unix disztribúcióban megtalálható. A legtöbb más számára léteznek binárisok és források. operációs rendszer. Még a nyílt forráskódú PHP-programozók is használhatják a Curl-t, hogy biztonságosan hozzáférjenek a webtartalomhoz közvetlenül PHP-szkriptekből.
A Curlnek az OpenSSL csomagra van szüksége, hogy működjön a Secure Sockets Layer (SSL) webhelyekkel. A Curlnek két verziója létezik, az egyik SSL-lel, a másik pedig SSL nélkül. Az elsőt javaslom, mert az SSL biztonságosan védi az adatokat.
A Curl SSL funkcionalitással történő használata előtt le kell töltenie és külön telepítenie kell az OpenSSL csomagot a webről. Bináris OpenSSL fájlok Windowshoz letölthető a GnuWin32 SourceForge projekt webhelyéről a címről. Ezen az oldalon még sok más található hasznos eszközöket Windowsra portolták.
Töltse le és telepítse az OpenSSL csomagot, majd másolja a két DLL fájlt a system32 könyvtárba:
Másolja a "C:Program FilesGnuWin32 binlibeay32.dll" %windir%system32 másolatot a "C:Program FilesGnuWin32 binlibssl32.dll" %windir%system32
Ezt követően telepítheti a Curl-t. Az SSL-kompatibilis Curl binárisok Windowshoz a következő címen találhatók: http://curl.haxx.se/latest.cgi?curl=win32-ssl-sspi . Legújabb verzió, curl 7.15.0, a win32-ssl-sspi.zip fájlban található, amely tartalmazza a curl.exe fájlt és a dokumentációt.
A Curl telepítése után a parancs beírásával győződjön meg arról, hogy működik
Curl http://isc.sans.org/ infocon.txt
Ha egy színt jelző szó jelenik meg a képernyőn (például zöld), akkor a Curl működik. Ebben az egyszerű példában a Curl lekéri az Infocon tartalmat a SANS Institute Internet Storm Center webhelyéről. A zöld azt jelenti, hogy az internet megfelelően működik, és nem észleltek komoly fenyegetéseket. Ha a zöld helyett a sárga, narancs vagy piros szavak jelennek meg a képernyőn, akkor tegye félre ezt a cikket, és látogassa meg az oldalt http://isc.sans.org hogy megismerjék a magas kockázatú állapotokat az interneten. Hiba esetén ellenőriznie kell, hogy a Curl megfelelően van-e telepítve.
Lényegében a Curl letölt egy weboldalt, majd kiköpi az eredetit HTML szöveg oldalakat a konzolra. A segédprogram lehetőségei azonban szélesebbek. A Curl beépített hibaellenőrzővel rendelkezik. Például a parancs
Curl http://noserveride
Curl hibát ad: (6) Nem sikerült feloldani a gazdagépet: noserverhere; host nem található. A hibakódok a szkriptekben használhatók egy weblap elérhetőségének vagy a webszerver válaszának tesztelésére. Ha például a Curl segítségével naponta lekér egy weboldalt, különösen egy webhely napi statisztikáit, akkor forráskódot adhat hozzá a szkripthez, amely hibakódokat keres. Ha a Curl a Curl: (7) hibakódot adja meg, nem tudott csatlakozni a gazdagéphez, akkor azonnal küldhet figyelmeztetést vagy e-mailt.
A Curl egyik legfontosabb előnye, hogy kompatibilis az SSL-lel. A kért HTTPS-oldalak a hálózaton keresztül titkosítva kerülnek elküldésre, majd a Curl megjeleníti a visszaállított szöveget a képernyőn. Ezenkívül a Curl ellenőrzi a tanúsítványokat – a tanúsítvány lejárati dátumát, a gazdagépnév megegyezik a tanúsítvány gazdagépnevével és a gyökértanúsítvány megbízhatósági szintjével –, és figyelmeztet, ha a tanúsítvány érvénytelen. A -cacert opció lehetővé teszi egy adott tanúsítványfájl megadását. A tanúsítvány ellenőrzése le van tiltva a -k kapcsolóval. Alternatív megoldás a -insecure opció használata.
A Curl több, mint fájlok interneten keresztüli küldése. A Curl segítségével gyorsan listázhatja az FTP-oldalak könyvtárait:
Curl ftp://myftpsite
A webhely alkönyvtárainak megtekintéséhez írja be a parancsot
Curl ftp://myftpsite/subdir/
Ha fájlt szeretne letölteni a hálózatról, csak adja meg a fájl nevét az URL-ben. A következő példában egy readme.txt nevű fájl közvetlenül a parancssorból töltődik be, és megjelenik a képernyőn:
Curl ftp://ftp.microsoft.com/deskapps/games/readme.txt
Gyakran könnyebb a Curl-lel szkriptelni FTP-fájlok beszúrásához, mint használni FTP parancs interaktívan.
Alapértelmezés szerint a kimenet közvetlenül a konzolra íródik, de az -o és -O kapcsolókkal átirányítható egy fájlba. Az oldal lekéréséhez és lemezre mentéséhez használja a -o kapcsolót. Az -O opció elmenti az eredményül kapott oldalt egy helyi fájlba, a Curl pedig lekéri a távoli dokumentum nevét. Ha az URL-ben nincs megadva fájlnév, akkor ez a művelet sikertelen lesz. Ha a Curl használatával kérést küld egy webhelyre fájlnév nélkül, de az eredményt fájlba szeretné menteni, megadhatja a fájlnevet parancs sor, Például:
A Curl Basic, Digest és Integrated hitelesítési módszereket biztosít. A legtöbb webhelyen az űrlapalapú hitelesítési oldalak a Curl elküldési funkcióival érhetők el, amint azt hamarosan bemutatjuk. Ez azt jelenti, hogy űrlapadatokat, például felhasználónevet és jelszót küldhet el egy távoli webhelyre, amely információkat kér a weboldalról. A hitelesítő adatok elküldéséhez használhatja a -u opciót, vagy beágyazhatja azokat az URL-be, ami hagyományosan FTP-ben történik, így:
Curl ftp://felhasználónév: [e-mail védett]
A Curl használatával az FTP-ről kölcsönzött technikák átvihetők HTTP-re, amint az a következő példában látható:
Curl http://username:password @myhtmlsite/default.htm
A Curl proxyszerveren keresztül is hozzáférést biztosít a weblapokhoz. Ezért a Curl beállítható úgy, hogy proxykiszolgálót használjon az alapszintű, a kivonatolt és az NTLM hitelesítéshez.
Nehéz egyetlen cikkben lefedni a Curl összes funkcióját, beleértve a fájlok feltöltését a szerverre (-T), csak a HTTP-fejlécben lévő információk megtekintését (-I), az összes adat megtekintését bőbeszédű módban (-V) és a rejtett adatokat. kimenet ( -s). Azt javaslom, hogy nézze meg közelebbről a Curl funkciókat a címen közzétett oktatóanyagban http://curl.haxx.se/docs .
Most, hogy ismeri a Curl alapjait, nézzünk meg egy egyszerű példát az adatok kinyerésére egy webhelyről, adott bemeneti adatokkal. Készítsünk egy egyszerű Whois-eszközt, amely bemutatja a Curl használatának egyszerűségét és kényelmét, valamint azt, hogy hogyan küldhetünk adatokat egy webhelyre a -d kapcsolóval. BAN BEN ezt a példát A Curl elküldi az IP-címet az Arin Whois webhelynek, majd lekéri az eredményeket arról a webhelyről. A Whois információkat keres egy IP-cím tulajdonosáról.
Fontos, hogy mielőtt elkezdené, tájékozódjon egy webhelyről, mert az egyes webhelyek forráskódja eltérő, és a Curl nem mindig működik egyformán minden webhelyen. Az oldal előzetes látogatása lehetővé teszi, hogy összegyűjtse a Curl működéséhez szükséges információkat. Ebben a példában a böngészőt használtam a webhely felkeresésére http://www.arin.net/whois/, és észrevette, hogy az oldalon egyetlen adatbeviteli mező található, amelyben a látogatók jelzik az őket érdeklő IP-címet. Meg kell szereznie ennek a mezőnek a részleteit, amely a webes űrlap részét képezi. Ez a példa a Perl szkriptet használja formfind.pl ( http://cool.haxx.se/cvs.cgi/curl/perl/contrib/formfind?rev=HEAD&content-type=text/vnd.viewcvs-markup). A Formfind.pl szkript az űrlapadatokat használható kimenetekké alakítja, és megkönnyíti az adatok kézi keresését HTML-ben. Természetesen a Perl-t telepíteni kell a számítógépen a Formfind futtatásához. jó csomag A Win32 Perl megrendelhető az ActiveState ActivePerl webhelyről a címen http://www.activestate.com .
Tekintsünk egy példát részletesebben. Először nézzünk meg egy olyan webhelyet, amely információkat kér:
Curl -o whoisOutputFile http://www.arin.net/whois/
Ez a parancs lekéri a Whois oldalt a http://www.arin.net webhelyről, és egy whoisOutputFile szövegfájlban tárolja, amely tartalmazza azt a HTML-forrást, amelyet a böngésző lejátszik a webhely meglátogatásakor.
Ezután meg kell találnia és ki kell jelölnie az űrlap adatait:
./formfind.pl
A Formfind űrlapváltozókat és azok lehetséges értékeit adja vissza. Ebben a példában a kimeneti eredmények meglehetősen egyszerűek (lásd alább). képernyő 1).
Figyelje meg az űrlapadatokat A queryinput nevű bemenet. Ez egy szövegmező, amelybe a Curlnek el kell küldenie az IP-címet a kereséshez. A konkrét IP-cím nem számít – ebben a példában a Microsoft-címet használtuk. A -d opcióval a keresett IP-cím elküldésre kerül a lekérdezésbeviteli mezőbe:
Curl -d "queryinput=207.46.133.140" http://ws.arin.net/cgibin/whois.pl
A Curl parancs a -d kapcsolóval adatokat keres az űrlapon ez az eset queryinput, amely a keresendő IP-cím. Ez megváltoztatja a célcímet; az űrlapnak egy új URL-re kell küldenie az adatokat, amely a whois.pl szkriptet képviseli. Az új célcím az 1. képernyő formfind kimenetében látható.
Ebben a példában a Whois-válasz HTML-forrásszövegét is megkapjuk, de azt HTML-címkék csoportja elrejti. Alapértelmezés szerint a Curl állapotüzenet a dokumentum méretét, a kész állapotát és az átviteli sebességet mutatja. Kicsit megtisztíthatja a kimenetet, és szűrheti az IP-címet birtokló szervezet nevét. A curl állapotát a -s kapcsolóval lehet letiltani. A parancsot a grep-en keresztül kell futtatni, hogy csak az OrgName legyen:
Curl -s -d "queryinput=207.46.133.140" http://ws.arin.net/cgibin/ whois.pl | grep Szervezetnév
Ebben a példában a kimenet azt mutatja, hogy az OrgName a Microsoft Corp.
@echo off curl -k -s -d "queryinput= %1" http://ws.arin.net/cgibin/ whois.pl | grep Szervezetnév
Ez a cikk egy olyan hatékony eszközre összpontosít, mint a cURL, valamint egy php-könyvtárra, amely hozzáférést biztosít ehhez az eszközhöz - libcurl. Minek ez az egész? Kommunikáció a szerverrel adatátviteli protokollokon keresztül, például http vagy ftp. A többi protokoll nem különösebben érdekel minket, ha valaki elmélyülni szeretne ebben a témában, akkor angol nyelvű forrásokat kell ásnia, és ez a cikk tartalmazza az alapokat és a felhasználási példákat.
Tehát a libcurl könyvtár lehetőséget biztosít számunkra, hogy adatokat vigyünk át a szerverre, és válaszokat kapjunk onnan. Mit ad ez nekünk? Képes a felhasználói viselkedés emulálására vagy ! Beszerezheti az oldalak tartalmát utólagos elemzéshez, megkaphatja a szolgáltatás válaszfejléceit, és programozottan engedélyezheti a webhelyeken, szkripteket készíthet üzenetek (például Twitteren vagy fórumokon) vagy információk közzétételéhez. Mindennek csak a képzeleted szab határt!
Az első dolog, amit tennünk kell, a könyvtár telepítése. Tovább helyi számítógép A Denwer összeállítást használom, mint a kezdő webmesterek túlnyomó többsége, akiknek a cikk készült. Erőteljes felhasználók, akik önállóan telepítik a php + apache + mysql köteget, képesek lesznek a cURL telepítésére, nem nekem kell elmagyaráznom nekik, hogy ez hogyan történik;) És mi, kezdők, kész megoldásokat használunk, hogy megkönnyítsük. Ezért telepítse a libcurl-t így:
és távolítsa el a pontosvesszőt a sor elején:
;extension=php_curl.dll
Kész. A könyvtár működésének ellenőrzéséhez hívja meg a phpinfo() függvényt, és keresse meg a következő sort: cURL support enabled. Gratulálok az első győzelmedhez.
Az eszközzel való munka megkezdéséhez inicializálnia kell. Ez a következőképpen történik:
$ch = curl_init();
A cURL munkamenet inicializálási függvényt használtuk. Ebben az esetben azonnal beállíthatja az URL-t, így:
$ch = curl_init("https://site");
És ezt később is megteheti, a lehetőségek között. Az opciók beállításának sorrendje nem számít. Ezt egy másik funkció végzi:
curl_setopt(erőforrás ch, karakterlánc opció, vegyes érték)
Ennek a függvénynek az első paraméterét, vagyis a ch erőforrást már létrehoztuk egy kicsit magasabban, de rengeteg opció és érték paraméter van. Szerintem ne másold be ide, hanem adj egy linket Részletes leírás függvények, remélem senki nem sértődik meg: curl_setopt .
Példát adok a beállítási lehetőségekre, csak egy URL példáján:
$url = "https://site"; curl_setopt($ch, CURLOPT_URL,$url);
Még néhány példa a beállítási lehetőségekre: kapjuk meg a szerver válaszfejlécét, de magát az oldalt ne:
curl_setopt($ch, CURLOPT_HEADER, 1); // fejléc olvasása curl_setopt($ch, CURLOPT_NOBODY, 1); // CSAK a fejlécet olvassa el a törzs nélkül
Tehát inicializáltuk a munkamenetet, beállítottuk a szükséges paramétereket, most végrehajtjuk a kapott kérést, bezárjuk a munkamenetet és megjelenítjük az eredményt:
$eredmény = curl_exec($ch); curl_close($ch); echo $eredmény;
Ennek eredményeként megkapjuk az első teljesen működő példánkat a libcurl könyvtár használatára:
$ch = curl_init(); $url = "https://site"; curl_setopt($ch, CURLOPT_URL,$url); curl_setopt($ch, CURLOPT_HEADER, 1); // fejléc olvasása curl_setopt($ch, CURLOPT_NOBODY, 1); // CSAK a fejlécet olvassa el a törzs nélkül $result = curl_exec($ch); curl_close($ch); echo $eredmény;
Hogy működik, az remélem egyértelmű, mert minden lépést külön-külön mérlegeltünk :) Ennek eredményeként kapunk egy HTTP válaszfejlécet a szervertől, amit az alábbiakban mindenképpen ki fogunk elemezni, hogy jobban megértsük az interakció minden szakaszát a szerverek között. böngésző és szerver:
HTTP/1.1 200 OK Szerver: nginx/1.2..php 1
Mesés! Megkaptuk a válaszfejlécet a szervertől, és működés közben teszteltük a könyvtárat. Miért hasznos ez számunkra? Az a tény, hogy most nagyjából elképzeli a műveletek sorrendjét, amikor a cURL-lel dolgozik:
Például felkerestem a ya.ru oldalt, és megnéztem a generált böngészőkérést és a szervertől kapott választ. Itt vannak:
Kérés
GET / HTTP / 1.1 - Megpróbáljuk elérni az oldalt a / címen, azaz a mappa gyökerében található fő oldalon. 1.1-es protokollverziót használunk.
Felhasználói ügynök: Opera/9.80 (Windows NT 6.1; WOW64) Presto/2.12.388 Verzió/12.14- Bemutatkozunk a szervernek, mi vagyunk az Opera böngésző.
Házigazda: ya.ru Domain név a kért erőforrás.
Elfogadás: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/webp, image/jpeg, image/gif, image/x-xbitmap, */*;q=0,1— Az elfogadható forrásformátumok listája.
Accept-Language: ru-RU,ru;q=0.9,en;q=0.8— A támogatott nyelvek listája.
Elfogadás-kódolás: gzip, deflate- Támogatott kódolási módszerek.
Cookie: yandexuid=ХХХХХ — Cookie-k, ha szükséges.
Kapcsolat: Keep-Alive – Maradjon kapcsolatban és tartsa a kapcsolatot.
Válasz
HTTP / 1.1 200 Ok – 200-as kódot kapunk, ami azt jelenti, hogy minden rendben van.
Szerver: nginx – A szerver bemutatkozott – ez az nginx.
Dátum: V, 2013. március 10. 14:10:50 GMT— Aktuális dátum és idő a szerveren.
Tartalom típusa: szöveg/html; charset=UTF-8- Tartalom típusa és kódolása.
Kapcsolat: bezárás - A szerver nem akar állandó kapcsolatot fenntartani velünk, ezért azonnal bezárja. A következő kéréshez új kapcsolat jön létre.
Cache-Control: no-cache,no-store,max-age=0,must-revalidate- Caching kezelése. Ebben az esetben le van tiltva.
Lejárat: vasárnap, 2013. március 10. 14:10:50 GMT— A munkamenet várható lejártának dátuma. Esetünkben ez egybeesik a nyitási idővel, hiszen a szerver azonnal, feldolgozás után azonnal bezárta.
Utolsó módosítás: V, 2013. március 10., 14:10:50 GMT— Az utolsó módosítás ideje.
Tartalom-kódolás: gzip - Információk kódolási módszere.
A HTTP-kérés fejlécében található paraméterek teljes listája megtalálható a wikipédián.
Most már van elképzelése arról, hogyan kommunikál egymással a böngésző és a webszerver. Ezt nagyon hasznos tudni és megérteni, mert megpróbáljuk emulálni a böngésző műveleteit a libcurl könyvtár használatával. Menj tovább.
Úgy gondolom, hogy miután néhány általános pont már világos, és úgy tűnik, hogy minden világos, akkor itt az ideje, hogy továbblépjen a gyakorláshoz, és egy példa segítségével csiszolja készségeit. Személy szerint mindig viszket a kezem, hogy mindent kipróbáljak a gyakorlatban :)
Mivel a cURL nagyon jó az elemzők számára, nézzük meg azt a funkciót, hogy az oldal kódját a címére kapjuk. Ugyanakkor a kimenet egy tömb lesz a címmel, az oldal tartalmával, és még hibakódokkal is, ha valami elromlik.
Függvény get_web_page($url) ( $uagent = "Opera/9.80 (Windows NT 6.1; WOW64) Presto/2.12.388 Version/12.14"; $ch = curl_init($url); curl_setopt($ch, CURLOPT_RETURN1); // visszaadja a weblapot curl_setopt($ch, CURLOPT_HEADER, 0); // nem ad vissza fejlécet curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // követi az átirányításokat curl_setopt($ch, CURLOPT_ENCODING, ""); // az összes kódolást feldolgozza curl_setopt($ch, CURLOPT_USERAGENT, $uagent); // useragent curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 120); // kapcsolat időtúllépése curl_setopt($ch, CURLOPT_TIMEOUT, 120); // válaszidőtúllépés curl_setopt($ch,REDIRSOPT($ch,REDIRSURLt ); // leállítás a 10. átirányítás után $content = curl_exec($ch); $err = curl_errno($ch); $errmsg = curl_error($ch); $header = curl_getinfo($ch); curl_close( $ch); $fejléc["errno"] = $hiba; $fejléc["errmsg"] = $errmsg; $fejléc["tartalom"] = $tartalom; $fejléc visszaadása; )
Bemeneti paraméterek:
url - az oldal vagy a webhely címe.
Kimeneti paraméterértékek (három elemű tömb):
header['errno'] - ha valami elromlott, akkor hibakód jelenik meg.
header['errmsg'] - ez tartalmazza a hiba szövegét.
fejléc['tartalom'] – a tényleges oldal\fájl\kép stb.
Használjunk ehhez hasonló függvényt:
$eredmény = get_web_page("https://ya.ru"); if (($eredmény["errno"] != 0)||($eredmény["http_kód"] != 200)) ( echo $eredmény["errmsg"]; ) else ( $oldal = $eredmény["tartalom "]; echo $oldal; )
Mindennek hiba nélkül kell mennie, és a $page változóban megkapja az oldal kódját. Ha egy nem létező yaaaaaaaaaaaaa.ru oldalt próbálunk elérni, hibaüzenetet kapunk:
Nem sikerült feloldani a gazdagépet: yaaaaaaaaaaaa.ru; host nem található
Minden korrekten és szépen feldolgozva :)
Ezenkívül bármit megtehet az oldal kódjával, például elemzi reguláris kifejezésekkel. De ennyi a következő leckékben, de most álljunk meg itt.
A cURL egy olyan eszköz, amely lehetővé teszi a különféle szerverekkel való interakciót, és számos protokollt támogat: HTTP, FTP, TELNET stb. A cURL kezdetben egy parancssori segédprogram. De szerencsére a PHP támogatja a cURL könyvtárat. Ebben a cikkben a cURL-lel való munka nem triviális példáit tekintjük meg.
Valójában sok más módja is van annak, hogy kérést küldjön egy másik szervernek, például egy oldal tartalmának lekérésére. Sokan, többnyire lustaságból, egyszerűt használnak PHP függvények cURL helyett:
$content = file_get_contents("http://www.example.com"); // vagy $sorok = file("http://www.example.com"); // vagy readfile("http://www.example.com");
Ezek azonban nem teszik lehetővé a hatékony hibakezelést. Számos olyan feladat is van, amelyet egyáltalán nem tudnak elvégezni – például a cookie-kkal való munkavégzés, engedélyezés, bejegyzéskérés, fájlok letöltése.
A cUrl egy hatékony eszköz, amely számos protokollt támogat, és teljes körű információt nyújt a kérésről.
Mielőtt az összetett példákra térne át, fontolja meg alapszerkezet cURL kérés PHP-ben. A cURL-kérés PHP-ben való végrehajtásához 4 fő lépést kell végrehajtania:
Ebben a cikkben elsősorban a 2. lépést fogjuk figyelembe venni, mivel a fő varázslat ott történik. A cURL opciók listája nagyon széles, ezért ma nem fogunk minden lehetőséget figyelembe venni, hanem azokat fogjuk használni, amelyek konkrét problémák megoldásához hasznosak.
Ha szükséges, a következő sorokat is hozzáadhatja a hibák követéséhez:
// ... $kimenet = curl_exec($ch); if ($output === FALSE) ( echo "cURL Error: " . curl_error($ch); ) // ...
Figyeljük meg, hogy a "==="-t használjuk a "==" helyett, mert különbséget kell tenni az üres szerverválasz és a logikai válasz között HAMIS értékek, amely hiba esetén visszaküldésre kerül.
Egy másik választható lépés, hogy a végrehajtás után információkat szerezzen be a cURL-kérésről.
// ... curl_exec($ch); $info = curl_getinfo($ch); echo "Elvette" . $info["összes_idő"] . " másodperc az url - hez " . $info["url"]; // ...
Ennek eredményeként egy tömböt kap a következő információkkal:
Ebben a példában egy szkriptet fogunk írni, amely észleli az átirányításokat a böngésző különböző beállításai alapján. Például egyes webhelyek átirányítják a látogatókat innen mobil eszközök, látogatók más országokból.
A CURLOPT_HTTPHEADER opciót használjuk saját fejléceink beállítására, beleértve a User-Agent és a Language elemet, és megnézzük, hová irányítanak át minket a webhelyek.
// URL-ek $urls = array("http://www.cnn.com", "http://www.mozilla.com", "http://www.facebook.com"); // böngészők $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" => tömb ("user_agent" => "Mozilla/5.0 (iPhone; U; CPU, mint a Mac OS X; hu) AppleWebKit/420+ (KHTML, mint a Gecko) Version/3.0 Mobile/1A537a Safari/419.3", "language" => "en"), "french" => array ("user_agent" = > "Mozilla/4.0 (kompatibilis; MSIE 7.0; Windows NT 5.1; GTB6; .NET CLR 2.0.50727)", "nyelv" => "fr,fr-FR;q=0.5")); foreach ($urls mint $url) ( echo "URL: $url\n"; foreach ($browsers mint $test_name => $browser) ( $ch = curl_init(); // URL beállítása curl_setopt($ch, CURLOPT_URL, $url); // adja meg a használandó böngészőt és nyelvet curl_setopt($ch, CURLOPT_HTTPHEADER, array("User-Agent: ($browser["user_agent"])", "Accept-Language: ($browser["nyelv" ]) ")); // nincs szükségünk az oldaltartalomra curl_setopt($ch, CURLOPT_NOBODY, 1); // csak fejlécekre van szükség curl_setopt($ch, CURLOPT_HEADER, 1); // az eredményt adja vissza ahelyett kimenet curl_setopt($ch, CURLOPT_RETURNTRANSFER , 1); $output = curl_exec($ch); curl_close($ch); // átirányítások meghatározása a HTTP-fejlécekben? if (preg_match("!Location: (.*)!", $ output, $matches)) ( echo "$teszt_neve: átirányít ide: $matches\n"; ) else ( echo "$teszt_neve: nincs átirányítás\n"; ) ) echo "\n\n"; )
Egy ciklusban ellenőrizzük a böngészőket minden egyes URL-hez. Először beállítjuk a kérésünk beállításait: URL és tesztböngésző és nyelv.
Mert speciális opciót állítunk be, a kérés eredménye csak HTTP fejléceket fog tartalmazni. Egy egyszerűvel reguláris kifejezés ellenőrizhetjük, hogy a válasz tartalmazza-e a "Location:" karakterláncot.
A szkript végrehajtásának eredménye:
URL: http://www.cnn.com szabvány: átirányít a http://edition.cnn.com/ iphone címre: átirányít a http://edition.cnn.com/ french: átirányít a http://edition.cnn címre .com/ URL: http://www.mozilla.com standard: átirányít ide: https://www.mozilla.org/firefox/ iphone: átirányít a https://www.mozilla.org/firefox/ french: átirányít ide https://www.mozilla.org/firefox/ URL: http://www.facebook.com standard: átirányít a https://www.facebook.com/ iphone oldalra: átirányít a http://m.facebook.com oldalra /?refsrc=http%3A%2F%2Fwww.facebook.com%2F&_rdr francia: nincs átirányítás
A cselekvés által GET kéréseket adatok adhatók át a lekérdezési karakterláncban. Például amikor a Google-on keres, a lekérdezés az URL-ben kerül átadásra:
http://www.google.com/search?q=google
Még csak cURL-re sincs szüksége, hogy megkapja ennek a kérésnek az eredményét, lehet lusta és használhatja a "file_get_contents()"-t.
De több HTML űrlapok használja a POST módszert. Ebben az esetben az adatokat a kérés üzenetének törzsében küldi el, nem magában az URL-ben.
Írjunk egy szkriptet, amely elküldi a POST kéréseket. Kezdjük egy egyszerű létrehozásával PHP fájl, amely elfogadja ezeket a kéréseket és visszaküldi a neki küldött adatokat. Nevezzük post_output.php-nek:
$url = "http://localhost/post_output.php"; $post_data = array("foo" => "bar", "query" => "FooBar", "action" => "Küldés"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // POST kérés készítése curl_setopt($ch, CURLOPT_POST, 1); // adatok hozzáadása curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $kimenet = curl_exec($ch); curl_close($ch); echo $kimenet;
Ez a szkript a következőket fogja kiadni:
Array ( => bar => FooBar => Submit)
Ez a szkript POST kérést küldött a post_output.php fájlba. amely a $_POST tömb tartalmát adta ki, és ezt a választ a cURL használatával kaptuk meg.
Csakúgy, mint az előző példában, hozzunk létre egy fájlt, amely elfogadja a kéréseket, upload_output.php :
Print_r($_FILES);
És a szkript, amely letölti a fájlokat:
$url = "http://localhost/upload_output.php"; $post_data = tömb ("foo" => "bar", // fájl feltöltése "upload" => "@/tmp/desert.jpg"); $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); $kimenet = curl_exec($ch); curl_close($ch); echo $kimenet;
Ha fel szeretne tölteni egy fájlt, csak át kell adnia annak elérési útját, csakúgy, mint egy normál POST kérési paraméterhez, úgy, hogy "@" előtagot jelöl. A forgatókönyv eredménye:
Array ( => Array ( => desert.jpg => application/octet-stream => /tmp/phpAhEvXy => 0 => 845941))
A cURL egyik fejlett funkciója a PHP-ben több kérés egyidejű és aszinkron végrehajtásának képessége.
Normál körülmények között a szkript leáll, és megvárja a kérés befejezését. És ha sok kérést kell végrehajtania, akkor ez sok időt vehet igénybe, mert. sorban fogod követni. Ez a korlátozás megkerülhető:
// kezelők létrehozása $ch1 = curl_init(); $ch2 = curl_init(); // beállítások megadása 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); //több cURL-leíró létrehozása $mh = curl_multi_init(); // kezelők hozzáadása curl_multi_add_handle($mh,$ch1); curl_multi_add_handle($mh,$ch2); $fut = null; // lekérdezések végrehajtása do ( curl_multi_exec($mh, $running); ) while ($running > 0); // erőforrások kiadása curl_multi_remove_handle($mh, $ch1); curl_multi_remove_handle($mh, $ch2); curl_multi_close($mh);
Az ötlet az, hogy létrehozhat több cURL-leírót, kombinálhatja őket egy többleíró alá, és aszinkron módon hajthatja végre őket.
Eleinte minden ugyanúgy történik, mint egy normál cURL kérésnél - egy leíró jön létre ( curl_init() ), a paraméterek be vannak állítva ( curl_setopt() ). Ezután létrejön egy többleíró ( curl_multi_init() ) és a korábban létrehozott szokásos fogantyúk hozzáadódnak ( curl_multi_add_handle() ). A szokásos curl_exec() hívás helyett ismételten hívjuk curl_multi_exec() adott funkciót tájékoztat minket az aktív kapcsolatok számáról a második paraméterrel - $running. Ezért a ciklus addig fut, amíg a $futás egyenlővé nem válik 0-val. És természetesen a munka befejezése után fel kell szabadítani az erőforrásokat.
Ebben a példában egyszerűen kiadjuk a lekérdezések eredményét az STDOUT-ba. Tekintsük a több cURL használatának nem triviális esetét.
Képzeljen el egy blogot sok olyan bejegyzéssel, amely külső webhelyekre mutató hivatkozásokat tartalmaz. Előfordulhat, hogy egyes hivatkozások nem működnek.
Írjunk egy szkriptet, amely megtalálja az összes hibás hivatkozást, és megmutatja nekünk.
Először ki kell húznunk az összes külső hivatkozást az adatbázisból:
// CONFIG $db_host = "localhost"; $db_user = "root"; $db_pass = ""; $db_name = "wordpress"; $excluded_domains = array("localhost", "site"); $max_kapcsolatok = 10; $url_lista = array(); $working_urls = array(); $halott_urls = array(); $not_found_urls = array(); $aktív = null; // kapcsolódás a MySQL-hez if (!mysql_connect($db_host, $db_user, $db_pass)) ( die("Nem sikerült csatlakozni: " . mysql_error()); ) if (!mysql_select_db($db_name)) ( die("Lehetséges not select db: " . mysql_error()); ) // az összes olyan bejegyzés lekérése, amelyek linkjei a következő szöveggel rendelkeznek: $q = "SELECT post_content FROM wp_posts WHERE post_content LIKE "%href=%" ÉS post_status = "közzététel" ÉS post_type = "post " "; $r = mysql_query($q) vagy die(mysql_error()); while ($d = mysql_fetch_assoc($r)) ( // összegyűjti az összes hivatkozást reguláris kifejezéssel if (preg_match_all("/href=\"(.*?)\"/), $d["post_content"], $egyezik )) ( foreach ($egyezik a következővel: $url) ( // a nem kívánt tartományok kiszűrése $tmp = parse_url($url); if (isset($tmp["host"]) && in_array($tmp["host"], $ kizárt_domains)) ( folytatás; ) // $url_list = $url összerakása; ) ) ) // ismétlődések eltávolítása $url_list = array_values(array_unique($url_list)); if (!$url_list) ( die("Nincs ellenőrizendő URL"); )
A szkriptnek ebben a részében egyszerűen kihúzunk minden külső hivatkozást az adatbázisból. Nézzük meg őket:
$mh = curl_multi_init(); // 1. hivatkozások hozzáadása a ($i = 0; $i< $max_connections; $i++) { add_url_to_multi_handle($mh, $url_list); } // основной цикл do { curl_multi_exec($mh, $curRunning); // 2. один из потоков завершил работу if ($curRunning != $running) { $mhinfo = curl_multi_info_read($mh); if (is_array($mhinfo) && ($ch = $mhinfo["handle"])) { // 3. один из запросов выполнен, можно получить информацию о нем $info = curl_getinfo($ch); // 4. нерабочая ссылка if (!$info["http_code"]) { $dead_urls = $info["url"]; // 5. 404? } else if ($info["http_code"] == 404) { $not_found_urls = $info["url"]; // 6. верная ссылка } else { $working_urls = $info["url"]; } // 7. удаляем отработавший дескриптор curl_multi_remove_handle($mh, $mhinfo["handle"]); curl_close($mhinfo["handle"]); // 8. добавим новый урл add_url_to_multi_handle($mh, $url_list); $running = $curRunning; } } } while ($curRunning >0); curl_multi_close($mh); echo "==Holt URL-ek==\n"; echo implode("\n", $halott_urls) . "\n\n"; echo "==404 URL==\n"; echo implode("\n", $not_found_urls) . "\n\n"; echo "==Működő URL-ek==\n"; echo implode("\n", $working_urls); echo "\n\n"; // 9. hozzáad egy kezelőt adott url függvénnyel add_url_to_multi_handle($mh, $url_list) ( static $index = 0; // ha vannak még linkek if (isset($url_list[$index])) ( // mindent a szokásos módon $ ch = curl_init(); // beállítások megadása curl_setopt($ch, CURLOPT_URL, $url_list[$index]); // visszatérés helyett curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // átirányítások engedélyezése curl_setopt ($ ch, CURLOPT_FOLLOWLOCATION, 1); // csak fejlécek beszerzése, hogy időt takarítson meg curl_setopt($ch, CURLOPT_NOBODY, 1); // curl_multi_add_handle($mh, $ch); $index++; ) )
Nézzük meg részletesebben a kódot (a számozás megfelel a kódban található megjegyzéseknek):
Futtassuk a szkriptet:
Holt URL-ek== xample1234.com/ ==404 URL-ek== www.google.com/dsfasdfafd ==Működő URL-ek== ru.php.net/manual/ru/function.time.php www.cssbuttongenerator.com/ csslint. net/codex.wordpress.org/Plugin_API/Action_Reference fortawesome.github.io/Font-Awesome/fortawesome.github.io/Font-Awesome/ www.oracle.com/technetwork/java/javafx/downloads/index.html kódex. wordpress.org/Plugin_API/Filter_Reference codex.wordpress.org/Roles_and_Capabilities code.google.com/p/google-api-php-client/wiki/OAuth2#Google_APIs_Console jplayer.org/code.google.com/p/google-api -php-client/ developers.google.com/+/ accounts.google.com/ServiceLogin?service=devconsole&passive=1209600&continue=https%3A%2F%2Fcode.google.com%2Fapis%2Fconsole%2F&followup=https%3A%2F %2Fcode.google.com%2Fapis%2Fconsole%2F daneden.github.io/animate.css/ github.com/daneden/animate.css ru2.php.net/manual/ru/function.autoload.php www.google. com/recaptcha/api/verify phpunit.de/ phpunit.de/manual/current/en/phpunit-book.html
Az ellenőrzés körülbelül 2 másodpercig tartott. 10 szál egyidejű futtatásával a teljesítmény 10-szeresére nő a szokásos cURL-kérésekhez képest. A szerver válasz tartalmának lekéréséhez használja a függvényt curl_multi_getcontent($ch) , ahol a $ch az innen kapott leíró curl_multi_info_read() .
Ha a HTTP kérés hitelesítést igényel, használja a következő kódot:
$url = "http://www.somesite.com/tagok/"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // felhasználónév és jelszó küldése curl_setopt($ch, CURLOPT_USERPWD, "sajátfelhasználónév:jelszó"); // ha az átirányítás engedélyezett curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // A cURL az átirányítás után is jelszót küld curl_setopt($ch, CURLOPT_UNRESTRICTED_AUTH, 1); $kimenet = curl_exec($ch); curl_close($ch);
A PHP-nek saját FTP könyvtára van, de használhatja a cURL-t is:
// fájl olvasása $file = fopen("/fájl/elérési útja", "r"); // az url már tartalmazza a szükséges adatokat $url = "ftp://felhasználónév: [e-mail védett]:21/út/új/fájlhoz"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // beállítások curl_setopt($ch, CURLOPT_UPLOAD, 1); curl_setopt($ch, CURLOPT_INFILE, $fp); curl_setopt($ch, CURLOPT_INFILESIZE, fájlméret("/fájl/útvonal")); curl_setopt($ch, CURLOPT_FTPASCII, 1); $kimenet = curl_exec($ curl_close($ch);
A kérelmeket egy adott meghatalmazotton keresztül lehet benyújtani:
$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://www.example.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // proxy címe curl_setopt($ch, CURLOPT_PROXY, "11.11.11.11:8080"); // ha engedély szükséges curl_setopt($ch, CURLOPT_PROXYUSERPWD,"user:pass"); $kimenet = curl_exec($ch); curl_close($ch);
Lehetőség van visszahívások alkalmazására egy kérés végrehajtása során, anélkül, hogy meg kellene várnia annak befejezését. Például a szerver válaszának letöltése közben felhasználhatjuk a már kapott adatokat anélkül, hogy megvárnánk a teljes letöltést.
$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://example.com"); curl_setopt($ch, CURLOPT_WRITEFUNCTION,"haladás_függvény"); curl_exec($ch); curl_close($ch); function progress_function($ch,$str) ( echo $str; return strlen($str); )
A visszahívási függvénynek vissza kell adnia a karakterlánc hosszát, hogy a lekérdezés megfelelően működjön.
Minden alkalommal, amikor a szerver válaszának következő része érkezik, visszahívás történik.
Ebben a cikkben megvizsgáltuk a cURL fejlett funkcióit a PHP-ben. Amikor legközelebb URL-kéréseket kell végrehajtania, használja a cURL-t.
Egy webfejlesztő életét nehézségek borítják. Különösen elkeserítő, ha ezeknek a nehézségeknek a forrása ismeretlen. A kérés elküldésével, vagy a válasszal, vagy egy harmadik féltől származó könyvtárral van probléma, vagy a külső API hibás? Számos különféle eszköz létezik, amelyek megkönnyíthetik életünket. Íme néhány parancssori eszköz, amelyeket személy szerint felbecsülhetetlen értékűnek tartok.
becsavar
A cURL egy program, amely a wget-hez hasonlóan különböző protokollokon keresztül adatokat továbbít. A fő különbség az, hogy alapértelmezés szerint a wget fájlba ment, míg a cURL a parancssorba. Ez nagyon megkönnyíti a weboldal tartalmának megtekintését. Például az alábbi módon szerezheti meg gyorsan jelenlegi külső IP-címét:
$ curl ifconfig.me 93.96.141.93
Lehetőségek -én(címek megjelenítése) és -ÉN(csak a fejlécek megjelenítése) teszi a cURL-t nagyszerű eszközzé a HTTP-válaszok hibakereséséhez és annak elemzéséhez, hogy pontosan mit küld a szerver:
$ curl -I habrahabr.ru HTTP/1.1 200 OK Szerver: nginx Dátum: Cs., 2011. augusztus 18. 14:15:36 GMT Tartalomtípus: szöveg/html; charset=utf-8 Kapcsolat: életben tartás Életben tartás: timeout=25
Paraméter -L szintén hasznos, a cURL automatikusan követi az átirányításokat. A cURL támogatja a HTTP-hitelesítést, a cookie-kat, a HTTP-proxykon keresztüli tunnelinget, kézi beállítások főcímek és még sok minden más.
Ostrom
Az Siege egy terhelést vizsgáló eszköz. Ráadásul van egy praktikus opciója is -g, ami nagyon hasonlít a göndör -il, hanem megjeleníti a http kérés fejléceit is. Íme egy példa a google.com webhelyről (néhány címsort eltávolítottunk a rövidség kedvéért):
$ siege -g www.google.com GET / HTTP/1.1 Gazda: www.google.com User-Agent: JoeDog/1.00 (X11; I; Siege 2.70) Csatlakozás: bezár HTTP/1.1 302 Talált hely: http:// www.google.co.uk/ Tartalomtípus: text/html; charset=UTF-8 Szerver: gws Tartalomhossz: 221 Kapcsolat: bezár GET / HTTP/1.1 Gazda: www.google.co.uk Felhasználói ügynök: JoeDog/1.00 (X11; I; Siege 2.70) Kapcsolat: bezár HTTP/ 1.1 200 OK Tartalomtípus: szöveg/html; karakterkészlet=ISO-8859-1 X-XSS-védelem: 1; mode=block Kapcsolat: bezárás
De amire a Siege igazán nagyszerű, az a terhelési tesztelés. Mint az Apache benchmark ab, számos egyidejű kérést küldhet a webhelynek, és megnézheti, hogyan kezeli a forgalmat. A következő példa bemutatja, hogyan teszteljük a Google-t 20 kéréssel 30 másodpercig, majd az eredmény megjelenik:
$ ostrom -c20 www.google.co.uk -b -t30s ... A szerverostrom felemelése... kész. Tranzakciók: 1400 találat Elérhetőség: 100,00 % Eltelt idő: 29,22 mp Átvitt adatok: 13,32 MB Válaszidő: 0,41 mp Tranzakciós sebesség: 47,91 trans/sec Átbocsátási sebesség: 0,46 MB/sec Egyidejűség: 0,46 MB/sec. Leghosszabb tranzakció: 4,08 Legrövidebb tranzakció: 0,08
Az egyik legtöbb hasznos funkciókat Az ostrom az, hogy nem csak egy címmel tud működni, hanem egy fájl URL-listájával is. Ez nagyszerű terhelési teszteléshez, mert szimulálhatja a valódi forgalmat webhelyén, ahelyett, hogy ugyanazt az URL-t újra és újra megütné. Például a következőképpen használhatja a Siege-t egy kiszolgáló betöltésére az Apache-naplóból származó címek használatával:
$ cut -d " " -f7 /var/log/apache2/access.log > urls.txt $ ostrom -c
ngrep
A komoly forgalomelemzéshez ott van a Wireshark több ezer beállítással, szűrővel és konfigurációval. Létezik parancssori verzió is cápa. De egyszerű feladatoknál a Wireshark funkciót feleslegesnek tartom. Tehát amíg nincs szükségem erős fegyverre, addig használom. Lehetővé teszi, hogy megtegye hálózati csomagok ugyanaz, mint a grep csinál a fájlokkal.
A webes forgalomhoz szinte mindig a -W hogy megőrizze a karakterlánc formázást, valamint a lehetőséget -q, amely redundáns információkat rejt a nem megfelelő csomagokról. Íme egy példa egy parancsra, amely elfogja az összes csomagot GET vagy POST paranccsal:
ngrep -q -W "^(GET|POST) .*"
A csomagokhoz további szűrőt is hozzáadhat, például adott gazdagép, IP-cím vagy port szerint. Itt van egy szűrő a google.com 80-as portján lévő összes bejövő és kimenő forgalomhoz, amely tartalmazza a "keresés" szót.
ngrep -q -W byline "keresés" a www.google.com gazdagépen és a 80-as porton
Ez a cikk feltételezi, hogy ismeri a hálózatépítés alapjait és a HTML nyelvet.
A forgatókönyvírás képessége elengedhetetlen egy jószág felépítéséhez számítógépes rendszer. A Unix rendszerek kiterjeszthetősége shell szkripteken és különféle, automatizált parancsokat végrehajtó programokon keresztül az egyik oka annak, hogy ilyen sikeresek.
A webre költöző alkalmazások növekvő száma oda vezetett, hogy a HTTP-szkriptek témája egyre keresettebb. Ezen a területen fontos feladatok az információk automatikus kinyerése az internetről, adatok webszerverekre küldése vagy letöltése stb.
A Curl egy parancssori eszköz, amely lehetővé teszi az URL-ek manipulálását és különféle típusú átadásokat. Ez a cikk az egyszerű HTTP-kérésekre összpontosít. Feltételezhető, hogy már tudja, hol kell tárcsázni
# curl --segítség
# curl --kézikönyv
a göndörítéssel kapcsolatos információkért.
A curl nem olyan eszköz, amely mindent megtesz helyetted. Kéréseket hoz létre, adatokat fogad és adatokat küld. Szüksége lehet némi "ragasztóra", hogy mindent összetartson, esetleg valamilyen szkriptnyelvet (például bash) vagy néhány kézi hívást.
1. HTTP protokoll
A HTTP az a protokoll, amelyet a webszerverektől érkező adatok fogadásakor használnak. Ez egy nagyon egyszerű protokoll, amely a TCP/IP-re épül. A protokoll azt is lehetővé teszi, hogy információkat küldjön a szerverre a klienstől többféle módszerrel, amint azt a továbbiakban bemutatjuk.
A HTTP ASCII-szöveg karakterláncai, amelyeket egy kliens küld a kiszolgálónak, hogy valamilyen műveletet kérjen. Amikor egy kérés érkezik, a szerver több szolgáltatási szövegsorral válaszol a kliensnek, majd a tényleges tartalommal.
A curl -v kapcsolóval láthatja, hogy a curl mely parancsokat küldi el a szervernek, valamint másokat is tájékoztató szöveg. A -v kapcsoló talán az egyetlen módja annak, hogy hibakeresést végezzünk, vagy akár megértsük a curl és a webszerver közötti interakciót.
2.URL
Az URL formátum (Uniform Resource Locator – univerzális erőforráscím) egy adott erőforrás címét határozza meg az interneten. Valószínűleg Ön is tudja ezt, példák az URL-ekre: http://curl.haxx.se vagy https://yourbank.com.
3. Get (GET) oldal
A legegyszerűbb és leggyakoribb HTTP-kérés az URL tartalmának lekérése. Az URL hivatkozhat weboldalra, képre vagy fájlra. A kliens GET kérést küld a szervernek, és megkapja a kért dokumentumot. Ha lefuttatja a parancsot
# curl http://curl.haxx.se
a terminál ablakában megjelenik egy weboldal. Az ezen az URL-címen található teljes HTML-dokumentum.
Minden HTTP-válasz tartalmaz fejléceket, amelyek általában rejtve vannak. Ha magával a dokumentummal együtt szeretné látni őket, használja a curl -i kapcsolót. A -I kapcsolóval csak fejléceket is kérhet (ami a curl-t HEAD kérésre kényszeríti).
4. Alakzatok
Az űrlapok az elsődleges módja annak, hogy egy webhelyet HTML-oldalként mutassunk be, olyan mezőkkel, amelyekbe a felhasználó adatokat ír be, majd rákattint az OK vagy a Küldés gombra, majd az adatok elküldésre kerülnek a szerverre. A szerver ezután felhasználja a kapott adatokat, és eldönti, hogyan tovább: megkeresi az információt az adatbázisban, megjeleníti a megadott címet a térképen, hibaüzenetet ad hozzá, vagy az információ segítségével hitelesíti a felhasználót. Természetesen van valami program a szerver oldalon, ami elfogadja az adataidat.
4.1 GET
A GET űrlap a GET metódust használja, például:
Ha megnyitja ezt a kódot a böngészőben, megjelenik egy űrlap, amelyen egy szövegmező és egy "OK" feliratú gomb található. Ha beírja az „1905” értéket, és az OK gombra kattint, a böngésző új URL-t generál, amelyet követni kell. Az URL egy karakterlánc, amely az előző URL elérési útjából és egy olyan karakterláncból áll, mint a „junk.cgi?birthyear=1905&press=OK”.
Például, ha az űrlap a "www.hotmail.com/when/birth.html" címen volt, akkor az OK gombra kattintva a "www.hotmail.com/when/junk.cgi?birthyear=" URL-címre jut. 1905&press=OK" .
Többség kereső motorokígy működjön.
Ahhoz, hogy a curl GET kérést generáljon, egyszerűen írja be, hogy mit várna el az űrlapon:
# curl "www.hotmail.com/when/junk.cgi?birthyear=1905&press=OK"
4.2 POST
A GET metódus hatására az összes bevitt információ megjelenik címsor a böngészőjét. Ez jó lehet, ha könyvjelzővel kell ellátnia egy oldalt, de nyilvánvaló hátrányt jelent, ha titkos információkat ír be az űrlapmezőkbe, vagy ha a mezőkbe beírt információ mennyisége túl nagy (ez egy olvashatatlan URL-címet eredményez).
A HTTP protokoll biztosítja a POST metódust. Ezzel a kliens az URL-től elkülönítve küldi el az adatokat, ezért nem fogja látni a címsorban.
A POST kérést generáló űrlap hasonló az előzőhöz:
A Curl ugyanazokkal az adatokkal tud POST kérést létrehozni az alábbiak szerint:
# curl -d "születési év=1905&press=%20OK%20" www.hotmail.com/when/junk.cgi
Ez a POST-kérés a "Content-Type application/x-www-form-urlencoded"-t használja, amely a legszélesebb körben használt módszer.
A szerverre küldött adatoknak megfelelően kódoltnak kell lenniük, a curl ezt nem fogja megtenni helyetted. Ha például azt szeretné, hogy az adatok szóközt tartalmazzanak, ezt a szóközt a %20-ra kell cserélni, és így tovább. Az erre a kérdésre való odafigyelés hiánya egy gyakori hiba, ami miatt az adatok továbbítása nem úgy történik, ahogy kellene.
Még 1995-ben elhatározták kiegészítő módon adatátvitel HTTP-n keresztül. Az RFC 1867-ben van dokumentálva, ezért néha RFC1867-postingnak nevezik.
Ezt a módszert elsősorban arra tervezték jobb támogatást fájlfeltöltések. A fájl feltöltését lehetővé tevő űrlap a következőképpen néz ki HTML-ben:
Vegye figyelembe, hogy a Content-Type beállítása többrészes/formaadatok.
Ha adatokat szeretne küldeni egy ilyen űrlapra curl használatával, írja be a következő parancsot:
# curl -F [e-mail védett]-Fpress=OK
4.4 Rejtett mezők
A HTML-alkalmazásokban az állapotinformációk közlésének általános módja a rejtett mezők használata az űrlapokon. A rejtett mezők nincsenek kitöltve, a felhasználó számára láthatatlanok, és a normál mezőkkel azonos módon kerülnek átadásra.
Egy egyszerű példa egy űrlapra egy látható mezővel, egy rejtett mezővel és egy OK gombbal:
POST kérés curl elküldéséhez nem kell azon gondolkodnia, hogy a mező rejtett-e vagy sem. A göndörítéshez mind egyforma:
# curl -d "születési év=1905&press=OK&person=daniel"
4.5 Nézze meg, hogyan néz ki egy POST-kérés
Ha szeretne kitölteni egy űrlapot, és adatokat küldeni a kiszolgálónak a curl használatával, akkor valószínűleg azt szeretné, hogy a POST kérés pontosan úgy nézzen ki, mint a böngésző segítségével.
A POST-kérés egyszerű módja, ha lemezre menti az űrlap HTML-oldalát, módosítja a módszert GET-re, és megnyomja a „Küldés” gombot (az adatok beküldésének URL-címét is módosíthatja).
Látni fogja, hogy az adatokat „?” karakterekkel elválasztva hozzáfűzte az URL-hez, ahogy az a GET űrlapok használatakor várható.
5. PUT
Talán, A legjobb mód Az adatok feltöltése a HTTP szerverre a PUT használatával történik. Ehhez ismét egy program (script) szükséges a háttérben, amely tudja, mit kell tennie, és hogyan fogadhatja el a HTTP PUT adatfolyamot.
Fájl küldése a szervernek a curl használatával:
# curl -T feltöltési fájl www.uploadhttp.com/receive.cgi
6. Hitelesítés
Hitelesítés - felhasználónév és jelszó átadása a szervernek, amely után ellenőrzi, hogy jogosult-e a kért kérés végrehajtására. Az alapvető hitelesítés (amelyet a curl alapértelmezés szerint használ) egyértelmű szöveg alapú, ami azt jelenti, hogy a felhasználónév és a jelszó nem lesz titkosítva, hanem csak kis mértékben "elzavarja" a Base64 algoritmussal, így a támadók útközben megtudhatják ezeket az információkat. Ön és a HTTP szerver között.
Mondja meg a curl-nek, hogy használjon felhasználónevet és jelszót:
# curl -u name:password www.secrets.com
Előfordulhat, hogy a webhely más hitelesítési módot igényel (lásd, mit ír a szerver a fejlécekbe), ezekben az esetekben használhatja az --ntlm, --digest, --negotiate vagy akár --anyauth kulcsokat. Néha a külső HTTP-szerverekhez való hozzáférés proxyn keresztül történik, ahogyan azt gyakran teszik a vállalatok és cégek. Előfordulhat, hogy a HTTP-proxynak saját felhasználónévre és jelszóra van szüksége az internet eléréséhez. Releváns curl kulcs:
# curl -U proxyuser:proxypassword curl.haxx.se
Ha a proxy NTLM hitelesítést igényel, adja meg a --proxy-ntlm értéket, ha a Digest metódust, akkor a --proxy-digest.
Ha nem ad meg jelszót az -u és -U kapcsolókban, akkor a curl interaktívan kéri.
Vegye figyelembe, hogy amikor a curl fut, a futtatási karakterlánc (és vele együtt a kulcsok és jelszavak) a rendszer többi felhasználója számára látható lehet a feladatlistában. Vannak módszerek ennek megakadályozására. Erről lentebb bővebben.
7. Hivatkozó
A HTTP-kérés tartalmazhat egy „hivatkozó” mezőt, amely azt az URL-t jelzi, amelyről a felhasználó az erőforráshoz érkezett. Egyes programok/szkriptek ellenőrzik a "hivatkozó" mezőt, és nem hajtják végre a kérést, ha a felhasználó ismeretlen oldalról érkezett. Bár ez egy ostoba módja az ellenőrzésnek, sok szkript mégis használja. A curl segítségével bármit behelyezhet a "hivatkozó" mezőbe, és így arra kényszerítheti, hogy azt tegye, amit akar.
Ez a következő módon történik:
# curl -e http://curl.haxx.se daniel.haxx.se
8. Felhasználói ügynök
Minden HTTP-kérés támogat egy „User-Agent” mezőt, amely meghatározza a felhasználó ügyfélalkalmazását. Sok webalkalmazás használja ezeket az információkat az oldal ilyen vagy olyan módon történő megjelenítéséhez. A webprogramozók egy oldal több verzióját is létrehozzák a felhasználók számára különböző böngészők fejleszteni kinézet, különféle javascript szkriptek, vbscript stb.
Néha előfordulhat, hogy a curl olyan oldalt ad vissza, amely nem az, amit a böngészőjében látott. Ebben az esetben célszerű a "Felhasználói ügynök" mezőt használni, hogy ismét megtévessze a szervert.
A curl álcázása Internet Explorerként Windows 2000 rendszerű gépen:
# curl -A "Mozilla/4.0 (kompatibilis; MSIE 5.01; Windows NT 5.0)"
Miért nem lesz Netscape 4.73 Linux gépen (PIII):
# curl -A "Mozilla/4.73 (X11; U; Linux 2.2.15 i686)"
9. Átirányítások
Kérésére válaszul a szerver maga az oldal helyett jelzést adhat vissza arról, hogy a böngészőnek merre kell továbbmennie, hogy a kívánt oldalra jusson. A fejléc, amely közli a böngészővel az átirányítást, a „Hely:”.
Alapértelmezés szerint a curl nem a „Hely:” mezőben megadott címre megy, hanem a szokásos módon jeleníti meg az oldalt. De elküldheted így:
# curl -L www.sitethatredirects.com
Ha curl to POST kéréseket használ egy webhelyre, amely azonnal átirányít egy másik oldalra, nyugodtan használhatja a -L és -d/-F parancsokat. A Curl egy POST kérést küld az első oldalhoz, majd egy GET kérést a következőhöz.
10. Cookie-k
A sütik lehetővé teszik a webböngészők számára, hogy ellenőrizzék az állapotot a kliens oldalon. A cookie egy név, amelyhez tartalom csatolva van. A szerver a cookie-k küldésével közli a klienssel az elérési utat és az állomásnevet, ahova legközelebb a cookie-kat kell küldeni, megmondja a cookie élettartamát és néhány egyéb paramétert.
Amikor egy ügyfél a kapott cookie-ban megadott címen csatlakozik a szerverhez, az ügyfél elküldi a cookie-t a szervernek (ha az élettartam még nem járt le).
Sok alkalmazás és kiszolgáló használja ezt a módszert több kérés egy logikai munkamenetbe történő kombinálására. Ahhoz, hogy a curl is elláthassa ezt a funkciót, képesnek kell lennünk a cookie-k mentésére és küldésére, akárcsak a böngészőknek.
A legegyszerűbb módja annak, hogy cookie-t küldjön a szervernek egy curl-es oldal lekérésekor, ha hozzáadja a megfelelő beállítást a parancssorban:
# curl -b "név=Dániel" www.cookiesite.com
A cookie-k rendszeres HTTP-fejlécként kerülnek elküldésre. Ez lehetővé teszi a curl számára a cookie-k tárolását a fejlécek tárolásával. A cookie-k curl segítségével mentése a következő paranccsal történik:
# curl -D headers_and_cookies www.cookiesite.com
(egyébként a -c kapcsolót érdemesebb használni a cookie-k mentéséhez, erről lentebb).
A curl rendelkezik egy teljes körű cookie-kezelővel, amely akkor hasznos, ha újra csatlakozni szeretne a szerverhez, és a legutóbb elmentett (vagy kézzel készített) cookie-kat szeretne használni. Mert cookie-k használata fájlba mentve hívja meg a curl-t így:
# curl -b stored_cookies_in_file www.cookiesite.com
A curl cookie motor engedélyezve van, ha megadja a -b kapcsolót. Ha azt szeretné, hogy a curl csak a cookie-kat fogadja el, használja a -b parancsot egy nem létező fájlhoz. Ha például azt szeretné, hogy a curl elfogadja a cookie-kat egy oldalról, majd egy átirányítást kövessen (talán az éppen elfogadott cookie-t adja át), akkor a curl-t a következőképpen hívhatja meg:
# curl -b nada -L www.cookiesite.com
A Curl képes sütiket olvasni és írni Netscape és Mozilla formátumban. Ez kényelmes módja sütiket cserél a böngészők és az automatikus szkriptek között. A -b kapcsoló automatikusan meghatározza, hogy adott fájl a megadott böngészők cookie-jait és ennek megfelelően kezeli, a -c/--cookie-jar opcióval pedig a curl-t arra kényszerítheti, hogy a művelet befejeztével új cookie-t írjon:
# curl -b cookies.txt -c newcookies.txt www.cookiesite.com
11. HTTPS
Számos módja van a HTTP-átvitel biztonságának. A legismertebb protokoll, amely megoldja ezt a problémát, a HTTPS vagy HTTP over SSL. Az SSL titkosítja a hálózaton keresztül küldött és fogadott összes adatot, ami növeli annak valószínűségét, hogy adatai titkosak maradnak.
A Curl az ingyenes OpenSSL-könyvtárnak köszönhetően támogatja a HTTPS-kiszolgálókhoz intézett kéréseket. A kérések a szokásos módon történnek:
# curl https://that.secure.server.com
11.1 Tanúsítványok
A HTTPS világában a felhasználónév és jelszó mellett tanúsítványokat is használ a hitelesítéshez. A Curl ügyféloldalon támogatja a tanúsítványokat. Minden tanúsítvány zárolva van egy jelszóval, amelyet meg kell adnia, mielőtt a curl elkezdhet dolgozni velük. A jelszó megadható a parancssorban, vagy beírható interaktívan. A curl tanúsítványokat a következőképpen használják:
# curl -E mycert.pem https://that.secure.server.com
A Curl hitelesíti a kiszolgálót azáltal is, hogy ellenőrzi a kiszolgáló tanúsítványát egy helyileg tárolt tanúsítvánnyal. Az eltérés azt eredményezi, hogy a curl megtagadja a csatlakozást. A hitelesítés figyelmen kívül hagyásához használja a -k kapcsolót.
A tanúsítványokról további információ a http://curl.haxx.se/docs/sslcerts.html címen található.
12. Önkényes kérésfejlécek
Előfordulhat, hogy módosítania kell vagy hozzáadnia kell az egyes hullámosítási kérelmek elemeit.
Például módosíthatja a POST kérést PROPFIND-re, és az adatokat "Content-Type: text/xml" formában küldheti el (a szokásos tartalomtípus helyett):
# curl -d "
Bármelyik fejlécet eltávolíthatja, ha tartalom nélkül adja meg. Például eltávolíthatja a "Host:" fejlécet, így a kérés "üres" lesz:
# curl -H "Host:" http://mysite.com
Fejléceket is hozzáadhat. Szerverének szüksége lehet egy "Destination:" fejlécre:
# curl -H "Cél: http://moo.com/nowhere" http://url.com
13. Hibakeresés
Gyakran előfordul, hogy egy webhely másképpen válaszol a curl-kérésekre, mint a böngészőkérésekre. Ebben az esetben a curl-et a lehető legnagyobb mértékben hozzá kell igazítania a böngészőhöz:
Jó segítő ebben a nehéz feladatban a Mozilla/Firefox LiveHTTPHeader beépülő modul, amely lehetővé teszi az összes fejléc megtekintését, amelyet a böngésző küld és fogad (még HTTPS használata esetén is).
Egy alacsonyabb szintű megközelítés a hálózat HTTP-forgalmának rögzítése olyan programokkal, mint az ethereal vagy a tcpdump, majd elemzi, hogy a böngésző milyen fejléceket kapott és küldött (a HTTPS ezt a megközelítést nem hatékonyan teszi).
Az RFC 2616 kötelező olvasmány mindenkinek, aki meg akarja érteni a HTTP protokollt.
Az RFC 2396 elmagyarázza az URL-szintaxist.
Az RFC 2109 határozza meg a cookie-k működését.
Az RFC 1867 határozza meg a fájlfeltöltési bejegyzés formátumát.
http://openssl.planetmirror.com - Kezdőlap az OpenSSL projekt
http://curl.haxx.se – a cURL projekt honlapja
