(PHP 4 >= 4.0.2, PHP 5, PHP 7)

curl_setopt — Beállít egy paramétert a CURL munkamenethez

A paraméterek listája

cURL-leíró, amely innen származik curl_init().

Beállítandó paraméter CURLOPT_XXX.

Az opció paraméter értéke.

bool:

Paraméter		Megjegyzések
CURLOPT_AUTOREFERER	IGAZ az automatikus terepi beállításhoz Hivatkozó: a fejléc által átirányított kérésekben Elhelyezkedés:.
CURLOPT_BINARYTRANSFER	IGAZ a nyers válasz visszaadásához konstans használatakor CURLOPT_RETURNTRANSFER.	A PHP 5.1.3-tól kezdve ez az opció már nem szükséges: az opció használatakor mindig nyers kimenet jelenik meg CURLOPT_RETURNTRANSFER.
CURLOPT_COOKIESESSION	IGAZ hogy utasítsa az aktuális munkamenetet a cookie-k új "munkamenetének" elindítására. Ez azt eredményezi, hogy a libcurl figyelmen kívül hagy minden olyan "munkamenet" cookie-t, amelyet az előző munkamenetből kellett volna betöltenie. Alapértelmezés szerint a libcurl mindig elmenti és betölti az összes cookie-t, függetlenül attól, hogy "munkamenet"-e vagy sem. A "munkamenet" cookie-k olyan cookie-k, amelyek nem járnak le, és csak az aktuális "munkamenet" alatt létezhetnek.
CURLOPT_CERTINFO	IGAZ az SSL-tanúsítvány információinak adatfolyamba történő kiadásához STDERR biztonságos kapcsolatokkal.	Hozzáadva a cURL 7.19.1-hez. PHP 5.3.2-től elérhető. A megfelelő működéshez engedélyezni kell ezt az opciót CURLOPT_VERBOSE.
CURLOPT_CONNECT_ONLY	IGAZ utasítja a könyvtárat, hogy végezze el a szükséges proxy hitelesítést és a kapcsolat beállítását, de nem továbbít adatokat. Ez az opció HTTP, SMTP és POP3 esetén van megvalósítva.	Hozzáadva: 7.15.2. PHP 5.5.0-tól érhető el.
CURLOPT_CRLF	IGAZ a Unix sorvégződések CRLF-re konvertálásához.
CURLOPT_DNS_USE_GLOBAL_CACHE	IGAZ a globális DNS-gyorsítótár használatához. Ez az opció nem biztonságos, és alapértelmezés szerint engedélyezve van.
CURLOPT_FAILONERROR	IGAZ részletes hibajelentéshez, ha a kapott HTTP-kód nagyobb vagy egyenlő, mint 400. Az alapértelmezett viselkedés az oldalt a szokásos módon adja vissza, figyelmen kívül hagyva a kódot.
CURLOPT_FILETIME	IGAZ hogy megpróbálja lekérni egy távoli dokumentum módosítási dátumát. Ezt az értéket a függvény CURLINFO_FILETIME paraméterével kaphatjuk meg curl_getinfo().
CURLOPT_FOLLOWLOCATION	IGAZ hogy kövesse bármelyik címsort "Helyszín:" a szerver küldi el válaszában (vegye figyelembe, hogy ez rekurzív módon történik, a PHP követni fogja az elküldött fejléceket "Helyszín:", kivéve ha állandó van beállítva CURLOPT_MAXREDIRS).
CURLOPT_FORBID_REUSE	IGAZ egy kapcsolat bezárására kényszeríteni a feldolgozás befejezése után, hogy ne lehessen újra felhasználni.
CURLOPT_FRESH_CONNECT	IGAZ hogy a gyorsítótárban tárolt helyett új kapcsolatot kényszerítsünk.
CURLOPT_FTP_USE_EPRT	IGAZ az EPRT (és az LPRT) használatához az aktív FTP-feltöltésekhez. Használat HAMIS az EPRT és az LPRT letiltásához és csak a PORT használatához.
CURLOPT_FTP_USE_EPSV	IGAZ az EPSV parancs kezdeti teszteléséhez FTP átvitel közben. Ha a parancs meghiúsul, akkor visszaáll a PASV-be. Telepítse be HAMIS az EPSV letiltásához.
CURLOPT_FTP_CREATE_MISSING_DIRS	IGAZ hiányzó könyvtárak létrehozásához, ha egy FTP művelet nem létező elérési úttal találkozik.
CURLOPT_FTPAPPEND	IGAZ hogy egy távoli fájlt a végére írjon, ahelyett, hogy felülírná egy meglévő fájlt.
CURLOPT_TCP_NODELAY	Véglegesen meghatározza, hogy a TCP_NODELAY beállítást be kell-e állítani vagy törölni kell (1 = beállítva, 0 = törölve). Alapértelmezés szerint az opció törlődik.	Elérhető a PHP 5.2.1-től a libcurl 7.11.2 vagy újabb verziójával készült verziókhoz.
CURLOPT_FTPASCII	Becenév CURLOPT_TRANSFERTEXT. Használja ezt helyette.
CURLOPT_FTPLISTONLY	IGAZ hogy csak egy névlistát adjon vissza az FTP-könyvtárból.
CURLOPT_HEADER	IGAZ fejlécek szerepeltetéséhez a kimenetben.
CURLINFO_HEADER_OUT	IGAZ a lekérdezési karakterlánc követéséhez.	PHP 5.1.3-tól elérhető. Előtag CURLINFO_ kifejezetten használják.
CURLOPT_HTTPGET	IGAZ a HTTP-kérés metódusának visszaállításához a GET metódusra. Mivel a GET az alapértelmezett, erre a paraméterre csak akkor van szükség, ha a kérési módot korábban módosították.
CURLOPT_HTTPPROXYTUNNEL	IGAZ a megadott HTTP-proxyn keresztüli alagútra.
CURLOPT_MUTE	IGAZ a cURL függvény üzeneteinek teljes letiltásához.	Eltávolítva a cURL 7.15.5-ben (a CURLOPT_RETURNTRANSFER opció használható)
CURLOPT_NETRC	IGAZ hogy beolvassa a ~/.netrc fájlt a bejelentkezési névhez és a jelszóhoz ahhoz a távoli helyhez, amellyel a kapcsolat jön létre.
CURLOPT_NOBODY	IGAZ hogy a választestet kizárjuk a kimenetből. A kérési mód HEAD értékre van állítva. A beállítás módosítása erre: HAMIS nem változtatja vissza GET-re.
CURLOPT_NOPROGRESS	IGAZ a folyamatjelző letiltásához a cURL átviteleknél. Megjegyzés: A PHP automatikusan beállítja ezt a paramétert IGAZ, csak hibakeresési célból módosítsa.
CURLOPT_NOSIGNAL	IGAZ figyelmen kívül hagyni minden olyan cURL függvényt, amely jeleket küld a PHP folyamatnak. Ez a beállítás alapértelmezés szerint engedélyezve van a többszálú SAPI-kban, hogy az időtúllépési paraméterek megfelelően működjenek.
CURLOPT_POST	IGAZ a szokásos HTTP POST használatához. Ez a POST módszer a normált használja , amelyet általában a HTML-űrlapokban használnak.
CURLOPT_PUT	IGAZ fájl letöltéséhez a HTTP PUT metódus használatával. A használt fájlt az opciók segítségével kell beállítani CURLOPT_INFILEÉs CURLOPT_INFILESIZE.
CURLOPT_RETURNTRANSFER	IGAZ hogy az átvitel eredményét karakterláncként adja vissza curl_exec() a böngészőbe történő közvetlen kimenet helyett.
CURLOPT_SAFE_UPLOAD	IGAZ az előtagok támogatásának letiltásához @ a letöltött fájlokhoz CURLOPT_POSTFIELDS, ami azt jelenti, hogy az értékek átmentek vele @ biztonságosan továbbítható mezőként. Előtag helyett használhatja a lehetőséget CURLFile d.	Hozzáadva a PHP 5.5.0-hoz alapértelmezett értékkel HAMIS. A PHP 5.6.0-ban alapból egyenlő lett IGAZ.
CURLOPT_SSL_VERIFYPEER	HAMIS hogy a cURL ne ellenőrizze a gazdagép tanúsítványt. Alternatív ellenőrizendő tanúsítványok a paraméter segítségével adhatók meg CURLOPT_CAINFO vagy a paraméter által megadott tanúsítványokat tartalmazó könyvtárat CURLOPT_CAPATH.	Az alapértelmezett IGAZ a cURL 7.10-es verziója óta. Az alapértelmezett disztribúció a cURL 7.10-es verziójától kezdődően kerül telepítésre.
CURLOPT_TRANSFERTEXT	IGAZ az ASCII mód használatához az FTP-átvitelhez. LDAP használatakor az adatok HTML helyett egyszerű szövegben kerülnek visszaadásra. Windows rendszereken a szál STDOUT nem áll bináris módba.
CURLOPT_UNRESTRICTED_AUTH	IGAZ a bejelentkezés és a jelszó küldésének folytatásához az átirányítások során (a CURLOPT_FOLLOWLOCATION), akkor is, ha a gazdagépnév megváltozik.
CURLOPT_UPLOAD	IGAZ felkészülni a fájl szerverre való feltöltésére.
CURLOPT_VERBOSE	IGAZ további információk megjelenítéséhez. A kimenetet egy adatfolyamba írja STDERR, vagy a paraméter által megadott fájl CURLOPT_STDERR.

A következő opcióparaméter-értékeknél az értékparaméternek típusúnak kell lennie egész szám:

Paraméter	Állítsa be az érték értékét	Megjegyzések
CURLOPT_BUFFERSIZE	Az egyes leolvasásokhoz használt puffer mérete. Azonban nincs garancia arra, hogy ez a kérés teljesül.	Hozzáadva a cURL 7.10-hez.
CURLOPT_CLOSEPOLICY	Az egyik állandó CURLCLOSEPOLICY_*. Megjegyzés: Ez a lehetőség elavult, mivel soha nem volt implementálva a cURL-ben, és nem működött.	PHP 5.6.0-ban eltávolítva.
CURLOPT_CONNECTTIMEOUT	A csatlakozási kísérlet során várakozni kívánt másodpercek száma. Használja a 0-t a határozatlan ideig tartó várakozáshoz.
CURLOPT_CONNECTTIMEOUT_MS	A csatlakozási kísérlet során várakozni kívánt ezredmásodpercek száma. Használja a 0-t a határozatlan ideig tartó várakozáshoz. Ha a libcurl a rendszer szabványos névfeloldójával van lefordítva, akkor a kapcsolat továbbra is egy teljes másodperces várakozást használ időtúllépésként, a minimális megengedett időtúllépéssel 1 másodperc.	Hozzáadva a cURL 7.16.2-es verziójához. PHP 5.2.3-tól elérhető.
CURLOPT_DNS_CACHE_TIMEOUT	A DNS-rekordok memóriájában tárolt másodpercek száma. Alapértelmezés szerint ez a paraméter 120 (2 perc).
CURLOPT_FTPSSLAUTH	FTP hitelesítési módszer (aktív módban): CURLFTPAUTH_SSL(Az SSL-t először ellenőrizzük), CURLFTPAUTH_TLS(először a TLS-t ellenőrizték) ill CURLFTPAUTH_DEFAULT(a cURL maga dönt).	Hozzáadva a cURL 7.12.2-es verziójához.
CURLOPT_HTTP_VERSION	CURL_HTTP_VERSION_NONE (alapértelmezés szerint a CURL választja ki, hogy melyik verziót használja), CURL_HTTP_VERSION_1_0 (HTTP/1.0 kényszerítése) vagy CURL_HTTP_VERSION_1_1 (HTTP/1.1 kényszerítése).
CURLOPT_HTTPAUTH	Használhatja a bitenkénti operátort | (vagy) több módszer kombinálása. Ebben az esetben a cURL lekérdezi a kiszolgálót a támogatott engedélyezési módszerekről, és kiválasztja a legjobbat. A CURLAUTH_ANY egy álnév CURLAUTH_BASIC | CURLAUTH_DIGEST | CURLAUTH_GSSSNEGOTIATE | CURLAUTH_NTLM. A CURLAUTH_ANYSAFE egy álnév CURLAUTH_DIGEST | CURLAUTH_GSSSNEGOTIATE | CURLAUTH_NTLM.
CURLOPT_INFILESIZE	A várt fájlméret bájtban egy fájl távoli szerverre való feltöltésekor. Kérjük, vegye figyelembe, hogy ennek az opciónak a használata nem akadályozza meg az ezen értéket meghaladó további adatok küldését, mivel az elküldött adatok az eredménytől függenek CURLOPT_READFUNCTION.
CURLOPT_LOW_SPEED_LIMIT	Az adatátviteli sebesség felső küszöbértéke, bájt per másodperc. Az ellenőrzés belül történik CURLOPT_LOW_SPEED_TIME másodpercig, ami után a PHP túl lassúnak tartja az átvitelt, és megszakítja azt.
CURLOPT_LOW_SPEED_TIME	A másodpercek maximális száma, amely alatt az átviteli sebesség nem haladhatja meg CURLOPT_LOW_SPEED_LIMIT, ellenkező esetben a PHP túl lassúnak jelöli az átvitelt, és leállítja.
CURLOPT_MAXCONNECTS	Az állandó kapcsolatok maximális száma. A határérték elérésekor a paraméter határozza meg, hogy melyik kapcsolatot kell lezárni. CURLOPT_CLOSEPOLICY.
CURLOPT_MAXREDIRS	Az elfogadott átirányítások maximális száma. Használja ezt az opciót az opcióval együtt CURLOPT_FOLLOWLOCATION.
CURLOPT_PORT	Alternatív csatlakozási port.
CURLOPT_POSTREDIR	Egy bitmaszk, amely 1-et (301 véglegesen áthelyezve), 2-t (302 talált) és 4-et (303 Lásd Egyéb) tartalmaz annak meghatározására, hogy a HTTP POST metódust fel kell-e dolgozni, ha az opció engedélyezve van. CURLOPT_FOLLOWLOCATION ha a megadott típusú átirányítás megtörtént.	Hozzáadva a cURL 7.19.1-hez. PHP 5.3.2 óta elérhető.
CURLOPT_PROTOCOLS	Értékek bitmaszkja CURLPROTO_*. Ez a maszk korlátozza a libcurl által használt protokollokat. Ez lehetővé teszi, hogy a libcurl számos protokollal működjön, és bizonyos átvitelek működését csak egy részhalmazára korlátozza. Alapértelmezés szerint a libcurl az összes támogatott protokollt használja. Lásd még paraméter CURLOPT_REDIR_PROTOCOLS. Correct protocol values: CURLPROTO_HTTP , CURLPROTO_HTTPS , CURLPROTO_FTP , CURLPROTO_FTPS , CURLPROTO_SCP , CURLPROTO_SFTP , CURLPROTO_TELNET , CURLPROTO_LDAP , CURLPROTO_LDAPS , CURLPROTO_DICT , CURLPROTO_FILE , CURLP ROTO_TFTP, CURLPROTO_ALL
CURLOPT_PROXYAUTH	A proxyszerverhez való csatlakozáskor használt HTTP hitelesítési módszerek. Használja ugyanazokat a bitmaszkokat, amelyeket a paraméternél leírtunk CURLOPT_HTTPAUTH. Jelenleg csak a CURLAUTH_BASIC és a CURLAUTH_NTLM támogatja a proxy hitelesítését.	Hozzáadva a cURL 7.10.7-es verziójához.
CURLOPT_PROXYPORT	Annak a proxyszervernek a portszáma, amelyhez a kapcsolat létrejön. Ez a szám a paraméter segítségével is beállítható CURLOPT_PROXY.
CURLOPT_PROXYTYPE	Vagy a CURLPROXY_HTTP (alapértelmezett) vagy a CURLPROXY_SOCKS5.	Hozzáadva a cURL 7.10-hez.
CURLOPT_REDIR_PROTOCOLS	Értékek bitmaszkja CURLPROTO_*. Ez a bitmaszk korlátozza a libcurl által az átirányítás során használt protokollokat (engedélyezett paraméter mellett CURLOPT_FOLLOWLOCATION). Ez lehetővé teszi, hogy korlátozza az egyes átvitelek átirányításánál használt protokollkészletet. Alapértelmezés szerint a libcurl a FILE és az SCP kivételével minden protokollt támogat. A 7.19.4 előtti verziókban az átirányítást kivétel nélkül minden protokollnál alkalmazták. Lásd még a paraméter leírását CURLOPT_PROTOCOLS a protokollértékekkel rendelkező konstansok listájához.	Hozzáadva a cURL 7.19.4-es verziójához.
CURLOPT_RESUME_FROM	Az átvitel kezdeti eltolása, bájtban.
CURLOPT_SSL_VERIFYHOST	Használja az 1-et annak ellenőrzésére, hogy van-e általános név az SSL-tanúsítványban. Használja a 2-t annak ellenőrzésére, hogy a közös név létezik, és megegyezik-e a megadott gazdagéppel. Harci környezetben ennek a paraméternek 2-nek kell lennie (alapértelmezés szerint beállítva).	Az 1. érték támogatása megszűnt a cURL 7.28.1-ben
CURLOPT_SSLVERSION	Az egyik állandó CURL_SSLVERSION_DEFAULT (0), CURL_SSLVERSION_TLSv1 (1), CURL_SSLVERSION_SSLv2 (2), CURL_SSLVERSION_SSLv3 (3), CURL_SSLVERSION_TLSv1_0 (4), CURL_SSLVERSION_TLSv1_1(5) vagy CURL_SSLVERSION_TLSv1_2 (6).
CURLOPT_TIMECONDITION	Paraméter értelmezési módszer CURLOPT_TIMEVALUE. A CURL_TIMECOND_IFMODSINCE használatával csak akkor adja vissza az oldalt, ha az megváltozott a paraméterben megadott idő óta CURLOPT_TIMEVALUE. Ha az oldalt nem módosították, a cím visszaadásra kerül "304 nem módosítva", ami arra utal, hogy a paraméter CURLOPT_HEADER beépítve IGAZ. Az ellenkező hatás eléréséhez használja a CURL_TIMECOND_IFUNMODSINCE. Az alapértelmezett érték CURL_TIMECOND_IFMODSINCE.
CURLOPT_TIMEOUT	A cURL függvények végrehajtására engedélyezett maximális másodpercek száma.
CURLOPT_TIMEOUT_MS	A cURL-függvények végrehajtásához megengedett maximális számú ezredmásodperc. Ha a libcurl a normál rendszernév-feloldó használatával épül fel, akkor ez a kapcsolati szakasz továbbra is a második kerekítési időtúllépéseket fogja használni, és a megengedett minimális időkorlát egy másodperc.	Hozzáadva a cURL 7.16.2-es verziójához. PHP 5.2.3-tól elérhető.
CURLOPT_TIMEVALUE	A másodpercek száma 1970. január 1. óta. Ezt az időt a paraméter fogja használni CURLOPT_TIMECONDITION. Alapértelmezés szerint a CURL_TIMECOND_IFMODSINCE paraméter használatos.
CURLOPT_MAX_RECV_SPEED_LARGE	Ha a letöltési sebesség a teljes átvitel során átlagosan meghaladja ezt az értéket (bájt/másodpercben megadva), a letöltés szünetel, hogy az átlagos sebesség ennél a paraméternél kisebb vagy egyenlő maradjon. Alapértelmezés szerint a sebesség nincs korlátozva.
CURLOPT_MAX_SEND_SPEED_LARGE	Ha a szerverre történő feltöltés átlagosan meghaladja ezt az értéket (bájt/másodpercben megadva) átlagosan a teljes átvitel során, a feltöltés szünetel, hogy ennél a paraméternél kisebb vagy azzal egyenlő átlagos sebességet tartson fenn. Alapértelmezés szerint a sebesség nincs korlátozva.	Hozzáadva a cURL 7.15.5-höz. PHP 5.4.0-tól kezdve elérhető.
CURLOPT_SSH_AUTH_TYPES	Egy vagy több állandóból álló bitmaszk: CURLSSH_AUTH_PUBLICKEY, CURLSSH_AUTH_PASSWORD, CURLSSH_AUTH_HOST, CURLSSH_AUTH_KEYBOARD. Telepítés CURLSSH_AUTH_ANY hogy a libcurl önállóan válasszon közülük egyet.	Hozzáadva a cURL 7.16.1-hez.
CURLOPT_IPRESOLVE	Lehetővé teszi egy alkalmazás számára, hogy kiválassza az IP-cím típusát, amellyel a gazdagépnevet meghatározza. Erre akkor van szükség, ha olyan gazdagépnevet használ, amely az IP-cím egynél több verziójából származik. Lehetséges értékek lehetnek CURL_IPRESOLVE_WHATEVER, CURL_IPRESOLVE_V4, CURL_IPRESOLVE_V6, és alapértelmezés szerint CURL_IPRESOLVE_WHATEVER.	Hozzáadva a cURL 7.10.8-hoz.

A következő opcióparaméter-értékeknél az értékparaméternek típusúnak kell lennie húr:

Paraméter	Állítsa be az érték értékét	Megjegyzések
CURLOPT_CAINFO	Egy vagy több tanúsítványt tartalmazó fájl neve, amelyhez képest a csomópontok ellenőrzésre kerülnek. Ennek a paraméternek csak akkor van értelme, ha együtt használjuk CURLOPT_SSL_VERIFYPEER.	Abszolút útvonalat igényel.
CURLOPT_CAPATH	Több CA-tanúsítványt tartalmazó könyvtár. Használja ezt a lehetőséget a következővel együtt CURLOPT_SSL_VERIFYPEER.
CURLOPT_COOKIE	Fejléc tartalma "Aprósütemény:", amelyet a HTTP-kérésben használnak. Kérjük, vegye figyelembe, hogy több cookie pontosvesszővel és szóközzel van elválasztva (például " gyümölcs=alma; szín=piros")
CURLOPT_COOKIEFILE	A cookie-kat tartalmazó fájl neve. Ennek a fájlnak Netscape formátumban kell lennie, vagy egyszerűen a fájlhoz írt HTTP-fejlécek. Ha üres karakterláncot adunk át fájlnévként, a cookie-k nem kerülnek mentésre, de feldolgozásuk továbbra is engedélyezve lesz.
CURLOPT_COOKIEJAR	Annak a fájlnak a neve, amelybe az aktuális átvitel összes belső cookie-ja mentésre kerül a fogantyú bezárása után, például a curl_close meghívása után.
CURLOPT_CUSTOMREQUEST	Ehelyett használt egyéni kérési módszer "KAP" vagy "FEJ" HTTP-kérés esetén. Ez hasznos lekérdezéseknél "TÖRÖL" vagy más, ritkább HTTP-kérések. A helyes jelentések olyan szavak lennének, mint "KAP", "POST", "CONNECT" stb; azok. Ne írja be ide a teljes HTTP kérés sort. Például egy jelzés "GET /index.html HTTP/1.0\r\n\r\n" rossz lesz. Megjegyzés: Ne használja ezt a funkciót, amíg meg nem bizonyosodott arról, hogy a kiszolgáló támogatja az ilyen típusú kéréseket.
CURLOPT_EGDSOCKET	Mint CURLOPT_RANDOM_FILE, kivéve, hogy a fájlnév az Entropy Gathering Daemon socketre van állítva.
CURLOPT_ENCODING	Fejléc tartalma "Accept-Encoding:". Ez lehetővé teszi a kérés dekódolását. A támogatott kódolások "identitás", "kienged"És "gzip". Ha üres karakterláncot adunk át, "" , akkor a rendszer elküldi az összes támogatott kódolási típust tartalmazó fejlécet.	Hozzáadva a cURL 7.10-hez.
CURLOPT_FTPPORT	Az az érték, amely az FTP "PORT" parancs IP-címének meghatározására szolgál. A "PORT" parancs megmondja a szervernek, hogy melyik IP-címhez kell csatlakoznia. Ez lehet egy IP-cím, egy gazdagépnév, egy hálózati interfésznév (Unix alatt), vagy egyszerűen "-" az alapértelmezett rendszer IP-címének használatához.
CURLOPT_INTERFACE	A használni kívánt hálózati interfész neve. Lehet interfésznév, IP-cím vagy gazdagépnév.
CURLOPT_KEYPASSWD	A privát kulcs használatához szükséges jelszó CURLOPT_SSLKEY vagy CURLOPT_SSH_PRIVATE_KEYFILE.	Hozzáadva a cURL 7.16.1-hez.
CURLOPT_KRB4LEVEL	KRB4 biztonsági szint (Kerberos 4). A következő értékek bármelyike ​​helyes (a leggyengébbtől a legerősebbig): "egyértelmű", "biztonságos", "bizalmas", "magán".. Ha a megadott karakterlánc eltér a megadott értékektől, akkor az érték kerül felhasználásra "magán". Ennek az opciónak a beállítása NULLA teljesen letiltja a KRB4 biztonságát. Jelenleg a KRB4 biztonság csak FTP-tranzakciókkal működik.
CURLOPT_POSTFIELDS	HTTP POST kérésben továbbított összes adat. Fájl átviteléhez adja meg a fájl nevét @ , és használja a fájl teljes elérési útját is. A fájl típusa a következő formátumban is megadható ;type=mimetype" a fájlnév után. Ez a paraméter url-kódolt karakterláncként adható át, például " para1=val1¶2=val2&...", és egy tömb formájában, amelynek kulcsai a mezők nevei lesznek, az értékek pedig azok tartalma. Ha az érték egy tömb, akkor a fejléc Tartalom típusértékre lesz beállítva többrészes/forma-adatok. PHP 5.2.0-tól kezdve az előtaggal rendelkező fájlok átvitelekor @ , az értéknek tömbnek kell lennie. A PHP 5.5.0 óta, előtag @ elavult, és a fájlok a használatával küldhetők CURLFile. Előtag @ letiltható, hogy a karakterekkel kezdődő értékeket engedélyezze @ opció beállításával CURLOPT_SAFE_UPLOAD jelentésében IGAZ.
CURLOPT_PROXY	HTTP-proxy, amelyen keresztül a kérések továbbításra kerülnek.
CURLOPT_PROXYUSERPWD	Az űrlapba írt bejelentkezési név és jelszó ":" , akkor használatos, ha proxyn keresztül csatlakozik.
CURLOPT_RANDOM_FILE	Az SSL véletlenszám-generátorának inicializálásához használt fájl neve.
CURLOPT_RANGE	Letöltendő adatok köre, formátumban "X-Y", és az X vagy az Y elhagyható. A HTTP protokoll több vesszővel elválasztott tartomány átvitelét is támogatja, ezek a formátumban vannak megadva "X-Y, N-M".
CURLOPT_REFERER	Fejléc tartalma "Hivatkozó:", amelyet a HTTP-kérésben fog használni.
CURLOPT_SSH_HOST_PUBLIC_KEY_MD5	32 hexadecimális számjegyet tartalmazó karakterlánc. A karakterláncnak a távoli számítógép nyilvános kulcsának MD5 ellenőrző összegének kell lennie, és a libcurl visszaállítja a kapcsolatot a távoli gazdagéppel mindaddig, amíg az ellenőrző összeg meg nem egyezik a nyilvános kulccsal. Ez az opció csak SCP és SFTP használatával történő adatátvitelre vonatkozik.	Hozzáadva a cURL 7.17.1-hez.
CURLOPT_SSH_PUBLIC_KEYFILE	A nyilvános kulcs fájlneve. Ha nincs megadva, a libcurl alapértelmezett értéke a $HOME/.ssh/id_dsa.pub fájl, ha a HOME környezeti változó be van állítva, és az „id_dsa.pub” fájl az aktuális könyvtárban, ha a HOME környezeti változó nincs beállítva.	Hozzáadva a cURL 7.16.1-hez.
CURLOPT_SSH_PRIVATE_KEYFILE	A privát kulcs fájlneve. Ha nincs megadva, a libcurl alapértelmezés szerint a $HOME/.ssh/id_dsa fájlt használja, ha a HOME környezeti változó be van állítva, és az "id_dsa" fájlt az aktuális könyvtárban, ha a HOME környezeti változó nincs beállítva. Ha a fájl jelszóval védett, állítsa be a jelszót a segítségével CURLOPT_KEYPASSWD.	Hozzáadva a cURL 7.16.1-hez.
CURLOPT_SSL_CIPHER_LIST	Az SSL átvitelekhez használt titkosítások listája. Például, RC4-SHAÉs TLSv1érvényes titkosítási listák.
CURLOPT_SSLCERT	Egy megfelelően formázott PEM-tanúsítvánnyal rendelkező fájl neve.
CURLOPT_SSLCERTPASSWD	A tanúsítvány használatához szükséges jelszó CURLOPT_SSLCERT.
CURLOPT_SSLCERTTYPE	Tanúsítvány formátuma. Támogatott formátumok "PEM"(alapértelmezett), "DER"És "HUN".	Hozzáadva a cURL 7.9.3-as verziójához.
CURLOPT_SSLENGINE	A paraméterben megadott titkosítási motor azonosítója az SSL privát kulcshoz CURLOPT_SSLKEY.
CURLOPT_SSLENGINE_DEFAULT	Az aszimmetrikus titkosítási műveletekhez használt titkosítási mechanizmus azonosítója.
CURLOPT_SSLKEY	Az SSL privát kulcs fájl neve.
CURLOPT_SSLKEYPASSWD	A paraméter által megadott SSL privát kulcs használatához szükséges titkos jelszó CURLOPT_SSLKEY. Megjegyzés: Mivel ez a paraméter értékes jelszót tartalmaz, ne felejtse el biztonságos helyen tartani ezt a PHP-szkriptet.
CURLOPT_SSLKEYTYPE	A paraméterben megadott SSL privát kulcs típusa CURLOPT_SSLKEY. A következő kulcstípusok támogatottak: "PEM"(alapértelmezett), "DER"És "HUN".
CURLOPT_URL	Letölthető URL. Ez a paraméter a munkamenet inicializálása során is beállítható curl_init().
CURLOPT_USERAGENT	Fejléc tartalma "Felhasználói ügynök:", HTTP-kérésben küldött.
CURLOPT_USERPWD	A csatlakozás során használt bejelentkezési név és jelszó, a formátumban megadva ":" .

A következő opcióparaméter-értékeknél az értékparaméternek egy tömbnek kell lennie:

Paraméter	Állítsa be az érték értékét	Megjegyzések
CURLOPT_HTTP200ALIASES	HTTP 200 válaszok tömbje, amelyeket a rendszer helyes válaszként kezel, nem pedig hibás válaszként.	Hozzáadva a cURL 7.10.3-as verziójához.
CURLOPT_HTTPHEADER	Beállított HTTP-fejlécek tömbje tömb ("Tartalom típusa: szöveg/sima", "Tartalom hossza: 100") formátumban.
CURLOPT_POSTQUOTE	A kiszolgálón végrehajtott FTP-parancsok tömbje az FTP-kérés befejezése után.
CURLOPT_QUOTE	A kiszolgálón végrehajtott FTP-parancsok tömbje FTP-kérés indítása előtt.

A következő opcióparaméter-értékeknél az értékparaméternek egy adatfolyam-leírónak kell lennie (amelyet például a függvény adja vissza fopen()):

Paraméter	Állítsa be az érték értékét
CURLOPT_FILE	A fájl, amelybe az átvitel eredménye be lesz írva. Alapértelmezett kimeneti adatfolyam STDOUT(böngésző ablak).
CURLOPT_INFILE	Az a fájl, amelyből az adatokat ki kell olvasni a szerverre való feltöltéskor.
CURLOPT_STDERR	A hibafolyam helyett használt alternatív hibakimeneti fájl STDERR.
CURLOPT_WRITEHEADER	A fájl, amelybe az aktuális művelet fejlécei kerülnek beírásra.

A következő opcióparaméter-értékeknél az értékparaméternek érvényes függvénynévnek vagy lezárásnak kell lennie:

Paraméter	Állítsa be az érték értékét
CURLOPT_HEADERFUNCTION	A visszahívási függvénynek két paramétere van. Az első paraméter a cURL-leíró, a második paraméter a megírandó fejléceket tartalmazó karakterlánc. A fejléceket ezzel a visszahívási funkcióval kell írni. A megírt bájtok számát kell visszaadnia.
CURLOPT_PASSWDFUNCTION	A visszahívási függvénynek három paramétere van. Az első paraméter a cURL-leíró, a második paraméter a jelszóprompt karakterlánc, a harmadik pedig a jelszó maximális hossza. A jelszót tartalmazó karakterláncot kell visszaadnia.
CURLOPT_PROGRESSFUNCTION	A visszahívási funkció öt paramétert vesz igénybe. Az első a cURL leíró, a második a szerverről várhatóan letölthető bájtok teljes száma, a harmadik a már letöltött bájtok száma, a negyedik a szerverre várhatóan elküldendő bájtok teljes száma, és az ötödik a már elküldött bájtok száma. Megjegyzés: A visszahívási funkció csak akkor hívható meg, ha az opció CURLOPT_NOPROGRESSértékre állítva HAMIS. Az átvitel megszakításához nullától eltérő értéket adhat vissza. Ebben az esetben hibaüzenet jelenik meg CURLE_ABORTED_BY_CALLBACK.
CURLOPT_READFUNCTION	A visszahívási függvénynek három paramétere van. Az első paraméter a cURL-leíró, a második paraméter a cURL-nek az opción keresztül átadott adatfolyam-erőforrás CURLOPT_INFILE, a harmadik paraméter pedig a kiolvasható adatok maximális megengedett mennyisége. A visszahívási függvénynek a kért adatmennyiségnél nem nagyobb hosszúságú karakterláncot kell visszaadnia, általában az átadott adatfolyam-erőforrásból olvasva. Üres karakterláncot kell visszaadnia, jelezve a fájl végét EOF.
CURLOPT_WRITEFUNCTION	A visszahívási függvénynek két paramétere van. Az első paraméter a cURL-leíró, a második paraméter pedig az írandó adatokat tartalmazó karakterlánc. Az adatokat ezzel a funkcióval kell menteni. Pontos számú bájtot kell visszaadnia, különben a letöltés hibával megszakad.

Egyéb jelentések:

Visszatérési értékek

Visszatér IGAZ sikeres teljesítése esetén ill HAMIS hiba esetén.

Változások listája

Változat	Leírás
5.6.0	választási lehetőség CURL_SAFE_UPLOAD most alapértelmezett értéke: IGAZ.
5.6.0	Eltávolított opció CURLOPT_CLOSEPOLICYés a hozzá tartozó jelentések.
5.5.0	A cURL erőforrás a visszahívási függvény első argumentumaként kerül hozzáadásra CURLOPT_PROGRESSFUNCTION.
5.5.0	Hozzáadott opció CURLOPT_SHARE.
5.3.0	Hozzáadott opció CURLOPT_PROGRESSFUNCTION.
5.2.10	Hozzáadott opciók CURLOPT_PROTOCOLSÉs CURLOPT_REDIR_PROTOCOLS.
5.1.0	Hozzáadott opciók CURLOPT_AUTOREFERER, CURLOPT_BINARYTRANSFER, CURLOPT_FTPSSLAUTH, CURLOPT_PROXYAUTHÉs CURLOPT_TIMECONDITION.
5.0.0	Hozzáadott opciók CURLOPT_FTP_USE_EPRT, CURLOPT_NOSIGNAL, CURLOPT_UNRESTRICTED_AUTH, CURLOPT_BUFFERSIZE, CURLOPT_HTTPAUTH, CURLOPT_PROXYPORT, CURLOPT_PROXYTYPE, CURLOPT_SSLCERTTYPEÉs CURLOPT_HTTP200ALIASES.

Példák

1. példa CURL munkamenet inicializálása és weboldal betöltése

// hozzon létre egy új cURL-erőforrást
$ch = curl_init();

/* http://localhost/upload.php:
print_r($_POST);
print_r($_FILES);
*/

$ch = curl_init();

$data = array("név" => "Foo" , "file" => "@/home/user/test.png" );

Curl_setopt($ch, CURLOPT_URL, "http://localhost/upload.php");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $adat);

Curl_exec($ch);
?>

A példa futtatásának eredménye:

Array ( => Foo) Array ( => Array ( => test.png => image/png => /tmp/phpcpjNeQ => 0 => 279))

Megjegyzések

Megjegyzés:

Tömb átadása a CURLOPT_POSTFIELDSígy kódolja az adatokat többrészes/forma-adatok, míg az URL-kódolású karakterlánc átadása az adatokat a következőképpen kódolja application/x-www-form-urlencoded.

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 eredetileg egy parancssori segédprogram. Szerencsére azonban a PHP támogatja a cURL könyvtárral való együttműködést. Ebben a cikkben a cURL-lel való munka nem triviális példáit tekintjük meg.

Miért cURL?

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ű PHP függvényeket használnak a 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 több protokollt is támogat, és teljes kérési információkat biztosít.

A curl alapjai

Mielőtt rátérnénk az összetett példákra, nézzük meg a PHP cURL-kérésének alapvető szerkezetét. A cURL kérés végrehajtásához PHP-ben 4 fő lépést kell végrehajtania:

1. Inicializálás.
2. Beállítási lehetőségek.
3. A kérés teljesítése.
4. Tisztító erőforrások.

// 1. inicializálás $ch = curl_init(); // 2. beállítások megadása, beleértve az URL-t curl_setopt($ch, CURLOPT_URL, "http://www.google.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_HEADER, 0); // 3. a kérés végrehajtása és a válasz fogadása $output = curl_exec($ch); // 4. erőforrások tisztítása curl_close($ch);

Leginkább a 2. lépéssel foglalkozunk ebben a cikkben, mivel itt történik a varázslat. A cURL opciók listája nagyon széles, ezért ma nem fogunk minden lehetőséget figyelembe venni, hanem azokat használjuk, amelyek konkrét problémák megoldásához hasznosak.

Hibakövetés

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); ) // ...

Kérjük, vegye figyelembe, hogy a „===”-t használjuk az „==” helyett, mert Különbséget kell tenni az üres szerverválasz és a FALSE logikai érték között, amelyet hiba esetén ad vissza.

Információk beszerzése egy kéréssel kapcsolatban

Egy másik választható lépés a cURL-kéréssel kapcsolatos információk beszerzése annak végrehajtása után.

// ... curl_exec($ch); $info = curl_getinfo($ch); echo "Vettem" . $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:

• "url"
• "tartalom típus"
• "http_code"
• "fejléc_mérete"
• "request_size"
• "fájlidő"
• "ssl_verify_result"
• "átirányítás_száma"
• "teljes idő"
• "namelookup_time"
• "csatlakozási_idő"
• "transzfer_időpontja"
• "size_upload"
• "size_download"
• "speed_download"
• "speed_upload"
• "download_content_length"
• "upload_content_length"
• "transzfer_kezdési időpontja"
• "átirányítási_idő"

Átirányítási követés, a böngészőtől függően

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. Egyes webhelyek például átirányítják a látogatókat mobileszközökről más országokból érkező látogatókhoz.

A CURLOPT_HTTPHEADER beállítást használjuk saját fejléceink beállítására, beleértve a User-Agent és a Language elemeket, é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(); // a cím beállítása curl_setopt($ch, CURLOPT_URL , $url); // jelzi a böngészőt és a használt nyelvet curl_setopt($ch, CURLOPT_HTTPHEADER, array("User-Agent: ($browser["user_agent"])", "Accept-Language: ($browser["nyelv" ]) ")); // nincs szükségünk az oldal tartalmára curl_setopt($ch, CURLOPT_NOBODY, 1); // csak fejlécekre van szükségünk curl_setopt($ch, CURLOPT_HEADER, 1); // helyette az eredményt adjuk vissza kimenetéből curl_setopt($ch, CURLOPT_RETURNTRANSFER , 1); $output = curl_exec($ch); curl_close($ch); // átirányításokat határoz meg a HTTP-fejlécekben? if (preg_match("!Location: (.*)!" , $kimenet, $egyezik)) ( 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 URL-hez. Először beállítjuk kérésünk beállításait: URL-t és böngészőt és tesztelendő nyelvet.

Mert Beállítottunk egy speciális opciót, a kérés eredménye csak HTTP fejléceket tartalmaz. Egy egyszerű reguláris kifejezés segítségével 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/ oldalra Francia: átirányít a http://edition.cnn oldalra .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

POST kérések küldése

GET kérések végrehajtásakor az adatok a lekérdezési karakterláncban adhatók át. Például amikor a Google-on keres, a lekérdezést a rendszer egy URL-címmé fordítja le:

http://www.google.com/search?q=google

A lekérdezés eredményének eléréséhez nincs is szükség cURL-re, lehet lusta és használhatja a "file_get_contents()"-t.

Néhány HTML-űrlap azonban a POST módszert használja. Ebben az esetben az adatokat a kérés üzenetének törzsében küldi el a rendszer, nem pedig magában az URL-ben.

Írjunk egy szkriptet, amely elküldi a POST kéréseket. Először hozzunk létre egy egyszerű PHP fájlt, 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.

Fájlok feltöltése

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 maga a szkript, amely letölti a fájlokat:

$url = "http://localhost/upload_output.php"; $post_data = tömb ("foo" => "bar", // feltöltendő fájl "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, ugyanúgy, mint egy normál POST kérési paraméternél, "@" előtaggal. A forgatókönyv eredménye:

Array ( => Array ( => desert.jpg => application/octet-stream => /tmp/phpAhEvXy => 0 => 845941))

Több cURL

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 lekérdezést kell végrehajtania, az sok időt vehet igénybe, mert... sorban fogsz teljesíteni. 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; // kérések végrehajtása do ( curl_multi_exec($mh, $running); ) while ($running > 0); // erőforrások felszabadítá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, egyesítheti őket egy többleíró alá, és aszinkron módon végrehajthatja őket.

Először is minden ugyanúgy történik, mint egy normál cURL kérésnél – létrejön egy leíró ( 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 reguláris leírók hozzáadódnak ( curl_multi_add_handle() ). A curl_exec() normál hívása helyett meg fogjuk hívni curl_multi_exec() ez a függvény 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 $running 0 lesz. És természetesen a munka befejezése után erőforrásokat kell felszabadítani.

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 egy nem triviális esetét.

Külső hivatkozások ellenőrzése a WordPressben

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 is 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 elvétele, 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 felesleges 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. Vizsgáljuk meg őket:

$mh = curl_multi_init(); // 1. hivatkozások hozzáadása ehhez: ($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 leírót a megadott URL függvénnyel add_url_to_multi_handle($mh, $url_list) ( static $index = 0; // ha vannak még hivatkozások if (isset($url_list[$index])) ( // minden a szokásos módon $ ch = curl_init(); // beállítások megadása curl_setopt($ch, CURLOPT_URL, $url_list[$index]); // az eredmény megjelenítése helyett curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // engedélyezés átirányítja a curl_setopt($ ch, CURLOPT_FOLLOWLOCATION, 1); // csak fejléceket kap, hogy időt takarítson meg curl_setopt($ch, CURLOPT_NOBODY, 1); // hozzáadás a több kezelőhöz 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):

1. Adunk hozzá egy kezdeti számú leírót, hogy ne terheljük túl a rendszert szálakkal. A számot a $max_connections változó szabályozza.
2. A $curRunning változó a futó szálak számát, a $running az előző értéket tárolja; ha egyenlőtlenné válnak, akkor az egyik szál befejezte a munkát.
3. A teljesített kérelemről tájékoztatást kapunk.
4. Ha nem érkezik válasz a szervertől, akkor a hivatkozás nem működik.
5. A szerver válasza 404.
6. Egyébként a link működik.
7. A kérés teljesítve, felszabadítjuk az erőforrásokat.
8. Adjunk hozzá egy új URL-t a többszörös leíróhoz.
9. Funkció add_url_to_multi_handle() hozzáad egy új leírót a megadott URL-lel a többleíróhoz.

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 egy leíró, amelyet innen kaptunk curl_multi_info_read() .

Egyéb cURL funkciók a PHP-ben

HTTP hitelesítés

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 elküldi a jelszót az átirányítás után curl_setopt($ch, CURLOPT_UNRESTRICTED_AUTH, 1); $kimenet = curl_exec($ch); curl_close($ch);

Feltöltés FTP-n keresztül

A PHP saját könyvtárral rendelkezik az FTP-vel való munkavégzéshez, de használhatja a cURL-t is:

// a 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);

Proxy használata

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);

Visszahívási funkciók

Lehetőség van visszahívások használatára, miközben a kérés fut, 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 kéré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.

Következtetés

Ebben a cikkben megvizsgáltuk a cURL fejlett funkcióit a PHP-ben. Ha legközelebb URL-kéréseket kell végrehajtania, használja a cURL-t.

Gyakran le kell töltenünk az internetről különféle fájlokat, például futtatható programfájlokat, szkriptfájlokat, forrásarchívumokat. De ezt nem mindig a böngészőn keresztül kell megtenni. Sok helyzetben sokkal könnyebb minden műveletet végrehajtani a terminálon keresztül. Mert így automatizálhatja a folyamatot. Másrészt a webmestereknek időről időre tesztelniük kell a webhely elérhetőségét, ellenőrizniük kell a küldött és fogadott fejléceket, és még sok mást.

Az ilyen problémák és hasonló tartományú problémák megoldásához használhatja a curl segédprogramot. Lehetővé teszi a problémák sokkal szélesebb körének megoldását, beleértve a felhasználói műveletek szimulálását is a webhelyen. Ebben a cikkben megvizsgáljuk, hogyan kell használni a curl-t, mi az, és miért van szükség erre a programra.

Valójában a curl több, mint egy parancssori segédprogram Linux vagy Windows számára. Ez egy olyan könyvtárkészlet, amely megvalósítja az URL-oldalak kezelésének és a fájlok átvitelének alapvető képességeit. A könyvtár támogatja a következő protokollokkal való munkát: FTP, FTPS, HTTP, HTTPS, TFTP, SCP, SFTP, Telnet, DICT, LDAP, valamint POP3, IMAP és SMTP. Kiválóan alkalmas az oldalakon végzett felhasználói műveletek és egyéb URL-ekkel végzett műveletek szimulálására.

A curl könyvtár támogatása számos különböző programozási nyelvhez és platformhoz került. A curl segédprogram ennek a könyvtárnak a független burkolója. Ebben a cikkben erre a segédprogramra összpontosítunk.

curl parancs

Mielőtt rátérnénk a curl linux parancs használatának leírására, nézzük meg magát a segédprogramot és annak főbb lehetőségeit, amelyekre szükségünk lesz. A segédprogram szintaxisa nagyon egyszerű:

$ curl opciók link

Most nézzük a főbb lehetőségeket:

• -# - egy egyszerű folyamatjelző sáv megjelenítése betöltés közben;
• -0 - használja a http 1.0 protokollt;
• -1 - használja a tlsv1 titkosítási protokollt;
• -2 - sslv2 használata;
• -3 - sslv3 használata;
• -4 - ipv4 használata;
• -6 - ipv6 használata;
• -A- adja meg USER_AGENT-jét;
• -b- mentse a cookie-t fájlba;
• -c- Cookie-t küld a szervernek egy fájlból;
• -C- folytassa a fájl letöltését a töréspontból vagy a megadott eltolásból;
• -m- maximális várakozási idő a szervertől érkező válaszra;
• -d- adatokat küldeni POST módszerrel;
• -D- a szerver által visszaadott fejléceket fájlba menteni;
• -e- állítsa be a Referer-uri mezőt, jelezve, hogy a felhasználó melyik oldalról érkezett;
• -E- külső SSL tanúsítvány használata;
• -f- ne jelenítsen meg hibaüzeneteket;
• -F- adatlapot nyomtatvány formájában küldeni;
• -G- ha ez az opció engedélyezve van, akkor a -d opcióban megadott összes adat a GET metódussal kerül továbbításra;
• -H- fejlécek átvitele a szerverre;
• -ÉN- csak a HTTP fejlécet fogadja, és figyelmen kívül hagyja az oldal teljes tartalmát;
• -j- sütiket olvasni és küldeni egy fájlból;
• -J- fejléc eltávolítása a kérésből;
• -L- átirányítások elfogadása és feldolgozása;
• -s- a Location használatával történő átirányítások maximális száma;
• -o- az oldal tartalmát fájlba írja ki;
• -O- mentse el a tartalmat egy fájlba az oldal vagy fájl nevével a szerveren;
• -o- proxy használata;
• --proto- jelezze a használni kívánt protokollt;
• -R- mentse el egy távoli fájl utolsó módosítási idejét;
• -s- minimális információ megjelenítése a hibákról;
• -S- hibaüzenetek megjelenítése;
• -T- feltölteni a fájlt a szerverre;
• -v- a legrészletesebb kimenet;
• -y- minimális letöltési sebesség;
• -Y- maximális letöltési sebesség;
• -z- csak akkor töltse le a fájlt, ha azt a megadott időpontnál később módosították;
• -V- megjeleníti a verziót.

Ez egyáltalán nem minden opció a curl linuxhoz, de felsorolja azokat az alapokat, amelyeket használnia kell.

Hogyan kell használni a curl-t?

Mindennel foglalkoztunk, ami a curl segédprogrammal való munka elméletével kapcsolatos, most itt az ideje, hogy továbblépjünk a gyakorlatba, és nézzünk példákat a curl parancsra.

A leggyakoribb feladat ez. A fájl letöltése nagyon egyszerű. Ehhez csak adja át a fájlnevet vagy a html oldalt a segédprogramnak a paraméterekben:

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

De itt egy meglepetés vár rád: a fájl teljes tartalma standard kimenetre kerül. Bármely fájlba írásához használja:

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

És ha azt szeretné, hogy az eredményül kapott fájl ugyanaz legyen, mint a kiszolgálón, használja a -O kapcsolót:

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

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

Ha szükséges, több fájlt is letölthet egyetlen paranccsal:

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

Egy másik dolog, ami hasznos lehet az adminisztrátor számára, hogy csak akkor tölt le egy fájlt, ha azt módosították:

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

Sebességkorlátozás

A letöltési sebességet a szükséges határértékre korlátozhatja, hogy ne terhelje túl a hálózatot az -Y kapcsolóval:

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

Itt meg kell adni, hogy másodpercenként hány kilobájtot lehet letölteni. Megszakíthatja a kapcsolatot is, ha a sebesség nem elegendő, ehhez használja a -Y kapcsolót:

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

Fájlok átvitele

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

Vagy nézzük meg, hogy a fájl elküldése HTTP-n keresztül történik-e, erre van egy speciális szolgáltatás:

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

A válaszban a segédprogram megmondja, hol találja a letöltött fájlt.

POST adatok küldése

Nem csak fájlokat, hanem bármilyen adatot is küldhet a POST módszerrel. Hadd emlékeztesselek arra, hogy ezt a módszert különféle formájú adatok küldésére használják. Ilyen kérés küldéséhez használja a -d kapcsolót. A teszteléshez ugyanazt a szolgáltatást fogjuk használni:

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

Ha nem elégedett ezzel a beküldési lehetőséggel, úgy tehet, mintha elküldi az űrlapot. Van erre egy lehetőség -F:

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

Itt egyszerű szövegként adjuk át a jelszó mezőt az űrlappal, ugyanígy több paramétert is átadhatunk.

Cookie-k küldése és fogadása

A cookie-kat a weboldalak arra használják, hogy bizonyos információkat tároljanak a felhasználói oldalon. Erre például hitelesítéshez lehet szükség. Cookie-kat küldhet és fogadhat a curl használatával. A fogadott cookie-k fájlba mentéséhez használja a -c kapcsolót:

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

Ezután visszaküldheti a curl cookie-t:

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

Fejléc átvitel és elemzés

Nem mindig van szükségünk az oldal tartalmára. Néha csak a címek lehetnek érdekesek. Ha csak ezeket szeretné megjeleníteni, a -I kapcsolóval:

curl -I https://site

A -H opció pedig lehetővé teszi több vagy több küldését a szervernek, például átadhatja az If-Modified-Since fejlécet, így az oldal csak akkor kerül vissza, ha módosították:

göndör hitelesítés

Ha a kiszolgáló megköveteli az egyik általános hitelesítési típust, például a HTTP Basic vagy az FTP, akkor a curl nagyon könnyen kezeli ezt a feladatot. A hitelesítési részletek megadásához egyszerűen adja meg őket kettősponttal elválasztva a -u kapcsolóban:

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

A HTTP szervereken a hitelesítés ugyanilyen módon történik.

Proxy használata

Ha proxykiszolgálót kell használnia a fájlok letöltéséhez, akkor az is nagyon egyszerű. Elég megadni a proxy szerver címét az -x opcióban:

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

következtetéseket

Ebben a cikkben megvizsgáltuk, hogyan kell használni a curl-et, miért van szükség erre a segédprogramra és főbb képességeit. Annak ellenére, hogy hasonlóak, nagyon különböznek egymástól. A curl linux parancs inkább a szerveren végzett különféle műveletek elemzésére és szimulálására szolgál, míg a wget inkább fájlok letöltésére és webhelyek feltérképezésére alkalmas.

Ez a cikk egy olyan hatékony eszközről szól, mint a cURL, valamint a PHP könyvtáráról, amely hozzáférést biztosít ehhez az eszközhöz - libcurl. Minek ez az egész? A szerverrel való kommunikációhoz adatátviteli protokollok használatával, például http vagy ftp. A többi protokoll nem különösebben érdekes számunkra, ha valaki mélyebben szeretne elmélyülni ebben a témában, akkor angol nyelvű forrásokat kell előásnia, ebben a cikkben az alapokat és a felhasználási példákat tartalmazza.

Mi is pontosan a cURL és a libcurl? Általános szempontok

Tehát a libcurl könyvtár lehetőséget biztosít számunkra, hogy adatokat továbbítsunk a szervernek, és válaszokat kapjunk onnan. Mit ad ez nekünk? A felhasználói viselkedés emulálásának képessége vagy ! Megkaphatja az oldalak tartalmát utólagos elemzésre, szolgáltatásválasz fejléceket kaphat, és programozottan bejelentkezhet az oldalakra, szkripteket hozhat létre ü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!

A cURL telepítése Denweren (Denver). Hogyan kezdjük el a libcurl használatát?

Az első dolog, amit tennünk kell, a könyvtár telepítése. A helyi számítógépemen a Denwer buildet használom, mint a kezdő webmesterek túlnyomó többsége, akiknek a cikk készült. A tapasztalt felhasználók, akik önállóan telepítik a php+apache+mysql kombinációt, képesek lesznek a cURL telepítésére, nem az én dolgom, hogy elmagyarázzam 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 a következőképpen:

• Töltse le a „PHP5: kiegészítő modulok” kész bővítménycsomagot.
• Ennek megfelelően telepítjük. Semmi bonyolult, egyetértek :)
• Nyissa meg a fájlt a Jegyzettömbben (mindig a Notepad++-t ajánlom): X:/webservers/usr/local/php5/php.ini //ahol X a meghajtó, amelyre a webszerver telepítve van

  és távolítsa el a pontosvesszőt a kifejezések elejéről:

  ;extension=php_curl.dll

• Újraindítjuk a denveri szervert.

Kész. A könyvtár működőképességé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.

A cURL leírása és az első lépések

Az eszközzel való munka megkezdéséhez inicializálni 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 telepítési 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 az erőforrás ch-t már elkészítettük közvetlenül fent, de rengeteg opció és érték paraméter van. Szerintem ne másold be az összeset ide, hanem adj egy linket a funkció részletes leírásához, remélem senki nem sértődik meg: curl_setopt.

Példát adok a beállítási lehetőségekre, példaként egy URL-t használva:

$url = "https://site"; curl_setopt($ch, CURLOPT_URL,$url);

Még néhány példa a beállítási lehetőségekre: vegyük le a szerver válaszfejlécét anélkül, hogy magát az oldalt kapnánk meg:

Curl_setopt($ch, CURLOPT_HEADER, 1); // a fejléc beolvasá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); // a fejléc beolvasá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 néztünk meg :) 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 böngésző és a 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. Mennyire hasznos ez számunkra? Mert most nagyjából el tudja képzelni a műveletek sorrendjét, amikor a cURL-lel dolgozik:

• Munkamenet inicializálása (curl_init)
• Állítsa be a szükséges beállításokat (curl_setopt)
• A kapott kérés végrehajtása (curl_exec)
• Munkamenet befejezése (curl_close)

HTTP kérés fejléc szerkezete

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 a / címen található oldalt, vagyis a mappa gyökerében található főoldalt. 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ő.
Gazda: ya.ru — A kért erőforrás tartományneve.
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 – Kérjük, ne szakítsa meg a kapcsolatot, és maradjon kapcsolatban.
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— Tartalomtípus és kódolás.
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— Gyorsítótárazás kezelése. Ebben az esetben le van tiltva.
Lejárat: vasárnap, 2013. március 10. 14:10:50 GMT— Az ülés 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.
Tartalomkódolás: gzip – Az információ kódolásának módja.
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 hozzávetőleges 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.

Példa a könyvtárral való munkára

Úgy gondolom, hogy miután néhány általános pont már világos, és úgy tűnik, minden világos, akkor ideje továbblépni a gyakorláshoz, és példával csiszolni 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 alapján kapjuk meg. Ebben az esetben a kimenet egy tömb lesz a címmel, az oldal tartalmával, és még hibakódokkal is, ha valami baj van.

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, ""); // folyamatok minden kódolás 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); //CURLOPT_TIMEOUT, 120); //CURLOPT_TIMEOUT, 120; //CURLOPT_TIMEOUT, curl_MAX_MAX , 10); // 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; vissza $fejléc; )

Bemeneti paraméterek:
url – oldal vagy webhely címe.
Kimeneti paraméterértékek (három elemű tömb):
header['errno'] - ha valami elromlott, itt hibakód jelenik meg.
header[’errmsg’] – itt jelenik meg a hibaüzenet.
fejléc['tartalom'] – a tényleges oldal\fájl\kép stb.

A függvényt például így használjuk:

$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 kapja meg az oldal kódját. Ha megpróbáljuk megszerezni a nem létező yaaaaaaaaaaaa.ru oldalt, akkor a következő hibát kapjuk:

Nem sikerült feloldani a gazdagépet: yaaaaaaaaaaaa.ru; A gazdagép nem található

Minden korrekten és szépen feldolgozva :)
Ezután bármit megtehet az oldal kódjával, például elemzi azt reguláris kifejezésekkel. De ennyi a következő leckékben, de most álljunk meg ennél.

A JavaScript le van tiltva a böngészőjében. Kérjük, engedélyezze a JavaScriptet az oldal működéséhez!

Becsavar

A PHP támogatja a libcurl-t, a Daniel Stenberg által létrehozott könyvtárat, amely lehetővé teszi a különböző típusú szerverekhez való csatlakozást és különböző protokollok használatát.
A libcurl jelenleg támogatja a http, https, ftp, gopher, telnet, dict, fájl és ldap protokollokat.
A libcurl támogatja a HTTPS-tanúsítványokat, a HTTP POST-ot, a HTTP PUT-t, az FTP-feltöltést (ez az ftp PHP kiterjesztéssel is megtehető), a HTTP űrlap alapú feltöltést, a proxykat, a cookie-kat és a felhasználó+jelszó hitelesítést.

Ezeket a funkciókat a PHP 4.0.2-ben vezették be.

curl_init

curl_init – inicializálja a CURL munkamenetet.

Leírás

forrás curl_init()

Funkció curl_init() inicializál egy új munkamenetet, és visszaad egy CURL-leírót a , and függvényekben való használatra. Ha az opcionális paraméter url megadva, akkor a CURLOPT_URL opció megkapja ennek a paraméternek az értékét. Manuálisan telepítheti a .

curl_setopt

curl_setopt - beállítja a CURL átviteli/átviteli beállításokat.

Leírás

bool curl_setopt(erőforrás ch, karakterlánc opció, vegyes érték)

Funkció curl_setopt() beállítja a paraméter által azonosított CURL-munkamenet beállításait ch. Paraméter választási lehetőség a beállítani kívánt opció, és érték ez az opció értéke választási lehetőség .

Paraméter érték hosszúnak kell lennie a következő opciókhoz (paraméter határozza meg). választási lehetőség):

• CURLOPT_INFILESIZE: Ha egy fájlt egy távoli webhelyre tölt fel, ezt az opciót kell használni, hogy megmondja a PHP számára, hogy mekkora lesz a várt fájlméret.
• CURLOPT_VERBOSE: Állítsa ezt a beállítást nullától eltérő értékre, ha azt szeretné, hogy a CURL minden műveletet jelentsen.
• CURLOPT_HEADER: Állítsa ezt az opciót nullától eltérő értékre, ha azt szeretné, hogy a fejléc szerepeljen a kimenetben.
• CURLOPT_NOPROGRESS: Állítsa ezt az opciót nullától eltérő értékre, ha nem szeretné, hogy a PHP CURL átviteli folyamatjelzőt jelenítsen meg. (A PHP automatikusan nullától eltérő értékre állítja be ezt az opciót; csak hibakereséskor kell módosítania.)
• CURLOPT_NOBODY: Állítsa ezt a lehetőséget nullától eltérő értékre, ha nem szeretné, hogy a törzs szerepeljen a kimenetben.
• CURLOPT_FAILONERROR: Állítsa ezt a beállítást nullától eltérő értékre, ha azt szeretné, hogy a PHP csendben kilépjen, ha a visszaadott HTTP-kód nagyobb, mint 300. Alapértelmezés szerint az oldal normál módon, a kód figyelmen kívül hagyásával tér vissza.
• CURLOPT_UPLOAD: Állítsa ezt a beállítást nullától eltérő értékre, ha azt szeretné, hogy a PHP előkészítse a fájlt a feltöltésre.
• CURLOPT_POST: Állítsa ezt a beállítást nullától eltérő értékre, ha azt szeretné, hogy a PHP rendszeres HTTP POST-ot hajtson végre. Ez a POST normál formátumú application/x-www-form-urlencoded, amelyet leggyakrabban a HTML-űrlapok használnak.
• CURLOPT_FTPLISTONLY: Állítsa ezt az opciót nullától eltérő értékre, és a PHP listázza az FTP-könyvtárneveket.
• CURLOPT_FTPAPPEND: Állítsa ezt a beállítást nullától eltérő értékre, és a PHP felülírása helyett hozzáfűzi a távoli fájlhoz.
• CURLOPT_NETRC: Állítsa ezt a beállítást nullától eltérő értékre, és a PHP átvizsgálja a ~./netrc fájlt, hogy megtalálja a felhasználónevét és jelszavát a távoli webhelyhez, amelyhez csatlakozik.
• CURLOPT_FOLLOWLOCATION: Állítsa ezt a beállítást nullától eltérő értékre, hogy kövesse a szerver által egy HTTP-fejléc részeként elküldött "Location:" fejlécet (vegye figyelembe, hogy ez rekurzió, a PHP követni fogja az összes elküldött "Location: " -fejlécet). )
• CURLOPT_PUT: Állítsa be ezt a beállítást nullától eltérő értékre a HTTP TELEPÍTÉSÉHEZ a fájlt. A PUT fájlt a CURLOPT_INFILE és CURLOPT_INFILESIZE paraméterekkel kell beállítani.
• CURLOPT_MUTE: Állítsa ezt az opciót nullától eltérő értékre, és a PHP rejtetten fog működni a CURL függvények tekintetében.
• CURLOPT_TIMEOUT: Olyan paraméterként adjon meg egy hosszút, amely a CURL függvények futásának maximális időtartamát tartalmazza másodpercben.
• CURLOPT_CONNECTTIMEOUT: Olyan paraméterként adjon meg egy hosszút, amely tartalmazza a maximális várakozási időt (másodpercben) a csatlakozási kísérlet során. Használja a 0-t az örökkévaló várakozáshoz.
• CURLOPT_LOW_SPEED_LIMIT: Adjon meg egy hosszú paramétert, amely tartalmazza az átviteli sebességet, bájt/másodpercben, amely alatt az átvitelnek futnia kell a végrehajtás során CURLOPT_LOW_SPEED_TIME, másodpercben, hogy a PHP túl lassúnak tekintse és megszakítsa.
• CURLOPT_LOW_SPEED_TIME: Adjon meg egy hosszút olyan paraméterként, amely tartalmazza azt az időt másodpercben, amely alatt az átvitelnek futnia kell a CURLOPT_LOW_SPEED_LIMIT futtatása közben, hogy a PHP túl lassúnak tekintse és megszakítsa.
• CURLOPT_RESUME_FROM: Pass long, mint egy paraméter, amely tartalmazza azt a bájteltolást, amelynél az átvitelnek el kell indulnia.
• CURLOPT_SSLVERSION: Adjon meg egy hosszút olyan paraméterként, amely tartalmazza a használni kívánt SSL-verziót (2 vagy 3). Alapértelmezés szerint a PHP ezt maga próbálja meghatározni, bár bizonyos esetekben ezt manuálisan kell beállítani.
• CURLOPT_SSL_VERIFYHOST: Ha a CURL-nek ellenőriznie kell a peer-tanúsítvány közönséges nevét egy SSL-kézfogás során. Az 1-es érték azt jelzi, hogy ellenőriznünk kell a közönséges /közönséges név meglétét, a 2-es érték azt jelzi, hogy meg kell győződnünk arról, hogy az megegyezik a megadott gazdagépnévvel.
• CURLOPT_TIMECONDITION: Adjon meg egy hosszút olyan paraméterként, amely meghatározza a CURLOPT_TIMEVALUE kezelését. Ezt a paramétert TIMECOND_IFMODSINCE vagy TIMECOND_ISUNMODSINCE értékre állíthatja. Ez csak HTTP esetén működik.
• CURLOPT_TIMEVALUE: Adjon meg egy hosszút paraméterként, ami az 1970. január 1-je óta eltelt idő másodpercben. Ezt az időt a CURLOPT_TIMEVALUE beállításnak megfelelően használja, vagy az alapértelmezett TIMECOND_IFMODSINCE.
• CURLOPT_RETURNTRANSFER: Adjon meg egy nullától eltérő értéket, ha azt szeretné, hogy a CURL közvetlenül adja vissza a kapott információt ahelyett, hogy közvetlenül nyomtatná ki azokat.

Paraméter érték karakterláncnak kell lennie a következő paraméterértékekhez választási lehetőség :

A következő opciók egy fájlleírót várnak el, amelyet a függvény segítségével kapunk meg fopen() :

• CURLOPT_FILE: A fájl, ahová az átvitel kimenetét el kell helyezni, alapértelmezés szerint STDOUT.
• CURLOPT_INFILE: A fájl, amelyből az átviteli bemenet származik.
• CURLOPT_WRITEHEADER: Fájl a kimenet fejléc részének rögzítéséhez.
• CURLOPT_STDERR: A hibák rögzítésére szolgáló fájl stderr helyett.

Paraméter érték long write_callback (erőforrás ch, karakterlánc adatok)( ... return strlen($data);) választási lehetőség :

• CURLOPT_WRITEFUNCTION: .
• CURLOPT_HEADERFUNCTION: .

Paraméter érték a következő alak függvényének kell lennie string read_callback (erőforrás ch, erőforrás fd, hosszú hossz)() a következő paraméterértékekhez választási lehetőség :

• CURLOPT_READFUNCTION: .

curl_exec

curl_exec – CURL munkamenetet hajt végre.

Leírás

bool curl_exec(forrás ch)

Ezt a függvényt azután kell meghívni, hogy inicializált egy CURL-munkamenetet, és a munkamenethez tartozó összes beállítás már be van állítva. Célja egyszerűen egy előre meghatározott CURL munkamenet végrehajtása (a paraméterben megadva ch).

curl_close

curl_close – bezárja a CURL munkamenetet.

Leírás

üres curl_close(forrás ch)

Ez a függvény bezárja a CURL munkamenetet, és felszabadítja az összes erőforrást. CURL fogantyú ch is törölve van.

curl_errno

curl_errno – az utolsó hibaszámot tartalmazó egész számot ad vissza.

Leírás

1. példa: Új CURL-munkamenet inicializálása és egy weboldal lekérése.

2. példa: A PHP CURL moduljának használata az example.com letöltéséhez

3. példa: URL elérhetőségének ellenőrzése a PHP CURL használatával

4. példa: A fejléc elválasztása a PHP CURL használatával kapott törzstől

5. példa: Hivatkozási URL meghatározása PHP CURL használatával

a probléma: curl_setopt($ch,FOLLOW_LOCATION,1); a hiba: az open_basedir és a safe_mode probléma a megoldás: valaki által már kifejlesztett függvény a megoldás n 2: ugyanaz a függvény, módosítva, nekem remekül működik.= $curl_max_loops) ( $curl_loops = 0; return FALSE; ) curl_setopt($ch, CURLOPT_HEADER, true); curl_setopt($ch, CURLOPT_RETURNTRANSFER, igaz); $adat = curl_exec($ch); lista($fejléc, $adat) = explode("\n\n", $adat, 2); $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE); if ($http_code == 301 || $http_code == 302) ( $matches = ; preg_match("/Location:(.*?)\n/", $fejléc, $egyezik); $url = @parse_url(trim (array_pop($matches))); if (!$url) ( //nem tudta feldolgozni az URL-t a $curl_loops = 0 címre való átirányításhoz; $data visszaküldése; ) $last_url = parse_url(curl_getinfo($ch, CURLINFO_EFFECTIVE_URL)) if (!$url["séma"]) $url["séma"] = $utolsó_url["séma"]; if (!$url["gazda"]) $url["gazda"] = $utolsó_url[ "host"]; if (!$url["elérési út"]) $url["útvonal"] = $utolsó_url["útvonal"]; $új_url = $url["séma"] . "://" . $ url["host"] . $url["elérési út"] . ($url["lekérdezés"]?"?".$url["lekérdezés"]:""); curl_setopt($ch, CURLOPT_URL, $új_url) ; debug("Átirányítás ide", $új_url); return curl_redir_exec($ch); ) else ( $curl_loops=0; return $data; ) ) ?>
csak használja ezt a funkciót a FOLLOW_LOCATION nélkül, és működnie kell. a probléma az volt, hogy amikor eljut arra a sorra, ahol visszaadja az adatokat, ha a http_code különbözik a 301-től vagy a 302-től, akkor a $data elavult információval rendelkezik, vagy nincs. így $debbbb elvégzi a munkát.

6. példa: Cookie elemzése a fejlécből a CURL PHP segítségével

Néha nem használhatja a CURLOPT_COOKIEJAR és a CURLOPT_COOKIEFILE függvényeket a szerver php-beállításai miatt (Azt mondják, hogy ezekkel a beállításokkal bármilyen fájlt lefoglalhat a szerverről). Íme a megoldás 1) Ne használja a CURLOPT_FOLLOWLOCATION 2) Használja a curl_setopt($ch, CURLOPT_HEADER, 1) 3) Fogja meg a fejléc-cookie-kat a következőképpen: preg_match_all("|Set-Cookie: (.*);|U", $tartalom, $eredmények); $sütik = implode(";", $eredmények); 4) Állítsa be őket a curl_setopt($ch, CURLOPT_COOKIE, $cookies) segítségével;

7. példa: Cookie elemzése a fejlécből a CURL PHP segítségével

Ahogy Yevgen korábban említette, néha nem tudjuk használni a CURLOPT_COOKIEJAR és a CURLOPT_COOKIEFILE függvényeket. Az alábbiakban látható egy fejléc-visszahívási funkció, amelyet még januárban írtam, és amely lehetővé teszi a cookie-k karbantartását a cURL kérések között. A cookie-k hozzáadódnak a $ch-hez minden kérés során, még az átirányítás során is, így használja együtt a CURLOPT_FOLLOWLOCATION funkcióval. Íme a kód: függvény read_header($ch, $string) ( global $location; #helykövetés/átirányítások globális $cookiearr; #cookie-k tárolása itt global $ch; # ^felülbírálja a függvényparamétert $ch # ez rendben van, mert # frissítenünk kell a globális $ch-t # új cookie-val $length = strlen($string); if(!strncmp($string, "Hely:", 9)) ( #követni utolsó átirányítás $location = trim(substr($string, 9, -1)); ) if(!strncmp($string, "Set-Cookie:", 11)) ( #süti lekérése $cookiestr = trim(substr( $string, 11, -1)); $cookie = explode(";", $cookiestr); $cookie = explode("=", $cookie); $cookiename = trim(array_shift($cookie)); $cookiearr [$cookiename] = trim(implode("=", $cookie)); ) $süti = ""; if(trim($string) == "") ( #végrehajtás csak a fejléc végén foreach ($cookiearr mint $key=>$value) ($cookie .= "$key=$value; "; ) curl_setopt ($ ch, CURLOPT_COOKIE, $cookie); ) return $length; ) curl_setopt($ch, CURLOPT_HEADERFUNCTION, "fejléc olvasása"); Ez a kód feltételezi, hogy a $ch-t újra fogja használni anélkül, hogy minden alkalommal inicializálná (a curl_init-et csak egyszer hívja meg, az elején). Ha a kód bármely pontján újra inicializálnia kell a $ch-t, elérheti a jelenleg tárolt cookie-kat a $cookiearr-ben, és belefoglalhatja őket az új $ch-ba. Ezt a függvényt azelőtt írtam, hogy elég tapasztalatom lett volna a reguláris kifejezésekkel, így itt nem fogsz találni preg_match hívást. Elég régóta használom ezt a kódot, és minden gond nélkül elértem a gmailt, yahoot, hotmailt, aol-t stb., ahol kellett menjen át a bejelentkezésen és néhány oldalon, mielőtt eljut arra, amit kerestem.

8. példa: Fejlécbetöltés-kezelő beállítása CURL PHP használatával

A cURL használatával meg kellett hívnom egy harmadik féltől származó szkriptet, amely mellékletként bináris adatokat adott vissza, hogy a letöltött adatokat ismét mellékletként továbbítsam. A probléma az volt, hogy a harmadik féltől származó szkript időnként HTTP-hibákat adott vissza, és ilyen esetekben el akartam kerülni a nulla hosszúságú mellékletek átadását. A CURLOPT_FAILONERROR és a CURLOPT_HEADERFUNCTION visszahívás kombinációja segített a harmadik féltől származó szkript HTTP-hibáinak pontos feldolgozásában: function curlHeaderCallback($resURL, $strHeader) ( if (preg_match("/^HTTP/i", $strHeader)) ( fejléc($strHea) ); header("Content-Disposition: attachment; filename="file-name.zip""); ) return strlen($strHeader); ) $resURL = curl_init("http://site/"); curl_setopt($resURL, CURLOPT_BINARYTRANSFER, 1); curl_setopt($resURL, CURLOPT_HEADERFUNCTION, "curlHeaderCallback"); curl_setopt($resURL, CURLOPT_FAILONERROR, 1); curl_exec($resURL); $intReturnCode = curl_getinfo($resURL, CURLINFO_HTTP_CODE); curl_close($resURL); if ($intReturnCode != 200) ( "Hiba a kóddal: " nyomtatása . $intReturnCode; )

9. példa: Oldal mentése fájlba és az átviteli sebesség kiszámítása a CURL PHP segítségével

WritePageToFile("http://es.php.net", "es.php.net.txt"); function WritePageToFile($sHTMLpage, $sTxtfile) ( $sh = curl_init($sHTMLpage); $hFile = FOpen($sTxtfile, "w"); curl_setopt($sh, CURLOPT_FILE, $hFile); curl_setopt($sh, CURLOPT_HEADER 0); curl_exec ($sh); $sAverageSpeedDownload = curl_getInfo($sh, CURLINFO_SPEED_DOWNLOAD); $sAverageSpeedUpload = curl_getInfo($sh, CURLINFO_SPEED_UPLOAD); echo "

"; echo "Átlagos letöltési sebesség == " . $sAverageSpeedDownload . " 
"; echo "Átlagos feltöltési sebesség == " . $sAverageSpeedUpload ." 
"; visszhang" 
"; $aCURLinfo = curl_getInfo($sh); print_r($aCURLinfo); echo "

"; curl_close($sh); FClose ($hFile); echo "( Tekintse meg a "".$sTxtfile."" fájlt a tárhely ugyanazon az útvonalán." " ahova ez a PHP szkript).
"; }

9. példa: Oldal fogadása SSL-kapcsolaton keresztül (https)

$ch=curl_init("https://site"); curl_setopt($ch, CURLOPT_HEADER, 0); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // Az "SSL-tanúsítvány probléma, ellenőrizze, hogy a CA-tanúsítvány rendben van-e" hiba kikapcsolása curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0); // Tiltsa le az "SSL: tanúsítvány tárgya neve "hostname.ru" nem egyezik a "123.123" célállomásnévvel" curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0); $out=curl_exec($ch); //$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE); //echo "http_code=".$http_code,", err=".curl_error($ch); curl_close($ch);

10. példa: Munkamenetek és cookie-k használata curlben

$cookie_filename=sys_get_temp_dir()+"/cookie.tmp"; $curl=curl_init("http://site"); curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1); curl_setopt($curl, CURLOPT_COOKIEJAR, $cookie_filename);//fogadott COOKIE-k mentése fájlba curl_setopt($curl, CURLOPT_COOKIEFILE, $cookie_filename); //elküldi a szervernek a tőle az engedélyezés során kapott COOKIE-kat $out=curl_exec($curl);

11. példa: Fájlfeltöltés és többdimenziós tömb a Curlben. CURLOPT_POSTFIELDS + CurlFile

Ha többdimenziós tömböt és fájlt kell küldenie POST kérésben, megoldhatatlan problémába ütközik. Ha többdimenziós tömböt ad át a CURLOPT_POSTFIELDS-nek, a második szint a „Tömb” karakterláncként kerül átadásra. Ha a http_build_query használatával konvertál, akkor nem tudja átvinni a fájlt.

Az alábbiakban egy kétdimenziós tömb kódolására szolgál a Curl fájlbetöltésével, amely a PHP 5.3, PHP 5.4 és PHP 5.6 régebbi verzióiban is működik.

/** a többdimenziós tömböt egydimenziós tömbbé alakítja összetett indexek használatával, és az előtag @ jelét CurlFile-ra cseréli a Curlben való használathoz * @param $inputArray * @param string $inputKey * @return tömb $requestVars = array ("id" => array( 1, 2,"id"=>1234), "name" => "log", "logfile" => "@/tmp/test.log"); ezt kapjuk: ["id"]=> int(1) ["id"]=> int(2) ["id"]=> int(1234) ["név"]=> string(3) "napló" [ "logfile"]=> string(13) "/tmp/test.log" ) */ függvény convertToStringArray($inputArray, $inputKey="") ( $resultArray=; foreach ($inputArray mint $kulcs => $érték ) ( $tmpKey = (bool)$inputKey ? $inputKey."[$key]" : $kulcs; if (is_array($value)) ( $resultArray+=convertToStringArray($value, $tmpKey); ) elseif ($érték = = "@")( $resultArray[$tmpKey] = (class_exists(" CURLFile ", false)) ? new CurlFile(ltrim($value, "@")) : $value; ) else ( $resultArray[$tmpKey ] = $érték; ) ) return $resultArray; ) // ellenőrzés $requestVars = array("id" => array(1, 2,"id"=>1234), "name" => "napló", "naplófájl " => "@/tmp/test.log"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, "webhely"); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, convertToStringArray($requestVars)); $res = curl_exec($ch); curl_close($ch); Alkalmazási példák a Curl használatára