PHP CURL - ფუნქციები და გამოყენების მაგალითები. cURL-ის გაფართოებული გამოყენება PHP Curl ბრძანების სტრიქონში

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

curl_setopt - ადგენს პარამეტრს CURL სესიისთვის

პარამეტრების სია

cURL სახელური მიღებული curl_init ().

დასაყენებელი პარამეტრი CURLOPT_XXX.

ოფციონის პარამეტრის მნიშვნელობა.

ბული:

Პარამეტრი შენიშვნები
CURLOPT_AUTOREFERER მართალიველის ავტომატური დაყენებისთვის რეფერენტი:სათაურით გადამისამართებულ მოთხოვნებში მდებარეობა:.
CURLOPT_BINARYTRANSFER მართალიმუდმივის გამოყენებისას დაუმუშავებელი პასუხის დასაბრუნებლად CURLOPT_RETURNTRANSFER. PHP 5.1.3-დან ეს პარამეტრი აღარ არის საჭირო: უმი გამომავალი ყოველთვის ბრუნდება ოფციის გამოყენებისას CURLOPT_RETURNTRANSFER.
CURLOPT_COOKIESESSION მართალიდაავალოს მიმდინარე სესიას ქუქიების ახალი „სესიის“ დაწყება. ეს გამოიწვევს libcurl-ის იგნორირებას ნებისმიერი "სესიის" ქუქი-ფაილების, რომელიც უნდა ჩაიტვირთა წინა სესიიდან. ნაგულისხმევად, libcurl ყოველთვის ინახავს და ატვირთავს ყველა ქუქი-ფაილს, მიუხედავად იმისა, არის თუ არა ისინი "სესიაზე". "სესიის" ქუქი-ფაილები არის ქუქი-ფაილები, რომლებსაც ვადა არ გაუვა და უნდა არსებობდეს მხოლოდ მიმდინარე "სესიისთვის".
CURLOPT_CERTINFO მართალი SSL სერთიფიკატის ინფორმაციის გასატანად ნაკადისთვის STDERRუსაფრთხო კავშირებით. დამატებულია cURL 7.19.1-ში. ხელმისაწვდომია PHP 5.3.2-დან დაწყებული. საჭიროებს ამ პარამეტრის ჩართვას სწორი მუშაობისთვის CURLOPT_VERBOSE.
CURLOPT_CONNECT_ONLY მართალიეუბნება ბიბლიოთეკას, შეასრულოს პროქსის აუთენტიფიკაცია და კავშირის დაყენება, მაგრამ არ გადასცემს მონაცემებს. ეს პარამეტრი დანერგილია HTTP, SMTP და POP3-სთვის. დამატებულია 7.15.2-ში. ხელმისაწვდომია PHP 5.5.0-დან.
CURLOPT_CRLF მართალი Unix ხაზების დაბოლოებების CRLF-ად გადაქცევა.
CURLOPT_DNS_USE_GLOBAL_CACHE მართალიგლობალური DNS ქეშის გამოსაყენებლად. ეს პარამეტრი არ არის უსაფრთხო თემაში და ჩართულია ნაგულისხმევად.
CURLOPT_FAILONERROR მართალიწარუმატებლობის დეტალური ანგარიშისთვის, თუ მიღებული HTTP კოდი 400-ზე მეტია ან ტოლია. ნაგულისხმევი ქცევა აბრუნებს გვერდს ჩვეულებრივად, კოდის იგნორირებაში.
CURLOPT_FILETIME მართალიდისტანციური დოკუმენტის შეცვლის თარიღის მოპოვების მცდელობა. ამ მნიშვნელობის მიღება შესაძლებელია ფუნქციიდან CURLINFO_FILETIME პარამეტრის გამოყენებით curl_getinfo().
CURLOPT_FOLLOWLOCATION მართალიდაიცვას ნებისმიერი სათაური "ადგილმდებარეობა:"სერვერის მიერ გაგზავნილი პასუხში (გაითვალისწინეთ, რომ ეს ხდება რეკურსიულად, PHP მიჰყვება გაგზავნილ ნებისმიერ სათაურს "ადგილმდებარეობა:", გარდა იმ შემთხვევისა, როდესაც დაყენებულია მუდმივი CURLOPT_MAXREDIRS).
CURLOPT_FORBID_REUSE მართალიაიძულოს კავშირი დახუროს მისი დამუშავების დასრულების შემდეგ, რათა არ მოხდეს მისი ხელახლა გამოყენება.
CURLOPT_FRESH_CONNECT მართალიიძულებით გამოიყენოს ახალი კავშირი ქეშის ნაცვლად.
CURLOPT_FTP_USE_EPRT მართალიგამოიყენოს EPRT (და LPRT) აქტიური FTP ატვირთვისთვის. გამოყენება ცრუიმისათვის, რომ გამორთოთ EPRT და LPRT და გამოიყენოთ მხოლოდ PORT.
CURLOPT_FTP_USE_EPSV მართალი EPSV ბრძანების საწყისი ტესტირებისთვის FTP გადაცემის დროს. თუ ბრძანება ვერ მოხერხდა, ის დაბრუნდება PASV-ზე. დააინსტალირეთ ცრუ EPSV-ის გამორთვა.
CURLOPT_FTP_CREATE_MISSING_DIRS მართალიშექმნათ დაკარგული დირექტორიები, თუ FTP ოპერაცია შეხვდება არარსებულ გზას.
CURLOPT_FTPAPPEND მართალიდისტანციური ფაილის ბოლომდე ჩაწერა, არსებული ფაილზე გადაწერის ნაცვლად.
CURLOPT_TCP_NODELAY სამუდამოდ განსაზღვრავს თუ არა TCP_NODELAY ოფცია დაყენებული ან გასუფთავებული (1 = დაყენება, 0 = გასუფთავებული). ნაგულისხმევად, ვარიანტი გასუფთავებულია. ხელმისაწვდომია PHP 5.2.1-დან libcurl 7.11.2 ან უფრო ახალი ვერსიით აშენებული ვერსიებისთვის.
CURLOPT_FTPASCII მეტსახელი CURLOPT_TRANSFERTEXT. ამის ნაცვლად გამოიყენეთ ეს.
CURLOPT_FTPLISTONLY მართალიდააბრუნოს მხოლოდ სახელების სია FTP დირექტორიადან.
CURLOPT_HEADER მართალიგამომავალში სათაურების ჩართვა.
CURLINFO_HEADER_OUT მართალისახელურის შეკითხვის სტრიქონის თვალყურის დევნება. ხელმისაწვდომია PHP 5.1.3-დან დაწყებული. პრეფიქსი CURLINFO_გამოიყენება კონკრეტულად.
CURLOPT_HTTPGET მართალი HTTP მოთხოვნის მეთოდის GET მეთოდზე გადატვირთვისთვის. ვინაიდან GET არის ნაგულისხმევი, ეს პარამეტრი საჭიროა მხოლოდ იმ შემთხვევაში, თუ მოთხოვნის მეთოდი ადრე შეიცვალა.
CURLOPT_HTTPPROXYTUNNEL მართალიგვირაბი მითითებულ HTTP პროქსის მეშვეობით.
CURLOPT_MUTE მართალი cURL ფუნქციის შეტყობინებების სრულად გამორთვა. ამოღებულია cURL 7.15.5-ში (შესაძლებელია CURLOPT_RETURNTRANSFER ვარიანტის გამოყენება)
CURLOPT_NETRC მართალიწაიკითხეთ ~/.netrc ფაილი შესვლისა და პაროლისთვის დისტანციური საიტისთვის, რომელთანაც კავშირი დამყარებულია.
CURLOPT_NOBODY მართალისაპასუხო ორგანოს გამორიცხვა გამოსავალიდან. მოთხოვნის მეთოდი დაყენებულია HEAD. ამ პარამეტრის შეცვლა ცრუარ ცვლის მას GET-ზე.
CURLOPT_NOPROGRESS

მართალი cURL გადარიცხვებზე პროგრესის ინდიკატორის გამორთვა.

კომენტარი:

PHP ავტომატურად აყენებს ამ პარამეტრს მართალი, შეცვალეთ იგი მხოლოდ გამართვის მიზნით.
CURLOPT_NOSIGNAL მართალინებისმიერი cURL ფუნქციის იგნორირება, რომელიც აგზავნის სიგნალებს PHP პროცესზე. ეს ოფცია ნაგულისხმევად ჩართულია მრავალნაკადიან SAPI-ებში, რათა დროის ამოწურვის პარამეტრებმა სწორად იმუშაოს.
CURLOPT_POST მართალიჩვეულებრივი HTTP POST-ის გამოსაყენებლად. ეს POST მეთოდი იყენებს ნორმალურს , ჩვეულებრივ გამოიყენება HTML ფორმებში.
CURLOPT_PUT მართალიფაილის ჩამოტვირთვა HTTP PUT მეთოდის გამოყენებით. გამოყენებული ფაილი უნდა დაყენდეს ოფციების გამოყენებით CURLOPT_INFILEდა CURLOPT_INFILESIZE.
CURLOPT_RETURNTRANSFER მართალისტრიქონის სახით გადატანის შედეგის დასაბრუნებლად curl_exec()ბრაუზერში პირდაპირი გამოყვანის ნაცვლად.
CURLOPT_SAFE_UPLOAD მართალიპრეფიქსის მხარდაჭერის გამორთვა @ გადმოწერილი ფაილებისთვის CURLOPT_POSTFIELDS, რაც ნიშნავს, რომ მნიშვნელობები გავიდა @ შეიძლება უსაფრთხოდ გადაიცეს ველების სახით. პრეფიქსის ნაცვლად, შეგიძლიათ გამოიყენოთ ვარიანტი CURLFileდ. დამატებულია PHP 5.5.0-ში ნაგულისხმევი მნიშვნელობით ცრუ. PHP 5.6.0-ში ის გახდა ნაგულისხმევის ტოლი მართალი.
CURLOPT_SSL_VERIFYPEER ცრურომ შეაჩეროს cURL-ის ჰოსტის სერტიფიკატის შემოწმება. გადამოწმების ალტერნატიული სერთიფიკატები შეიძლება მითითებული იყოს პარამეტრის გამოყენებით CURLOPT_CAINFOან დირექტორია, პარამეტრით მითითებული სერთიფიკატებით CURLOPT_CAPATH. ნაგულისხმევია მართალი cURL 7.10 ვერსიიდან. ნაგულისხმევი დისტრიბუცია დაინსტალირებულია cURL 7.10 ვერსიიდან დაწყებული.
CURLOPT_TRANSFERTEXT მართალი ASCII რეჟიმის გამოყენება FTP გადარიცხვებისთვის. LDAP-ის გამოყენებისას მონაცემები ბრუნდება უბრალო ტექსტში HTML-ის ნაცვლად. Windows სისტემებზე თემა STDOUTარ არის დაყენებული ორობით რეჟიმზე.
CURLOPT_UNRESTRICTED_AUTH მართალირომ გააგრძელოთ შესვლისა და პაროლის გაგზავნა გადამისამართების დროს (გამოყენებისას CURLOPT_FOLLOWLOCATION), თუნდაც ჰოსტის სახელი შეიცვალოს.
CURLOPT_UPLOAD მართალიმომზადდეს ფაილის სერვერზე ატვირთვისთვის.
CURLOPT_VERBOSE მართალიდამატებითი ინფორმაციის ჩვენება. წერს გამოსავალს ნაკადში STDERR, ან პარამეტრით მითითებული ფაილი CURLOPT_STDERR.

შემდეგი ვარიანტის პარამეტრის მნიშვნელობებისთვის, მნიშვნელობის პარამეტრი უნდა იყოს ტიპის მთელი რიცხვი:

Პარამეტრი დააყენეთ მნიშვნელობის მნიშვნელობა შენიშვნები
CURLOPT_BUFFERSIZE თითოეული წაკითხვისთვის გამოყენებული ბუფერის ზომა. თუმცა, არ არსებობს გარანტია, რომ ეს მოთხოვნა შესრულდება. დამატებულია cURL 7.10-ში.
CURLOPT_CLOSEPOLICY ერთ-ერთი მუდმივი CURLCLOSEPOLICY_*.

კომენტარი:

ეს პარამეტრი მოძველებულია, რადგან ის არასოდეს განხორციელებულა cURL-ში და არ მუშაობდა.

 წაშლილია PHP 5.6.0-ში.
CURLOPT_CONNECTTIMEOUT დაკავშირების მცდელობისას ლოდინის წამების რაოდენობა. გამოიყენეთ 0 განუსაზღვრელი ვადით ლოდინისთვის.
CURLOPT_CONNECTTIMEOUT_MS დაკავშირების მცდელობისას ლოდინის მილიწამების რაოდენობა. გამოიყენეთ 0 განუსაზღვრელი ვადით ლოდინისთვის. თუ libcurl შედგენილია სისტემის სტანდარტული სახელების გადამწყვეტის გამოყენებით, მაშინ კავშირი კვლავ გამოიყენებს სრულ წამს ლოდინს, როგორც დროის ამოწურვას, მინიმალური დასაშვები დროით 1 წამით. დამატებულია cURL ვერსიაში 7.16.2. ხელმისაწვდომია PHP 5.2.3-დან დაწყებული.
CURLOPT_DNS_CACHE_TIMEOUT წამების რაოდენობა, რომლითაც DNS ჩანაწერები ინახება მეხსიერებაში. ნაგულისხმევად, ეს პარამეტრი არის 120 (2 წუთი).
CURLOPT_FTPSSLAUTH FTP ავთენტიფიკაციის მეთოდი (აქტიურ რეჟიმში): CURLFTPAUTH_SSL(SSL ჯერ შემოწმდება), CURLFTPAUTH_TLS(TLS ჯერ შემოწმდა) ან CURLFTPAUTH_DEFAULT(cURL თავად წყვეტს). დამატებულია cURL ვერსიაში 7.12.2.
CURLOPT_HTTP_VERSION CURL_HTTP_VERSION_NONE (ნაგულისხმევად, CURL ირჩევს რომელი ვერსია გამოიყენოს), CURL_HTTP_VERSION_1_0 (იძულებით HTTP/1.0) ან CURL_HTTP_VERSION_1_1 (იძულებით HTTP/1.1).
CURLOPT_HTTPAUTH

შეგიძლიათ გამოიყენოთ bitwise ოპერატორი | (ან) რამდენიმე მეთოდის ერთად გაერთიანება. ამ შემთხვევაში, cURL გამოკითხავს სერვერს მხარდაჭერილი ავტორიზაციის მეთოდებზე და შეარჩევს საუკეთესოს.

CURLAUTH_ANY არის მეტსახელი CURLAUTH_BASIC | CURLAUTH_DIGEST | CURLAUTH_GSSNEGOTIATE | CURLAUTH_NTLM.

CURLAUTH_ANYSAFE არის მეტსახელი CURLAUTH_DIGEST | CURLAUTH_GSSNEGOTIATE | CURLAUTH_NTLM.
CURLOPT_INFILESIZE ფაილის მოსალოდნელი ზომა, ბაიტებში, ფაილის დისტანციურ სერვერზე ატვირთვისას. გთხოვთ, გაითვალისწინოთ, რომ ამ პარამეტრის გამოყენება არ შეწყვეტს შემდგომი მონაცემების გაგზავნას ამ მნიშვნელობაზე მეტი, რადგან გაგზავნილი მონაცემები დამოკიდებულია შედეგზე CURLOPT_READFUNCTION.
CURLOPT_LOW_SPEED_LIMIT მონაცემთა გადაცემის სიჩქარის ზედა ზღვარი, ბაიტი წამში. შემოწმება ხდება შიგნით CURLOPT_LOW_SPEED_TIMEწამში, რის შემდეგაც PHP თვლის გადაცემას ძალიან ნელა და აჩერებს მას.
CURLOPT_LOW_SPEED_TIME წამების მაქსიმალური რაოდენობა, რომლის დროსაც გადაცემის სიჩქარე არ უნდა აღემატებოდეს CURLOPT_LOW_SPEED_LIMIT, წინააღმდეგ შემთხვევაში PHP მონიშნავს გადაცემას, როგორც ძალიან ნელი და შეაჩერებს მას.
CURLOPT_MAXCONNECTS მუდმივი კავშირების მაქსიმალური რაოდენობა. როდესაც ლიმიტი მიიღწევა, პარამეტრი გამოიყენება იმის დასადგენად, თუ რომელი კავშირი უნდა დაიხუროს. CURLOPT_CLOSEPOLICY.
CURLOPT_MAXREDIRS მიღებული გადამისამართებების მაქსიმალური რაოდენობა. გამოიყენეთ ეს ვარიანტი პარამეტრთან ერთად CURLOPT_FOLLOWLOCATION.
CURLOPT_PORT ალტერნატიული კავშირის პორტი.
CURLOPT_POSTREDIR ბიტი ნიღაბი, რომელიც შეიცავს 1 (301 გადაადგილებულია მუდმივად), 2 (302 ნაპოვნია) და 4 (303 იხილეთ სხვა), რათა დაზუსტდეს, უნდა დამუშავდეს თუ არა HTTP POST მეთოდი, როდესაც ოფცია ჩართულია. CURLOPT_FOLLOWLOCATIONთუ მოხდა მითითებული ტიპის გადამისამართება. დამატებულია cURL 7.19.1-ში. ხელმისაწვდომია PHP 5.3.2-დან.
CURLOPT_პროტოკოლები

ღირებულებების ცოტა ნიღაბი CURLPROTO_*. ეს ნიღაბი ზღუდავს libcurl-ის მიერ გამოყენებულ პროტოკოლებს. ეს საშუალებას გაძლევთ გქონდეთ libcurl მუშაობა პროტოკოლების დიდი რაოდენობით და შეზღუდოთ გარკვეული გადარიცხვების მოქმედება მხოლოდ მათი ქვეჯგუფით. ნაგულისხმევად, libcurl იყენებს ყველა მხარდაჭერილ პროტოკოლს. ასევე იხილეთ პარამეტრი CURLOPT_REDIR_პროტოკოლები.

პროტოკოლის სწორი მნიშვნელობები: CURLPROTO_HTTP , CURLPROTO_HTTPS , CURLPROTO_FTP , CURLPROTO_FTPS , CURLPROTO_SCP , CURLPROTO_SFTP , CURLPROTO_TELNET , CURLPROTO_TELNET , CURLPROTO_FTP, CURLPROTO_FTPS , CURLPROTO_FILE , CURLP ROTO_TFTP, CURLPROTO_ALL
CURLOPT_PROXYAUTH პროქსი სერვერთან დაკავშირებისას გამოყენებული HTTP ავტორიზაციის მეთოდები. გამოიყენეთ იგივე ბიტის ნიღბები, რომლებიც აღწერილი იყო პარამეტრისთვის CURLOPT_HTTPAUTH. ამჟამად მხოლოდ CURLAUTH_BASIC და CURLAUTH_NTLM არის მხარდაჭერილი პროქსის ავტორიზაციისთვის. დამატებულია cURL ვერსიაში 7.10.7.
CURLOPT_PROXYPORT პროქსი სერვერის პორტის ნომერი, რომელთანაც დაკავშირება ხდება. ამ რიცხვის დაყენება ასევე შესაძლებელია პარამეტრის გამოყენებით CURLOPT_PROXY.
CURLOPT_PROXYTYPE ან CURLPROXY_HTTP (ნაგულისხმევი) ან CURLPROXY_SOCKS5. დამატებულია cURL 7.10-ში.
CURLOPT_REDIR_პროტოკოლები ღირებულებების ცოტა ნიღაბი CURLPROTO_*. ეს ბიტმასკი ზღუდავს libcurl-ის მიერ გადამისამართებისას გამოყენებულ პროტოკოლებს (ჩართული პარამეტრით CURLOPT_FOLLOWLOCATION). ეს საშუალებას გაძლევთ შეზღუდოთ პროტოკოლების ნაკრები, რომლებიც გამოიყენება ზოგიერთი გადაცემისთვის გადამისამართებისას. ნაგულისხმევად, libcurl მხარს უჭერს ყველა პროტოკოლს, გარდა FILE და SCP. 7.19.4-მდე ვერსიებში გადამისამართება გამოიყენებოდა ყველა პროტოკოლისთვის გამონაკლისის გარეშე. აგრეთვე პარამეტრის აღწერა CURLOPT_პროტოკოლებიპროტოკოლის მნიშვნელობებით მუდმივთა სიისთვის. დამატებულია cURL ვერსიაში 7.19.4.
CURLOPT_RESUME_FROM გადაცემის დაწყების ოფსეტი, ბაიტებში.
CURLOPT_SSL_VERIFYHOST გამოიყენეთ 1 SSL სერთიფიკატში საერთო სახელის არსებობის შესამოწმებლად. გამოიყენეთ 2, რათა შეამოწმოთ საერთო სახელის არსებობა და ასევე ემთხვევა მითითებულ ჰოსტს. საბრძოლო გარემოში ამ პარამეტრის მნიშვნელობა უნდა იყოს 2 (ნაგულისხმევად დაყენებული). მნიშვნელობის 1 მხარდაჭერა ამოღებულია cURL 7.28.1-ში
CURLOPT_SSLVERSION ერთ-ერთი მუდმივი 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) ან CURL_SSLVERSION_TLSv1_2 (6).
CURLOPT_TIMECONDITION პარამეტრის ინტერპრეტაციის მეთოდი CURLOPT_TIMEVALUE. გამოიყენეთ CURL_TIMECOND_IFMODSINCE გვერდის დასაბრუნებლად მხოლოდ იმ შემთხვევაში, თუ ის შეიცვალა პარამეტრში მითითებული დროის შემდეგ CURLOPT_TIMEVALUE. თუ გვერდი არ არის შეცვლილი, სათაური დაბრუნდება "304 არ არის შეცვლილი", რაც გულისხმობს, რომ პარამეტრი CURLOPT_HEADERდამონტაჟებულია მართალი. გამოიყენეთ CURL_TIMECOND_IFUNMODSINCE საპირისპირო ეფექტისთვის. ნაგულისხმევი არის CURL_TIMECOND_IFMODSINCE.
CURLOPT_TIMEOUT cURL ფუნქციების შესასრულებლად დაშვებული წამების მაქსიმალური რაოდენობა.
CURLOPT_TIMEOUT_MS cURL ფუნქციების შესასრულებლად დაშვებული მილიწამების მაქსიმალური რაოდენობა. თუ libcurl აგებულია ნორმალური სისტემის სახელების გადამწყვეტის გამოყენებით, მაშინ ამ კავშირის დიაპაზონი კვლავ გამოიყენებს მეორე დამრგვალების ვადებს, მინიმალური დროის ამოწურვით ერთი წამით. დამატებულია cURL ვერსიაში 7.16.2. ხელმისაწვდომია PHP 5.2.3-დან დაწყებული.
CURLOPT_TIMEVALUE წამების რაოდენობა 1970 წლის 1 იანვრიდან. ამ დროს გამოყენებული იქნება პარამეტრი CURLOPT_TIMECONDITION. ნაგულისხმევად გამოიყენება CURL_TIMECOND_IFMODSINCE პარამეტრი.
CURLOPT_MAX_RECV_SPEED_LARGE თუ ჩამოტვირთვის სიჩქარე აღემატება ამ მნიშვნელობას (მითითებულ ბაიტებში წამში) საშუალოდ მთელი გადაცემის განმავლობაში, ჩამოტვირთვა შეჩერდება, რათა შენარჩუნდეს საშუალო სიჩქარე ამ პარამეტრზე ნაკლები ან ტოლი. სტანდარტულად, სიჩქარე შეზღუდული არ არის.
CURLOPT_MAX_SEND_SPEED_LARGE თუ სერვერზე ატვირთვა აღემატება ამ მნიშვნელობას (მითითებულ ბაიტებში წამში) საშუალოდ მთელი გადაცემის განმავლობაში, ატვირთვა შეჩერდება ამ პარამეტრზე ნაკლები ან ტოლი საშუალო სიჩქარის შესანარჩუნებლად. სტანდარტულად, სიჩქარე შეზღუდული არ არის. დამატებულია cURL 7.15.5-ში. ხელმისაწვდომია PHP 5.4.0-დან დაწყებული.
CURLOPT_SSH_AUTH_TYPES ბიტმასკი, რომელიც შედგება ერთი ან მეტი მუდმივისაგან: CURLSSH_AUTH_PUBLICKEY, CURLSSH_AUTH_PASSWORD, CURLSSH_AUTH_HOST, CURLSSH_AUTH_KEYBOARD. Დაინსტალირება CURLSSH_AUTH_ANYრათა libcurl-მა დამოუკიდებლად აირჩიოს ერთ-ერთი მათგანი. დამატებულია cURL 7.16.1-ში.
CURLOPT_IPRESOLVE აპლიკაციას შეეძლება აირჩიოს IP მისამართის ტიპი, რომლითაც განისაზღვრება ჰოსტის სახელი. ეს აუცილებელია, თუ იყენებთ ჰოსტის სახელს, რომელიც მიღებულია IP მისამართის ერთზე მეტი ვერსიიდან. შესაძლო მნიშვნელობები შეიძლება იყოს CURL_IPRESOLVE_WHATEVER, CURL_IPRESOLVE_V4, CURL_IPRESOLVE_V6და ნაგულისხმევად CURL_IPRESOLVE_WHATEVER. დამატებულია cURL 7.10.8-ში.

შემდეგი ვარიანტის პარამეტრის მნიშვნელობებისთვის, მნიშვნელობის პარამეტრი უნდა იყოს ტიპის სიმებიანი:

Პარამეტრი დააყენეთ მნიშვნელობის მნიშვნელობა შენიშვნები
CURLOPT_CAINFO ფაილის სახელი, რომელიც შეიცავს ერთ ან მეტ სერთიფიკატს, რომლის წინააღმდეგაც მოხდება კვანძების შემოწმება. ამ პარამეტრს აქვს აზრი მხოლოდ მაშინ, როდესაც გამოიყენება ერთად CURLOPT_SSL_VERIFYPEER. მოითხოვს აბსოლუტურ გზას.
CURLOPT_CAPATH დირექტორია, რომელიც შეიცავს რამდენიმე CA სერთიფიკატს. გამოიყენეთ ეს ვარიანტი ერთად CURLOPT_SSL_VERIFYPEER.
CURLOPT_COOKIE სათაურის შინაარსი "ქუქი:", გამოიყენება HTTP მოთხოვნაში. გთხოვთ გაითვალისწინოთ, რომ რამდენიმე ქუქი-ფაილი გამოყოფილია მძიმით, რასაც მოჰყვება ინტერვალი (მაგალითად, " ხილი=ვაშლი; ფერი = წითელი")
CURLOPT_COOKIEFILE ქუქიების შემცველი ფაილის სახელი. ეს ფაილი უნდა იყოს Netscape ფორმატში ან უბრალოდ HTTP სათაურებში ჩაწერილი ფაილში. თუ ცარიელი სტრიქონი გადაეცემა ფაილის სახელს, მაშინ ქუქიები არ შეინახება, მაგრამ მათი დამუშავება მაინც ჩართული იქნება.
CURLOPT_COOKIEJAR ფაილის სახელი, რომელშიც შეინახება მიმდინარე გადაცემის ყველა შიდა ქუქი-ფაილი სახელურის დახურვის შემდეგ, მაგალითად curl_close-ის გამოძახების შემდეგ.
CURLOPT_CUSTOMREQUEST

ამის ნაცვლად გამოყენებულია მორგებული მოთხოვნის მეთოდი "მიიღე"ან "თავი" HTTP მოთხოვნის მიღებისას. ეს სასარგებლოა შეკითხვებისთვის "წაშლა"ან სხვა, უფრო იშვიათი HTTP მოთხოვნები. სწორი მნიშვნელობები იქნება სიტყვები, როგორიცაა "მიიღე", "პოსტ", "დაკავშირება"და ასე შემდეგ; იმათ. არ შეიყვანოთ მთელი HTTP მოთხოვნის ხაზი აქ. მაგალითად, მითითება "GET /index.html HTTP/1.0\r\n\r\n"არასწორი იქნება.

კომენტარი:

არ გამოიყენოთ ეს ფუნქცია, სანამ არ დარწმუნდებით, რომ სერვერი მხარს უჭერს ამ ტიპის მოთხოვნას.
CURLOPT_EGDSOCKET მოსწონს CURLOPT_RANDOM_FILE, გარდა იმისა, რომ ფაილის სახელი დაყენებულია Entropy Gathering Daemon სოკეტზე.
CURLOPT_ENCODING სათაურის შინაარსი "Accept-Encoding:". ეს საშუალებას აძლევს მოთხოვნის გაშიფვრას. მხარდაჭერილი კოდირება არის "იდენტობა", "გაფუჭება"და "gzip". თუ ცარიელი სტრიქონი გავიდა, "" , იგზავნება სათაური, რომელიც შეიცავს ყველა მხარდაჭერილ კოდირების ტიპს. დამატებულია cURL 7.10-ში.
CURLOPT_FTPPORT მნიშვნელობა, რომელიც გამოყენებული იქნება IP მისამართის დასადგენად FTP "PORT" ბრძანებისთვის. "PORT" ბრძანება ეუბნება სერვერს, რომელ IP მისამართს უნდა დაუკავშირდეს. ეს შეიძლება იყოს IP მისამართი, ჰოსტის სახელი, ქსელის ინტერფეისის სახელი (Unix-ში) ან უბრალოდ "-" სისტემის ნაგულისხმევი IP მისამართის გამოსაყენებლად.
CURLOPT_INTERFACE გამოსაყენებელი ქსელის ინტერფეისის სახელი. შეიძლება იყოს ინტერფეისის სახელი, IP მისამართი ან ჰოსტის სახელი.
CURLOPT_KEYPASSWD პირადი გასაღების გამოსაყენებლად საჭიროა პაროლი CURLOPT_SSLKEYან CURLOPT_SSH_PRIVATE_KEYFILE. დამატებულია cURL 7.16.1-ში.
CURLOPT_KRB4LEVEL უსაფრთხოების დონე KRB4 (Kerberos 4). ნებისმიერი ქვემოთ ჩამოთვლილი მნიშვნელობა (მიმდევრობით სუსტიდან უძლიერესამდე) სწორია: "ნათელი", "უსაფრთხო", "კონფიდენციალური", "პირადი".. თუ მითითებული სტრიქონი განსხვავდება მოცემული მნიშვნელობებისგან, მნიშვნელობა გამოყენებული იქნება "პირადი". ამ პარამეტრის დაყენება NULLმთლიანად გამორთავს KRB4 უსაფრთხოებას. ამ დროისთვის, KRB4 უსაფრთხოება მუშაობს მხოლოდ FTP ტრანზაქციებზე.
CURLOPT_POSTFIELDS ყველა მონაცემი გადაცემულია HTTP POST მოთხოვნით. ფაილის გადასატანად, მიუთითეთ ფაილის სახელი @ და ასევე გამოიყენეთ ფაილის სრული გზა. ფაილის ტიპი ასევე შეიძლება განისაზღვროს ფორმატის გამოყენებით " ;type=mimettype"ფაილის სახელის შემდეგ. ეს პარამეტრი შეიძლება გადაეცეს როგორც url კოდირებული სტრიქონი, როგორიცაა " para1=val1¶2=val2&...და მასივის სახით, რომლის კლავიშები იქნება ველების სახელები, ხოლო მნიშვნელობები იქნება მათი შინაარსი. თუ მნიშვნელობა არის მასივი, სათაური Შინაარსის ტიპიდაყენებული იქნება მრავალნაწილიანი/ფორმა-მონაცემები. დაწყებული PHP 5.2.0-დან, ფაილების პრეფიქსით გადატანისას @ , მნიშვნელობა უნდა იყოს მასივი. მას შემდეგ, რაც PHP 5.5.0, პრეფიქსი @ მოძველებულია და ფაილების გაგზავნა შესაძლებელია გამოყენებით CURLFile. პრეფიქსი @ შეიძლება გამორთოთ მნიშვნელობების დასაშვებად დაწყებული @ ვარიანტის დაყენებით CURLOPT_SAFE_UPLOADმნიშვნელობით მართალი.
CURLOPT_PROXY HTTP პროქსი, რომლის მეშვეობითაც მოხდება მოთხოვნების მარშრუტირება.
CURLOPT_PROXYUSERPWD ფორმაში ჩაწერილი შესვლა და პაროლი ":" , გამოიყენება პროქსის მეშვეობით დაკავშირებისას.
CURLOPT_RANDOM_FILE ფაილის სახელი, რომელიც გამოიყენება SSL-ისთვის შემთხვევითი რიცხვების გენერატორის ინიციალიზაციისთვის.
CURLOPT_RANGE ჩამოსატვირთი მონაცემების დიაპაზონი ფორმატში "X-Y"და X ან Y შეიძლება გამოტოვოთ. HTTP პროტოკოლი ასევე მხარს უჭერს მძიმით გამოყოფილი მრავალი დიაპაზონის გადაცემას, ისინი მითითებულია ფორმატში "X-Y, N-M".
CURLOPT_REFERER სათაურის შინაარსი "მიმართავი:", რომელიც გამოყენებული იქნება HTTP მოთხოვნაში.
CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 სტრიქონი, რომელიც შეიცავს 32 თექვსმეტობით ციფრს. სტრიქონი უნდა იყოს დისტანციური კომპიუტერის საჯარო გასაღების MD5 საკონტროლო ჯამი და libcurl აღადგენს კავშირს დისტანციურ ჰოსტთან, სანამ საკონტროლო ჯამი არ დაემთხვევა საჯარო გასაღებს. ეს პარამეტრი განკუთვნილია მხოლოდ SCP და SFTP გამოყენებით მონაცემთა გადაცემისთვის. დამატებულია cURL 7.17.1-ში.
CURLOPT_SSH_PUBLIC_KEYFILE ფაილის სახელი თქვენი საჯარო გასაღებისთვის. თუ მითითებული არ არის, libcurl ნაგულისხმევად აყენებს ფაილს $HOME/.ssh/id_dsa.pub, თუ დაყენებულია HOME გარემოს ცვლადი და ფაილი "id_dsa.pub" მიმდინარე დირექტორიაში, თუ HOME გარემოს ცვლადი არ არის დაყენებული. დამატებულია cURL 7.16.1-ში.
CURLOPT_SSH_PRIVATE_KEYFILE ფაილის სახელი თქვენი პირადი გასაღებისთვის. თუ მითითებული არ არის, libcurl ნაგულისხმევად აყენებს $HOME/.ssh/id_dsa ფაილს, თუ დაყენებულია HOME გარემოს ცვლადი და "id_dsa" ფაილი მიმდინარე დირექტორიაში, თუ HOME გარემოს ცვლადი არ არის დაყენებული. თუ ფაილი დაცულია პაროლით, დააყენეთ პაროლი გამოყენებით CURLOPT_KEYPASSWD. დამატებულია cURL 7.16.1-ში.
CURLOPT_SSL_CIPHER_LIST SSL გადარიცხვებში გამოყენებული შიფრების სია. Მაგალითად, RC4-SHAდა TLSv1არის მოქმედი შიფრული სიები.
CURLOPT_SSLCERT ფაილის სახელი სწორად ფორმატირებული PEM სერთიფიკატით.
CURLOPT_SSLCERTPASSWD სერთიფიკატის გამოსაყენებლად საჭიროა პაროლი CURLOPT_SSLCERT.
CURLOPT_SSLCERTTYPE სერთიფიკატის ფორმატი. მხარდაჭერილი ფორმატები "PEM"(ნაგულისხმევი), "DER"და "ENG". დამატებულია cURL ვერსიაში 7.9.3.
CURLOPT_SSLENGINE პარამეტრში მითითებული SSL პირადი გასაღების დაშიფვრის ძრავის ID CURLOPT_SSLKEY.
CURLOPT_SSLENGINE_DEFAULT ასიმეტრიული დაშიფვრის ოპერაციებისთვის გამოყენებული დაშიფვრის მექანიზმის იდენტიფიკატორი.
CURLOPT_SSLKEY SSL პირადი გასაღების ფაილის სახელი.
CURLOPT_SSLKEYPASSWD

პარამეტრით მითითებული SSL პირადი გასაღების გამოსაყენებლად საჭირო საიდუმლო პაროლი CURLOPT_SSLKEY.

კომენტარი:

ვინაიდან ეს პარამეტრი შეიცავს ღირებულ პაროლს, გახსოვდეთ, რომ ეს PHP სკრიპტი უსაფრთხო ადგილას შეინახეთ.
CURLOPT_SSLKEYTYPE პარამეტრში მითითებული SSL პირადი გასაღების ტიპი CURLOPT_SSLKEY. შემდეგი ძირითადი ტიპები მხარდაჭერილია: "PEM"(ნაგულისხმევი), "DER"და "ENG".
CURLOPT_URL ჩამოტვირთვადი URL. ამ პარამეტრის დაყენება ასევე შესაძლებელია სესიის ინიციალიზაციისას გამოყენებით curl_init ().
CURLOPT_USERAGENT სათაურის შინაარსი "მომხმარებლის აგენტი:", გაგზავნილია HTTP მოთხოვნით.
CURLOPT_USERPWD კავშირის დროს გამოყენებული შესვლა და პაროლი, მითითებულია ფორმატში ":" .

შემდეგი ვარიანტის პარამეტრის მნიშვნელობებისთვის, მნიშვნელობის პარამეტრი უნდა იყოს მასივი:

Პარამეტრი დააყენეთ მნიშვნელობის მნიშვნელობა შენიშვნები
CURLOPT_HTTP200ALIASES HTTP 200 პასუხების მასივი, რომელიც განიხილება როგორც სწორი პასუხები, ვიდრე მცდარი. დამატებულია cURL ვერსიაში 7.10.3.
CURLOPT_HTTPHEADER დაყენებული HTTP სათაურების მასივი, ფორმატის მასივში ("შიგთავსის ტიპი: ტექსტი/უბრალო", "შინაარსის სიგრძე: 100")
CURLOPT_POSTQUOTE FTP ბრძანებების მასივი, რომელიც შესრულებულია სერვერზე FTP მოთხოვნის დასრულების შემდეგ.
CURLOPT_QUOTE FTP ბრძანებების მასივი, რომელიც შესრულებულია სერვერზე FTP მოთხოვნის გაკეთებამდე.

შემდეგი ვარიანტის პარამეტრის მნიშვნელობებისთვის, მნიშვნელობის პარამეტრი უნდა იყოს ნაკადის სახელური (დაბრუნებული, მაგალითად, ფუნქციით fopen ()):

Პარამეტრი დააყენეთ მნიშვნელობის მნიშვნელობა
CURLOPT_FILE ფაილი, რომელშიც ჩაიწერება გადაცემის შედეგი. ნაგულისხმევი გამომავალი ნაკადი STDOUT(ბრაუზერის ფანჯარა).
CURLOPT_INFILE ფაილი, საიდანაც უნდა წაიკითხოს მონაცემები სერვერზე ატვირთვისას.
CURLOPT_STDERR შეცდომის ალტერნატიული გამომავალი ფაილი გამოიყენება შეცდომის ნაკადის ნაცვლად STDERR.
CURLOPT_WRITEHEADER ფაილი, რომელშიც ჩაიწერება მიმდინარე ოპერაციის სათაურები.

შემდეგი ვარიანტის პარამეტრის მნიშვნელობებისთვის, მნიშვნელობის პარამეტრი უნდა იყოს სწორი ფუნქციის სახელი ან დახურვა:

Პარამეტრი დააყენეთ მნიშვნელობის მნიშვნელობა
CURLOPT_HEADERFUNCTION გამოძახების ფუნქცია იღებს ორ პარამეტრს. პირველი პარამეტრი არის cURL სახელური, მეორე პარამეტრი არის სტრიქონი, რომელიც შეიცავს დასაწერ სათაურებს. სათაურები უნდა დაიწეროს ამ გამოძახების ფუნქციის გამოყენებით. უნდა დააბრუნოს დაწერილი ბაიტების რაოდენობა.
CURLOPT_PASSWDFUNCTION გამოძახების ფუნქცია იღებს სამ პარამეტრს. პირველი პარამეტრი არის cURL სახელური, მეორე პარამეტრი არის პაროლის მოთხოვნის სტრიქონი და მესამე პარამეტრი არის პაროლის მაქსიმალური სიგრძე. უნდა დააბრუნოს პაროლის შემცველი სტრიქონი.
CURLOPT_PROGRESSFUNCTION

გამოძახების ფუნქცია იღებს ხუთ პარამეტრს. პირველი არის cURL დესკრიპტორი, მეორე არის ბაიტების მთლიანი რაოდენობა, რომელიც მოსალოდნელია უნდა ჩამოიტვირთოს სერვერიდან, მესამე არის უკვე გადმოწერილი ბაიტების რაოდენობა, მეოთხე არის სერვერზე მოსალოდნელი გაგზავნის ბაიტების საერთო რაოდენობა და მეხუთე არის უკვე გაგზავნილი ბაიტების რაოდენობა.

კომენტარი:

გამოძახების ფუნქცია გამოიძახება მხოლოდ იმ შემთხვევაში, თუ ეს ვარიანტია CURLOPT_NOPROGRESSმნიშვნელობაზე დაყენებული ცრუ.

გადარიცხვის გასაუქმებლად შეგიძლიათ დააბრუნოთ ნულოვანი მნიშვნელობა. ამ შემთხვევაში გამოჩნდება შეცდომა CURLE_ABORTED_BY_CALLBACK.
CURLOPT_READFUNCTION გამოძახების ფუნქცია იღებს სამ პარამეტრს. პირველი პარამეტრი არის cURL სახელური, მეორე პარამეტრი არის ნაკადის რესურსი, რომელიც გადაეცემა cURL-ს ოფციონის საშუალებით. CURLOPT_INFILEდა მესამე პარამეტრი არის წასაკითხი მონაცემების მაქსიმალური დასაშვები რაოდენობა. გამოძახების ფუნქციამ უნდა დააბრუნოს სიგრძის სტრიქონი, რომელიც არ აღემატება მოთხოვნილ მონაცემთა რაოდენობას, როგორც წესი, გადაცემული ნაკადის რესურსიდან წაკითხვით. უნდა დააბრუნოს ცარიელი სტრიქონი ფაილის დასასრულის სიგნალად EOF.
CURLOPT_WRITEFUNCTION გამოძახების ფუნქცია იღებს ორ პარამეტრს. პირველი პარამეტრი არის cURL სახელური, ხოლო მეორე პარამეტრი არის სტრიქონი, რომელიც შეიცავს ჩასაწერ მონაცემებს. მონაცემები უნდა იყოს შენახული ამ ფუნქციის გამოყენებით. მან უნდა დააბრუნოს დაწერილი ბაიტების ზუსტი რაოდენობა, წინააღმდეგ შემთხვევაში ჩამოტვირთვა შეჩერდება შეცდომით.

სხვა მნიშვნელობები:

ღირებულებების დაბრუნება

ბრუნდება მართალიწარმატებით დასრულების შემდეგ ან ცრუშეცდომის შემთხვევაში.

ცვლილებების სია

ვერსია აღწერა
5.6.0 ვარიანტი CURL_SAFE_UPLOADახლა აქვს ნაგულისხმევი მნიშვნელობა მართალი.
5.6.0 ამოღებულია ვარიანტი CURLOPT_CLOSEPOLICYდა მასთან დაკავშირებული მნიშვნელობები.
5.5.0 cURL რესურსი ემატება, როგორც პირველი არგუმენტი გამოძახების ფუნქციას CURLOPT_PROGRESSFUNCTION.
5.5.0 დამატებულია ვარიანტი CURLOPT_SHARE.
5.3.0 დამატებულია ვარიანტი CURLOPT_PROGRESSFUNCTION.
5.2.10 დამატებულია პარამეტრები CURLOPT_პროტოკოლებიდა CURLOPT_REDIR_პროტოკოლები.
5.1.0 დამატებულია პარამეტრები CURLOPT_AUTOREFERER, CURLOPT_BINARYTRANSFER, CURLOPT_FTPSSLAUTH, CURLOPT_PROXYAUTHდა CURLOPT_TIMECONDITION.
5.0.0 დამატებულია პარამეტრები CURLOPT_FTP_USE_EPRT, CURLOPT_NOSIGNAL, CURLOPT_UNRESTRICTED_AUTH, CURLOPT_BUFFERSIZE, CURLOPT_HTTPAUTH, CURLOPT_PROXYPORT, CURLOPT_PROXYTYPE, CURLOPT_SSLCERTTYPEდა CURLOPT_HTTP200ALIASES.

მაგალითები

მაგალითი #1 CURL სესიის ინიციალიზაცია და ვებ გვერდის ჩატვირთვა

// ახალი cURL რესურსის შექმნა
$ch = curl_init();

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

$ch = curl_init();

$data = array("name" => "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, $data);

Curl_exec ($ch);
?>

ამ მაგალითის გაშვების შედეგი:

მასივი ( => Foo) მასივი ( => მასივი ( => test.png => image/png => /tmp/phpcpjNeQ => 0 => 279))

შენიშვნები

კომენტარი:

მასივის გადაცემა CURLOPT_POSTFIELDSშიფრავს მონაცემებს როგორც მრავალნაწილიანი/ფორმა-მონაცემები, მაშინ როცა URL-ში დაშიფრული სტრიქონის გადაცემა მონაცემებს დაშიფრავს როგორც განაცხადი/x-www-form-urlencoded.

cURL არის ინსტრუმენტი, რომელიც გაძლევთ საშუალებას იმოქმედოთ სხვადასხვა სერვერებთან და მხარს უჭერს ბევრ პროტოკოლს: HTTP, FTP, TELNET და ა.შ. cURL თავდაპირველად არის ბრძანების ხაზის პროგრამა. მაგრამ, ჩვენთვის საბედნიეროდ, PHP მხარს უჭერს cURL ბიბლიოთეკასთან მუშაობას. ამ სტატიაში განვიხილავთ cURL-თან მუშაობის არატრივიალურ მაგალითებს.

რატომ cURL?

სინამდვილეში, არსებობს მრავალი სხვა გზა სხვა სერვერზე მოთხოვნის გასაგზავნად, მაგალითად, გვერდის შინაარსის მისაღებად. ბევრი ადამიანი, ძირითადად სიზარმაცის გამო, იყენებს მარტივ PHP ფუნქციებს cURL-ის ნაცვლად:

$content = file_get_contents ("http://www.example.com"); // ან $lines = ფაილი ("http://www.example.com"); // ან readfile ("http://www.example.com");

თუმცა, ისინი არ იძლევიან შეცდომის ეფექტური დამუშავების საშუალებას. ასევე არის მთელი რიგი დავალება, რომელთა შესრულებაც მათ საერთოდ არ შეუძლიათ - მაგალითად, ქუქი-ფაილებით მუშაობა, ავტორიზაცია, მოთხოვნის განთავსება, ფაილების ჩამოტვირთვა.

cUrl არის ძლიერი ინსტრუმენტი, რომელიც მხარს უჭერს მრავალ პროტოკოლს და უზრუნველყოფს სრულ მოთხოვნის ინფორმაციას.

cURl საფუძვლები

სანამ რთულ მაგალითებზე გადავიდოდეთ, მოდით გადავხედოთ cURL მოთხოვნის ძირითად სტრუქტურას PHP-ში. PHP-ში cURL მოთხოვნის შესასრულებლად, თქვენ უნდა გადადგათ 4 ძირითადი ნაბიჯი:

  1. ინიციალიზაცია.
  2. პარამეტრების დაყენება.
  3. მოთხოვნის შესრულება.
  4. დასუფთავების რესურსები.
// 1. ინიციალიზაცია $ch = curl_init(); // 2. პარამეტრების დაყენება, მათ შორის URL curl_setopt($ch, CURLOPT_URL, "http://www.google.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_HEADER, 0); // 3. მოთხოვნის შესრულება და პასუხის მიღება $output = curl_exec($ch); // 4. დასუფთავების რესურსები curl_close($ch);

ჩვენ ძირითადად განვიხილავთ ამ სტატიაში #2 საფეხურს, რადგან სწორედ აქ ხდება მაგია. cURL ვარიანტების სია ძალიან დიდია, ამიტომ ჩვენ დღეს არ განვიხილავთ ყველა ვარიანტს, მაგრამ გამოვიყენებთ მათ, რაც სასარგებლოა კონკრეტული პრობლემების გადასაჭრელად.

შეცდომების თვალყურის დევნება

საჭიროების შემთხვევაში, შეგიძლიათ დაამატოთ შემდეგი ხაზები შეცდომების თვალყურის დევნებისთვის:

// ... $გამომავალი = curl_exec($ch); if ($output === FALSE) (echo "cURL შეცდომა: " . curl_error($ch); ) // ...

გთხოვთ გაითვალისწინოთ, რომ ჩვენ ვიყენებთ "==="-ს ნაცვლად "=="-ის, რადგან აუცილებელია განასხვავოთ სერვერის ცარიელი პასუხი და ლოგიკური მნიშვნელობა FALSE, რომელიც ბრუნდება შეცდომის შემთხვევაში.

ინფორმაციის მიღება მოთხოვნის შესახებ

კიდევ ერთი სურვილისამებრ ნაბიჯი არის ინფორმაციის მიღება cURL მოთხოვნის შესახებ მისი შესრულების შემდეგ.

// ... curl_exec($ch); $info = curl_getinfo ($ch); ექო "აიღო". $info["total_time"] . "წამები url-ისთვის". $info["url"]; //...

შედეგად, თქვენ მიიღებთ მასივს შემდეგი ინფორმაციით:

  • "url"
  • "შინაარსის ტიპი"
  • "http_code"
  • "header_size"
  • "მოთხოვნის_ ზომა"
  • "ფაილის დრო"
  • "ssl_verify_result"
  • "გადამისამართების_ რაოდენობა"
  • "total_time"
  • "namelookup_time"
  • "connect_time"
  • "წინასწარ გადაცემის_დრო"
  • "size_upload"
  • "ზომა_ჩამოტვირთვა"
  • "speed_download"
  • "speed_upload"
  • "ჩამოტვირთვა_კონტენტის_სიგრძე"
  • "ატვირთვა_კონტენტის_სიგრძე"
  • "დაწყების გადაცემის_დრო"
  • "გადამისამართების_დრო"

გადამისამართება თვალყურის დევნება, ბრაუზერის მიხედვით

ამ მაგალითში ჩვენ დავწერთ სკრიპტს, რომელიც აღმოაჩენს გადამისამართებებს ბრაუზერის სხვადასხვა პარამეტრებზე დაყრდნობით. მაგალითად, ზოგიერთი საიტი გადამისამართებს ვიზიტორებს მობილური მოწყობილობებიდან სხვა ქვეყნების ვიზიტორებზე.

ჩვენ გამოვიყენებთ CURLOPT_HTTPHEADER ვარიანტს, რათა დავაყენოთ ჩვენი საკუთარი სათაურები, მომხმარებლის აგენტისა და ენის ჩათვლით, და ვნახოთ, სად გვიგზავნის საიტები.

// URLs $urls = array("http://www.cnn.com", "http://www.mozilla.com", "http://www.facebook.com"); // ბრაუზერები $browsers = 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" => მასივი ("user_agent" => "Mozilla/5.0 (iPhone; U; CPU, როგორიცაა Mac OS X; en) AppleWebKit/420+ (KHTML, როგორიცაა Gecko) ვერსია/3.0 Mobile/1A537a Safari/419.3", "language" => "en"), "ფრანგული" => მასივი ("user_agent" = > "Mozilla/4.0 (თავსებადი; MSIE 7.0; Windows NT 5.1; GTB6; .NET CLR 2.0.50727)", "language" => "fr,fr-FR;q=0.5")); foreach ($urls როგორც $url) ( echo "URL: $url\n"; foreach ($browsers როგორც $test_name => $browser) ($ch = curl_init(); // დააყენეთ მისამართი curl_setopt($ch, CURLOPT_URL , $url); // მიუთითეთ გამოყენებული ბრაუზერი და ენა curl_setopt($ch, CURLOPT_HTTPHEADER, array("User-Agent: ($browser["user_agent"])", "Accept-Language: ($browser["language" ]) ")); // ჩვენ არ გვჭირდება გვერდის შინაარსი curl_setopt($ch, CURLOPT_NOBODY, 1); // ჩვენ გვჭირდება მხოლოდ სათაურები curl_setopt($ch, CURLOPT_HEADER, 1); // ამის ნაცვლად დავაბრუნოთ შედეგი მისი გამომავალი curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); $output = curl_exec($ch); curl_close($ch); // განსაზღვრავს გადამისამართებებს HTTP სათაურებში? if (preg_match("! მდებარეობა: (.*)!" , $output, $matches)) (echo "$test_name: გადამისამართდება $matches\n"; ) else (echo "$test_name: გადამისამართების გარეშე\n"; ) ) echo "\n\n"; )

ციკლში ჩვენ ვამოწმებთ ბრაუზერებს თითოეული URL-ისთვის. ჯერ დავაყენეთ ჩვენი მოთხოვნის ვარიანტები: URL და ბრაუზერი და შესამოწმებელი ენა.

იმიტომ რომ ჩვენ დავაყენეთ სპეციალური ვარიანტი, მოთხოვნის შედეგი შეიცავს მხოლოდ HTTP სათაურებს. მარტივი რეგულარული გამოხატვის გამოყენებით, ჩვენ შეგვიძლია შევამოწმოთ, შეიცავს თუ არა პასუხი სტრიქონს "Location:".

სკრიპტის შესრულების შედეგი:

URL: http://www.cnn.com სტანდარტი: გადამისამართებები http://edition.cnn.com/ iphone: გადამისამართებები http://edition.cnn.com/ ფრანგული: გადამისამართებები http://edition.cnn-ზე .com/ URL: http://www.mozilla.com სტანდარტი: გადამისამართებები https://www.mozilla.org/firefox/ iphone: გადამისამართებები https://www.mozilla.org/firefox/ ფრანგული: გადამისამართებები https://www.mozilla.org/firefox/ URL: http://www.facebook.com სტანდარტი: გადამისამართებები https://www.facebook.com/ iphone: გადამისამართებები http://m.facebook.com /?refsrc=http%3A%2F%2Fwww.facebook.com%2F&_rdr ფრანგული: გადამისამართების გარეშე

POST მოთხოვნების გაგზავნა

GET მოთხოვნების შესრულებისას, მონაცემები შეიძლება გადაეცეს შეკითხვის სტრიქონში. მაგალითად, როდესაც თქვენ ეძებთ Google-ში, თქვენი შეკითხვა ითარგმნება URL-ად:

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

ამ მოთხოვნის შედეგის მისაღებად თქვენ არც კი გჭირდებათ cURL, შეგიძლიათ იყოთ ზარმაცი და გამოიყენოთ "file_get_contents()".

მაგრამ ზოგიერთი HTML ფორმა იყენებს POST მეთოდს. ამ შემთხვევაში, მონაცემები იგზავნება მოთხოვნის შეტყობინების ტექსტში და არა თავად URL-ში.

მოდით დავწეროთ სკრიპტი, რომელიც გაგზავნის POST მოთხოვნებს. პირველი, მოდით შევქმნათ მარტივი PHP ფაილი, რომელიც მიიღებს ამ მოთხოვნებს და დააბრუნებს მასზე გაგზავნილ მონაცემებს. მოდით დავარქვათ მას post_output.php :

$url = "http://localhost/post_output.php"; $post_data = მასივი ("foo" => "bar", "query" => "FooBar", "action" => "გაგზავნა"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // POST მოთხოვნის გაკეთება curl_setopt($ch, CURLOPT_POST, 1); // მონაცემების დამატება curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $output = curl_exec($ch); curl_close ($ch); ექო $გამომავალი;

ეს სკრიპტი გამოვა:

მასივი ( => ბარი => FooBar => გაგზავნა)

ამ სკრიპტმა გაგზავნა POST მოთხოვნა post_output.php ფაილზე. რომელმაც გამოუშვა $_POST მასივის შიგთავსი და მივიღეთ ეს პასუხი cURL-ის გამოყენებით.

ფაილების ატვირთვა

ისევე, როგორც წინა მაგალითში, მოდით შევქმნათ ფაილი, რომელიც მიიღებს მოთხოვნებს, upload_output.php:

Print_r ($_FILES);

და თავად სკრიპტი, რომელიც ჩამოტვირთავს ფაილებს:

$url = "http://localhost/upload_output.php"; $post_data = მასივი ("foo" => "ზოლი", // ფაილი ასატვირთად "ატვირთვა" => "@/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); $output = curl_exec($ch); curl_close ($ch); ექო $გამომავალი;

თუ გსურთ ფაილის ატვირთვა, თქვენ მხოლოდ უნდა გაიაროთ მისკენ მიმავალი გზა, ისევე როგორც ჩვეულებრივი POST მოთხოვნის პარამეტრი, პრეფიქსით "@". სცენარის შედეგი:

მასივი ( => მასივი ( => desert.jpg => აპლიკაცია/ოქტეტი ნაკადი => /tmp/phpAhEvXy => 0 => 845941))

Multi cURL

cURL-ის ერთ-ერთი მოწინავე ფუნქცია PHP-ში არის მრავალი მოთხოვნის ერთდროულად და ასინქრონულად შესრულების შესაძლებლობა.

ნორმალურ პირობებში სკრიპტი ჩერდება და ელოდება მოთხოვნის დასრულებას. და თუ თქვენ გჭირდებათ ბევრი შეკითხვის შესრულება, ამას შეიძლება დიდი დრო დასჭირდეს, რადგან... თქვენ შეასრულებთ თანმიმდევრობით. ამ შეზღუდვის გვერდის ავლა შესაძლებელია:

// დამმუშავებლების შექმნა $ch1 = curl_init(); $ch2 = curl_init(); // პარამეტრების დაყენება 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); //მრავალჯერადი cURL სახელურის შექმნა $mh = curl_multi_init(); // დამმუშავებლების დამატება curl_multi_add_handle($mh,$ch1); curl_multi_add_handle($mh,$ch2); $running = null; // შეასრულეთ მოთხოვნები do ( curl_multi_exec($mh, $running); ) while ($running > 0); // გაათავისუფლე რესურსები curl_multi_remove_handle($mh, $ch1); curl_multi_remove_handle($mh, $ch2); curl_multi_close ($mh);

იდეა არის ის, რომ თქვენ შეგიძლიათ შექმნათ მრავალი cURL სახელური, დააკავშიროთ ისინი ერთი მრავალსახელურის ქვეშ და შეასრულოთ ისინი ასინქრონულად.

პირველი, ყველაფერი იგივეა, რაც ჩვეულებრივი cURL მოთხოვნის შემთხვევაში - იქმნება აღწერილობა ( curl_init () ), პარამეტრები დაყენებულია ( curl_setopt() ). შემდეგ იქმნება მულტი-აღმწერი ( curl_multi_init() ) და ემატება ადრე შექმნილი რეგულარული აღწერები ( curl_multi_add_handle() ). ნაცვლად curl_exec()-ის ნორმალურად გამოძახების ნაცვლად, ჩვენ გამოვიძახებთ curl_multi_exec() ეს ფუნქცია გვამცნობს აქტიური კავშირების რაოდენობას მეორე პარამეტრის გამოყენებით - $running. მაშასადამე, ციკლი გადის მანამ, სანამ $running არ გახდება 0-ის ტოლი. და, რა თქმა უნდა, სამუშაოს დასრულების შემდეგ, აუცილებელია რესურსების გამოშვება.

ამ მაგალითში, ჩვენ უბრალოდ გამოვიყვანთ შეკითხვის შედეგს STDOUT-ზე. განვიხილოთ multi cURL გამოყენების არა ტრივიალური შემთხვევა.

გარე ბმულების შემოწმება WordPress-ში

წარმოიდგინეთ ბლოგი ბევრი პოსტით, რომელიც შეიცავს ბმულებს გარე საიტებზე. ამ ბმულებიდან ზოგიერთი შეიძლება არ იმუშაოს.

მოდით დავწეროთ სკრიპტი, რომელიც იპოვის ყველა გაფუჭებულ ბმულს და გვაჩვენებს.

პირველ რიგში, ჩვენ უნდა ამოვიღოთ ყველა გარე ბმული მონაცემთა ბაზიდან:

// CONFIG $db_host = "localhost"; $db_user = "root"; $db_pass = ""; $db_name = "wordpress"; $excluded_domains = მასივი ("localhost", "საიტი"); $max_connections = 10; $url_list = მასივი(); $working_urls = მასივი(); $dead_urls = მასივი(); $not_found_urls = მასივი(); $active = null; // დაუკავშირდით MySQL-ს, თუ (!mysql_connect($db_host, $db_user, $db_pass)) ( die("დაკავშირება ვერ მოხერხდა: " . mysql_error()); ) if (!mysql_select_db($db_name)) ( die("შეუძლია არ აირჩიოთ db: " . mysql_error()); ) // მიიღეთ ყველა პოსტი ბმულით ტექსტში $q = "SELECT post_content FROM wp_posts WHERE post_content LIKE "%href=%" AND post_status = "publish" AND post_type = "post ""; $r = mysql_query($q) ან die(mysql_error()); while ($d = mysql_fetch_assoc($r)) ( // შეაგროვეთ ყველა ბმული რეგულარული გამოხატვის გამოყენებით if (preg_match_all("/href=\"(.*?)\"/", $d["post_content"], $ matches )) ( foreach ($ შეესაბამება $url-ს) ( // გაფილტრეთ არასაჭირო დომენები $tmp = parse_url($url); if (isset($tmp["host"]) && in_array($tmp["host"], $ excluded_domains)) ( გაგრძელება; ) // შეკრიბეთ $url_list = $url; ) ) ) // წაშალეთ გამეორებები $url_list = array_values(array_unique($url_list)); if (!$url_list) ( die ("URL არ არის შესამოწმებელი"); )

სკრიპტის ამ ნაწილში ჩვენ უბრალოდ ამოვიღებთ ყველა გარე ბმულს მონაცემთა ბაზიდან. მოდით შევამოწმოთ ისინი:

$mh = curl_multi_init(); // 1. დაამატეთ ბმულები ($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 "==მკვდარი URLs==\n"; echo implode("\n", $dead_urls) . "\n\n"; ექო "==404 URL==\n"; echo implode("\n", $not_found_urls) . "\n\n"; echo "==სამუშაო URLs==\n"; echo implode("\n", $working_urls); ექო "\n\n"; // 9. ამატებს სახელურს მოცემული URL ფუნქციით add_url_to_multi_handle($mh, $url_list) ( სტატიკური $index = 0; // თუ ჯერ კიდევ არის ბმულები if (isset($url_list[$index])) ( // ყველაფერი ჩვეულებრივ არის $ ch = curl_init(); // დააყენეთ პარამეტრები curl_setopt ($ch, CURLOPT_URL, $url_list[$index]); // დააბრუნეთ, ვიდრე შედეგის ჩვენება curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1); // დაშვება გადამისამართებს curl_setopt($ ch, CURLOPT_FOLLOWLOCATION, 1); // მიიღეთ მხოლოდ სათაურები დროის დაზოგვისთვის curl_setopt($ch, CURLOPT_NOBODY, 1); // დაამატეთ მრავალ სახელურს curl_multi_add_handle($mh, $ch); $index++; )

მოდით შევხედოთ კოდს უფრო დეტალურად (ნუმერაცია შეესაბამება კოდში მოცემულ კომენტარებს):

  1. ჩვენ ვამატებთ აღწერების საწყის რაოდენობას, რათა სისტემა არ გადავიტვირთოთ ძაფებით. რიცხვს აკონტროლებს $max_connections ცვლადი.
  2. $curRunning ცვლადი ინახავს გაშვებული ძაფების რაოდენობას, $running ინახავს წინა მნიშვნელობას; თუ ისინი არათანაბარი გახდებიან, მაშინ ერთ-ერთმა ძაფმა დაასრულა მუშაობა.
  3. ჩვენ ვიღებთ ინფორმაციას დასრულებული მოთხოვნის შესახებ.
  4. თუ სერვერისგან პასუხი არ არის, ბმული არ მუშაობს.
  5. სერვერის პასუხი არის 404.
  6. წინააღმდეგ შემთხვევაში ლინკი მუშაობს.
  7. მოთხოვნა დასრულებულია, ჩვენ გამოვყოფთ რესურსებს.
  8. მოდით დავამატოთ ახალი URL მრავალ აღმწერს.
  9. ფუნქცია add_url_to_multi_handle() ამატებს ახალ სახელურს მოცემული URL-ით მრავალ აღმწერს.

მოდით გავუშვათ სკრიპტი:

მკვდარი URLs== xample1234.com/ ==404 URLs== www.google.com/dsfasdfafd ==სამუშაო URLs== 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 კოდექსი. 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

შემოწმებას დაახლოებით 2 წამი დასჭირდა. 10 თემის ერთდროულად გაშვებით, შესრულება 10-ჯერ იზრდება ჩვეულებრივ cURL მოთხოვნებთან შედარებით. სერვერის პასუხის შინაარსის მისაღებად გამოიყენეთ ფუნქცია curl_multi_getcontent ($ch) , საიდანაც $ch არის აღმწერი, რომელიც მიღებულია curl_multi_info_read() .

სხვა cURL ფუნქციები PHP-ში

HTTP ავტორიზაცია

თუ HTTP მოთხოვნა მოითხოვს ავთენტიფიკაციას, გამოიყენეთ შემდეგი კოდი:

$url = "http://www.somesite.com/members/"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // გაგზავნეთ მომხმარებლის სახელი და პაროლი curl_setopt($ch, CURLOPT_USERPWD, "myusername:mypassword"); // თუ გადამისამართება დაშვებულია curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // cURL გამოგიგზავნით პაროლს curl_setopt გადამისამართების შემდეგ ($ch, CURLOPT_UNRESTRICTED_AUTH, 1); $output = curl_exec($ch); curl_close ($ch);

ატვირთეთ FTP-ის საშუალებით

PHP-ს აქვს საკუთარი ბიბლიოთეკა FTP-თან მუშაობისთვის, მაგრამ ასევე შეგიძლიათ გამოიყენოთ cURL:

// წაიკითხეთ ფაილი $file = fopen("/path/to/file", "r"); // url უკვე შეიცავს საჭირო მონაცემებს $url = "ftp://username: [ელფოსტა დაცულია]:21/path/to/new/file"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // ვარიანტები curl_setopt($ch, CURLOPT_UPLOAD, 1); curl_setopt ($ch, CURLOPT_INFILE, $fp); curl_setopt ($ch, CURLOPT_INFILESIZE, ფაილის ზომა ("/გზა/გზა/ფაილი")); curl_setopt($ch, CURLOPT_FTPASCII, 1); $გამომავალი = curl_exec($ ch);curl_close($ch);

პროქსის გამოყენება

მოთხოვნები შეიძლება გაკეთდეს კონკრეტული პროქსის მეშვეობით:

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://www.example.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // პროქსის მისამართი curl_setopt ($ch, CURLOPT_PROXY, "11.11.11.11:8080"); // თუ საჭიროა ავტორიზაცია curl_setopt($ch, CURLOPT_PROXYUSERPWD,"user:pass"); $output = curl_exec($ch); curl_close ($ch);

გამოძახების ფუნქციები

შესაძლებელია გამოძახების გამოყენება მოთხოვნის გაშვებისას, მის დასრულებამდე მოლოდინის გარეშე. მაგალითად, სანამ სერვერის პასუხი ჩამოტვირთულია, ჩვენ შეგვიძლია გამოვიყენოთ უკვე მიღებული მონაცემები სრული ჩამოტვირთვის მოლოდინის გარეშე.

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://example.com"); curl_setopt($ch, CURLOPT_WRITEFUNCTION,"პროგრესი_ფუნქცია"); curl_exec ($ch); curl_close ($ch); ფუნქცია progress_function($ch,$str) (echo $str; return strlen($str); )

გამოძახების ფუნქციამ უნდა დააბრუნოს სტრიქონის სიგრძე, რათა მოთხოვნამ სწორად იმუშაოს.

ყოველ ჯერზე, როდესაც მიიღება სერვერის პასუხის შემდეგი ნაწილი, გამოძახება მოხდება.

დასკვნა

ამ სტატიაში ჩვენ გადავხედეთ cURL-ის გაფართოებულ ფუნქციებს PHP-ში. შემდეგ ჯერზე, როცა URL-ის მოთხოვნა დაგჭირდებათ, გამოიყენეთ cURL.

ხშირად გვიწევს ინტერნეტიდან სხვადასხვა ფაილის გადმოწერა, მაგალითად, შესრულებადი პროგრამის ფაილები, სკრიპტის ფაილები, წყაროს არქივები. მაგრამ ეს ყოველთვის არ არის საჭირო ბრაუზერის საშუალებით. ბევრ სიტუაციაში ბევრად უფრო ადვილია ყველა მოქმედების შესრულება ტერმინალის მეშვეობით. რადგან ამ გზით თქვენ შეგიძლიათ პროცესის ავტომატიზაცია. მეორეს მხრივ, ვებმასტერებს დროდადრო უწევთ ვებსაიტის ხელმისაწვდომობის შემოწმება, გაგზავნილი და მიღებული სათაურების შემოწმება და მრავალი სხვა.

ასეთი პრობლემებისა და მსგავსი დიაპაზონის პრობლემების გადასაჭრელად, შეგიძლიათ გამოიყენოთ curl უტილიტა. ეს საშუალებას გაძლევთ გადაჭრას პრობლემების უფრო ფართო სპექტრი, მათ შორის, საიტზე მომხმარებლის მოქმედებების სიმულაც კი. ამ სტატიაში განვიხილავთ, თუ როგორ გამოვიყენოთ curl, რა არის და რატომ არის საჭირო ეს პროგრამა.

სინამდვილეში, curl უფრო მეტია, ვიდრე უბრალოდ ბრძანების ხაზი Linux-ისთვის ან Windows-ისთვის. ეს არის ბიბლიოთეკების ნაკრები, რომელიც ახორციელებს URL გვერდებთან მუშაობისა და ფაილების გადაცემის ძირითად შესაძლებლობებს. ბიბლიოთეკა მხარს უჭერს პროტოკოლებთან მუშაობას: FTP, FTPS, HTTP, HTTPS, TFTP, SCP, SFTP, Telnet, DICT, LDAP, ასევე POP3, IMAP და SMTP. ეს შესანიშნავია მომხმარებლის მოქმედებების სიმულაციისთვის გვერდებზე და სხვა ოპერაციებში URL-ებით.

Curl ბიბლიოთეკის მხარდაჭერა დაემატა მრავალ სხვადასხვა პროგრამირების ენასა და პლატფორმას. Curl უტილიტა არის დამოუკიდებელი შეფუთვა ამ ბიბლიოთეკისთვის. სწორედ ამ პროგრამაზე გავამახვილებთ ყურადღებას ამ სტატიაში.

curl ბრძანება

სანამ გადავიდოდეთ აღწერაზე, თუ როგორ შეიძლება გამოიყენოთ curl linux ბრძანება, მოდით გადავხედოთ თავად პროგრამას და მის მთავარ ვარიანტებს, რომლებიც დაგვჭირდება. პროგრამის სინტაქსი ძალიან მარტივია:

$ curl პარამეტრების ბმული

ახლა მოდით შევხედოთ მთავარ ვარიანტებს:

  • -# - მარტივი პროგრესის ზოლის ჩვენება დატვირთვის დროს;
  • -0 - გამოიყენეთ http 1.0 პროტოკოლი;
  • -1 - გამოიყენეთ tlsv1 დაშიფვრის პროტოკოლი;
  • -2 - გამოიყენეთ sslv2;
  • -3 - გამოიყენეთ sslv3;
  • -4 - გამოიყენეთ ipv4;
  • -6 - გამოიყენეთ ipv6;
  • -ა- მიუთითეთ თქვენი USER_AGENT;
  • -ბ- შეინახეთ ქუქი ფაილში;
  • -გ- გაგზავნეთ ქუქი სერვერზე ფაილიდან;
  • -გ- განაგრძეთ ფაილის ჩამოტვირთვა შესვენების წერტილიდან ან მითითებული ოფსეტიდან;
  • -მ- სერვერის პასუხის მოლოდინის მაქსიმალური დრო;
  • -დ- გაგზავნეთ მონაცემები POST მეთოდით;
  • -დ- სერვერის მიერ დაბრუნებული სათაურების შენახვა ფაილში;
  • -ე- დააყენეთ Referer-uri ველი, მიუთითეთ რომელი საიტიდან მოვიდა მომხმარებელი;
  • -ე- გამოიყენეთ გარე SSL სერთიფიკატი;
  • -ვ- არ აჩვენოთ შეცდომის შეტყობინებები;
  • -ფ- გაგზავნეთ მონაცემები ფორმის სახით;
  • -გ- თუ ეს პარამეტრი ჩართულია, მაშინ -d ოფციაში მითითებული ყველა მონაცემი გადაიცემა GET მეთოდით;
  • -ჰ- სათაურების გადატანა სერვერზე;
  • -ᲛᲔ- მიიღეთ მხოლოდ HTTP სათაური და უგულებელყოთ მთელი გვერდის შინაარსი;
  • -ჯ- წაიკითხეთ და გაგზავნეთ ქუქი ფაილები ფაილიდან;
  • -ჯ- ამოიღეთ სათაური მოთხოვნიდან;
  • -ლ- გადამისამართების მიღება და დამუშავება;
  • -ს- გადამისამართებების მაქსიმალური რაოდენობა მდებარეობის გამოყენებით;
  • -ო- გამომავალი გვერდის შინაარსი ფაილში;
  • -ო- შეინახეთ შინაარსი ფაილში გვერდის ან ფაილის სახელით სერვერზე;
  • -გვ- გამოიყენეთ პროქსი;
  • -- პროტო- მიუთითეთ გამოსაყენებელი პროტოკოლი;
  • -რ- შეინახეთ დისტანციური ფაილის ბოლო მოდიფიკაციის დრო;
  • -ს- შეცდომების შესახებ მინიმალური ინფორმაციის ჩვენება;
  • -ს- შეცდომის შეტყობინებების ჩვენება;
  • -თ- ატვირთეთ ფაილი სერვერზე;
  • -ვ- ყველაზე დეტალური გამომავალი;
  • -ი- ჩამოტვირთვის მინიმალური სიჩქარე;
  • -ი- ჩამოტვირთვის მაქსიმალური სიჩქარე;
  • -ზ- ჩამოტვირთეთ ფაილი მხოლოდ იმ შემთხვევაში, თუ ის შეიცვალა მითითებულ დროზე გვიან;
  • -ვ- აჩვენე ვერსია.

ეს სულაც არ არის curl linux-ის ყველა ვარიანტი, მაგრამ ის ჩამოთვლის საფუძვლებს, რომელთა გამოყენება დაგჭირდებათ.

როგორ გამოვიყენოთ curl?

ჩვენ განვიხილეთ ყველაფერი, რაც დაკავშირებულია curl უტილიტასთან მუშაობის თეორიასთან, ახლა დროა გადავიდეთ პრაქტიკაზე და გადავხედოთ curl ბრძანების მაგალითებს.

ყველაზე გავრცელებული ამოცანა ეს არის. ფაილის გადმოწერა ძალიან მარტივია. ამისათვის უბრალოდ გადაიტანეთ ფაილის სახელი ან html გვერდი უტილიტაში პარამეტრებში:

დახვევა https://raw.githubusercontent.com/curl/curl/master/README.md

მაგრამ აქ ერთი სიურპრიზი გელით: ფაილის მთელი შინაარსი გაიგზავნება სტანდარტულ გამომავალზე. ნებისმიერ ფაილში ჩასაწერად გამოიყენეთ:

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

და თუ გსურთ, რომ შედეგად ფაილს დაერქვას იგივე სახელი, როგორც ფაილი სერვერზე, გამოიყენეთ -O ვარიანტი:

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

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

საჭიროების შემთხვევაში, შეგიძლიათ ჩამოტვირთოთ რამდენიმე ფაილი ერთი ბრძანებით:

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

კიდევ ერთი რამ, რაც შეიძლება სასარგებლო იყოს ადმინისტრატორისთვის, არის ფაილის ჩამოტვირთვა მხოლოდ იმ შემთხვევაში, თუ ის შეცვლილია:

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

სიჩქარის ლიმიტი

თქვენ შეგიძლიათ შეზღუდოთ ჩამოტვირთვის სიჩქარე საჭირო ლიმიტამდე, რათა არ გადატვირთოთ ქსელი -Y ოფციის გამოყენებით:

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

აქ თქვენ უნდა მიუთითოთ კილობაიტების რაოდენობა წამში, რომლის ჩამოტვირთვაც შესაძლებელია. თქვენ ასევე შეგიძლიათ შეწყვიტოთ კავშირი, თუ სიჩქარე არ არის საკმარისი, ამისათვის გამოიყენეთ -Y ვარიანტი:

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

ფაილების გადატანა

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

ან მოდით შევამოწმოთ, რომ ფაილი იგზავნება HTTP-ით; ამისათვის არის სპეციალური სერვისი:

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

საპასუხოდ, პროგრამა გეტყვით, სად შეგიძლიათ იპოვოთ გადმოწერილი ფაილი.

POST მონაცემების გაგზავნა

თქვენ შეგიძლიათ გაგზავნოთ არა მხოლოდ ფაილები, არამედ ნებისმიერი მონაცემი POST მეთოდით. შეგახსენებთ, რომ ეს მეთოდი გამოიყენება სხვადასხვა ფორმის მონაცემების გასაგზავნად. ასეთი მოთხოვნის გასაგზავნად გამოიყენეთ -d ვარიანტი. ტესტირებისთვის ჩვენ გამოვიყენებთ იგივე სერვისს:

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

თუ არ ხართ კმაყოფილი წარდგენის ამ ვარიანტით, შეგიძლიათ პრეტენზია წარმოადგინოთ ფორმა. ამისთვის არის ვარიანტი -F:

curl -F "პაროლი=@pass;type=text/plain" http://posttestserver.com/post.php

აქ ჩვენ გადავცემთ პაროლის ველს ფორმას, როგორც უბრალო ტექსტს, ასევე შეგიძლიათ რამდენიმე პარამეტრის გადაცემა.

ქუქიების გაგზავნა და მიღება

ქუქი-ფაილებს ვებსაიტები იყენებენ მომხმარებლის მხარეს გარკვეული ინფორმაციის შესანახად. ეს შეიძლება იყოს საჭირო, მაგალითად, ავთენტიფიკაციისთვის. შეგიძლიათ გაგზავნოთ და მიიღოთ ქუქიები curl-ის გამოყენებით. მიღებული ქუქიების ფაილში შესანახად გამოიყენეთ -c ვარიანტი:

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

შემდეგ შეგიძლიათ უკან გაგზავნოთ curl cookie:

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

სათაურის გადაცემა და ანალიზი

ჩვენ ყოველთვის არ გვჭირდება გვერდის შინაარსი. ზოგჯერ მხოლოდ სათაურები შეიძლება იყოს საინტერესო. მხოლოდ მათი საჩვენებლად არის -I ვარიანტი:

დახვევა -I https://site

და -H ვარიანტი საშუალებას გაძლევთ გაგზავნოთ რამდენიმე ან მეტი სერვერზე, მაგალითად, შეგიძლიათ გადასცეთ If-Modified-Since სათაური ისე, რომ გვერდი დაბრუნდეს მხოლოდ იმ შემთხვევაში, თუ ის შეცვლილია:

დახვევის ავთენტიფიკაცია

თუ სერვერი მოითხოვს ავთენტიფიკაციის ერთ-ერთ ჩვეულებრივ ტიპს, როგორიცაა HTTP Basic ან FTP, მაშინ curl-ს შეუძლია ძალიან მარტივად გაუმკლავდეს ამ ამოცანას. ავთენტიფიკაციის დეტალების დასაზუსტებლად, უბრალოდ მიუთითეთ ისინი ორწერტილით გამოყოფილი -u ოფციაში:

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

ანალოგიურად განხორციელდება ავთენტიფიკაცია HTTP სერვერებზე.

პროქსის გამოყენება

თუ ფაილების ჩამოსატვირთად გჭირდებათ პროქსი სერვერის გამოყენება, მაშინ ეს ასევე ძალიან მარტივია. საკმარისია პროქსი სერვერის მისამართის მითითება -x ოფციაში:

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

დასკვნები

ამ სტატიაში ჩვენ განვიხილეთ, თუ როგორ გამოვიყენოთ curl, რატომ არის საჭირო ეს პროგრამა და მისი ძირითადი შესაძლებლობები. მიუხედავად მათი მსგავსებისა, ისინი ძალიან განსხვავდებიან. curl linux ბრძანება უფრო მეტად შექმნილია სერვერზე სხვადასხვა მოქმედებების ანალიზისა და სიმულაციისთვის, ხოლო wget უფრო შესაფერისია ფაილების ჩამოტვირთვისა და საიტების მცოცავისთვის.

ამ სტატიაში ვისაუბრებთ ისეთ მძლავრ ინსტრუმენტზე, როგორიც არის cURL, ასევე ბიბლიოთეკა PHP-სთვის, რომელიც უზრუნველყოფს წვდომას ამ ხელსაწყოზე - libcurl. რისთვის არის ეს ყველაფერი? სერვერთან კომუნიკაციისთვის მონაცემთა გადაცემის პროტოკოლების გამოყენებით, მაგალითად, http ან ftp. დანარჩენი პროტოკოლები ჩვენთვის განსაკუთრებით არ არის საინტერესო, თუ ვინმეს სურს ჩაუღრმავდეს ამ თემას, მოუწევს ინგლისურენოვანი რესურსების გათხრა და ეს სტატია შეიცავს საფუძვლებს და გამოყენების მაგალითებს.

კონკრეტულად რა არის cURL და libcurl? ზოგადი პუნქტები

ასე რომ, libcurl ბიბლიოთეკა გვაძლევს შესაძლებლობას გადავიტანოთ მონაცემები სერვერზე და მივიღოთ მისგან პასუხები. რას გვაძლევს ეს? მომხმარებლის ქცევის მიბაძვის შესაძლებლობა ან ! თქვენ შეგიძლიათ მიიღოთ გვერდების შიგთავსი შემდგომი ანალიზისთვის, შეგიძლიათ მიიღოთ სერვისის პასუხების სათაურები და პროგრამულად შეხვიდეთ საიტებზე, შექმნათ სკრიპტები შეტყობინებების გამოქვეყნებისთვის (მაგალითად, Twitter-ზე ან ფორუმებზე) ან ინფორმაციისთვის. ყველაფერი შემოიფარგლება მხოლოდ თქვენი ფანტაზიით!

cURL-ის ინსტალაცია Denwer-ზე (დენვერი). როგორ დავიწყოთ libcurl-ის გამოყენება?

პირველი რაც უნდა გავაკეთოთ არის ბიბლიოთეკის დაყენება. ჩემს ლოკალურ კომპიუტერზე მე ვიყენებ Denwer build-ს, როგორც დამწყები ვებმასტერების აბსოლუტური უმრავლესობა, ვისთვისაც განკუთვნილია სტატია. გამოცდილი მომხმარებლები, რომლებიც დამოუკიდებლად დააინსტალირებენ php+apache+mysql კომბინაციას, შეძლებენ cURL-ის დაინსტალირებას, ეს არ არის ჩემი ახსნა, თუ როგორ კეთდება ეს;) და ჩვენ, დამწყებთათვის, ვიყენებთ მზა გადაწყვეტილებებს ამის გასაადვილებლად. ამიტომ დააინსტალირეთ libcurl შემდეგნაირად:

  • ჩამოტვირთეთ მზა გაფართოების პაკეტი "PHP5: დამატებითი მოდულები".
  • შესაბამისად ვაინსტალირებთ. არაფერი რთული, გეთანხმები :)
  • გახსენით ფაილი Notepad-ში (მე ყოველთვის გირჩევთ Notepad++): X:/webservers/usr/local/php5/php.ini //სადაც X არის თქვენი დისკი, სადაც დაინსტალირებულია ვებ სერვერი

    და ამოიღეთ მძიმით ტერმინების დასაწყისში:

    ;extension=php_curl.dll

  • ჩვენ გადატვირთავთ დენვერის სერვერს.

მზადაა. ბიბლიოთეკის ფუნქციონირების შესამოწმებლად შეგიძლიათ დარეკოთ phpinfo() ფუნქცია და იპოვოთ ხაზი იქ: cURL მხარდაჭერა ჩართულია. გილოცავთ პირველ გამარჯვებას.

cURL-ის აღწერა და პირველი ნაბიჯები

ინსტრუმენტთან მუშაობის დასაწყებად საჭიროა მისი ინიციალიზაცია. ეს კეთდება შემდეგნაირად:

$ch = curl_init();

ჩვენ გამოვიყენეთ cURL სესიის ინიციალიზაციის ფუნქცია. ამ შემთხვევაში, თქვენ შეგიძლიათ დაუყონებლივ დააყენოთ URL, შემდეგნაირად:

$ch = curl_init ("https://site");

და ამის გაკეთება შეგიძლიათ მოგვიანებით, ოფციებში. ოფციების დაყენების თანმიმდევრობას არ აქვს მნიშვნელობა. ეს კეთდება სხვა ფუნქციით:

Curl_setopt (რესურსი ch, სტრიქონის ვარიანტი, შერეული მნიშვნელობა)

ჩვენ უკვე შევქმენით ამ ფუნქციის პირველი პარამეტრი, ანუ რესურსი ch, ზემოთ, მაგრამ ბევრი ვარიანტი და მნიშვნელობის პარამეტრია. მე ვფიქრობ, რომ თქვენ არ უნდა დააკოპიროთ ისინი ყველა აქ, არამედ მიაწოდოთ ბმული ფუნქციის დეტალური აღწერილობისთვის, იმედია არავის განაწყენდება: curl_setopt.

მე მივცემ მაგალითს პარამეტრების დაყენების მაგალითზე URL-ის გამოყენებით:

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

პარამეტრების დაყენების კიდევ რამდენიმე მაგალითი: მოდით მივიღოთ სერვერის პასუხის სათაური, თავად გვერდის მიღების გარეშე:

Curl_setopt($ch, CURLOPT_HEADER, 1); // წაიკითხეთ სათაური curl_setopt($ch, CURLOPT_NOBODY, 1); // წაიკითხეთ მხოლოდ სათაური სხეულის გარეშე

ასე რომ, ჩვენ მოვახდინეთ სესიის ინიციალიზაცია, დავაყენეთ ჩვენთვის საჭირო პარამეტრები, ახლა ვასრულებთ მიღებულ მოთხოვნას, ვხურავთ სესიას და ვაჩვენებთ შედეგს:

$შედეგი = curl_exec($ch); curl_close ($ch); ექო $შედეგი;

შედეგად, ჩვენ ვიღებთ libcurl ბიბლიოთეკის გამოყენების პირველ სრულად სამუშაო მაგალითს:

$ch = curl_init(); $url = "https://site"; curl_setopt($ch, CURLOPT_URL,$url); curl_setopt($ch, CURLOPT_HEADER, 1); // წაიკითხეთ სათაური curl_setopt($ch, CURLOPT_NOBODY, 1); // წაიკითხეთ მხოლოდ სათაური სხეულის გარეშე $result = curl_exec($ch); curl_close ($ch); ექო $შედეგი;

როგორ მუშაობს, იმედი მაქვს, გასაგებია, რადგან თითოეულ ნაბიჯს ცალ-ცალკე გადავხედეთ :) შედეგად, სერვერისგან ვიღებთ HTTP პასუხის სათაურს, რომელსაც აუცილებლად გავაანალიზებთ ქვემოთ, რათა უკეთ გავიგოთ ურთიერთქმედების ყველა ეტაპი. ბრაუზერი და სერვერი:

HTTP/1.1 200 OK სერვერი: nginx/1.2..php 1

ზღაპრული! ჩვენ მივიღეთ პასუხის სათაური სერვერიდან და შევამოწმეთ ბიბლიოთეკა მოქმედებაში. რამდენად სასარგებლოა ეს ჩვენთვის? იმის გამო, რომ ახლა თქვენ შეგიძლიათ წარმოიდგინოთ მოქმედებების თანმიმდევრობა cURL-თან მუშაობისას:

  • სესიის ინიცირება (curl_init)
  • დააყენეთ ჩვენთვის საჭირო ვარიანტები (curl_setopt)
  • შეასრულეთ მიღებული მოთხოვნა (curl_exec)
  • სესიის დასრულება (curl_close)

HTTP მოთხოვნის სათაურის სტრუქტურა

მაგალითად, გადავუხვიე ya.ru გვერდს და გადავხედე გენერირებულ ბრაუზერის მოთხოვნას და სერვერისგან მიღებულ პასუხს. აი ისინი:
მოთხოვნა
GET / HTTP/1.1 - ჩვენ ვცდილობთ მივიღოთ გვერდი /, ანუ მთავარი გვერდი, რომელიც მდებარეობს საქაღალდის ფესვში. ჩვენ ვიყენებთ პროტოკოლის ვერსიას 1.1.
მომხმარებლის აგენტი: Opera/9.80 (Windows NT 6.1; WOW64) Presto/2.12.388 ვერსია/12.14— ჩვენ თავს ვაცნობთ სერვერს, ჩვენ ვართ Opera ბრაუზერი.
მასპინძელი: ya.ru — მოთხოვნილი რესურსის დომენის სახელი.
მიღება: ტექსტი/html, აპლიკაცია/xml;q=0.9, აპლიკაცია/xhtml+xml, სურათი/png, სურათი/ვებპ, სურათი/jpeg, სურათი/გიფ, სურათი/x-xbitmap, */*;q=0.1— რესურსების მისაღები ფორმატების სია.
Accept-Language: ru-RU,ru;q=0.9,en;q=0.8— მხარდაჭერილი ენების სია.
Accept-Encoding: gzip, deflate— კოდირების მხარდაჭერილი მეთოდები.
ქუქი: yandexuid=ХХХХХ - ქუქიები, საჭიროების შემთხვევაში.
კავშირი: Keep-Alive - გთხოვთ, არ გაწყვიტოთ კავშირი და დარჩით კონტაქტზე.
უპასუხე
HTTP/1.1 200 Ok - ვიღებთ პასუხს 200 კოდით, რაც ნიშნავს, რომ ყველაფერი წესრიგშია.
სერვერი: nginx - სერვერმა გააცნო თავი - ეს არის nginx.
თარიღი: მზე, 10 მარტი 2013 14:10:50 GMT— მიმდინარე თარიღი და დრო სერვერზე.
Content-Type: text/html; charset=UTF-8- შინაარსის ტიპი და კოდირება.
კავშირი: დახურვა - სერვერს არ სურს ჩვენთან მუდმივი კავშირის შენარჩუნება, ამიტომ დაუყოვნებლივ ხურავს მას. ახალი კავშირი დამყარდება შემდეგი მოთხოვნისთვის.
Cache-Control: no-cache, no-store, max-age=0, აუცილებლად ხელახლა გადამოწმება— ქეშირების მართვა. ამ შემთხვევაში ის გამორთულია.
იწურება: მზე, 10 მარტი 2013 14:10:50 GMT— სხდომის სავარაუდო გასვლის თარიღი. ჩვენს შემთხვევაში, ეს ემთხვევა გახსნის დროს, რადგან სერვერმა დაუყოვნებლივ დახურა იგი, დამუშავებისთანავე.
ბოლო ცვლილება: მზე, 10 მარტი 2013 14:10:50 GMT- ბოლო მოდიფიკაციის დრო.
Content-Encoding: gzip — ინფორმაციის კოდირების მეთოდი.
ყველა პარამეტრის სრული სია, რომლებიც შეგიძლიათ იხილოთ HTTP მოთხოვნის სათაურში, შეგიძლიათ იხილოთ ვიკიპედიაში.
ახლა თქვენ გაქვთ უხეში წარმოდგენა იმის შესახებ, თუ როგორ ურთიერთობენ თქვენი ბრაუზერი და ვებ სერვერი ერთმანეთთან. ამის ცოდნა და გაგება ძალიან სასარგებლოა, რადგან ჩვენ შევეცდებით ბრაუზერის მოქმედებების ემულაციას libcurl ბიბლიოთეკის გამოყენებით. Განაგრძე.

ბიბლიოთეკასთან მუშაობის მაგალითი

მე მჯერა, რომ მას შემდეგ რაც ზოგიერთი ზოგადი პუნქტი უკვე ნათელია და ყველაფერი ნათელია, მაშინ დროა გადავიდეთ პრაქტიკაზე და დახვეწოთ თქვენი უნარები მაგალითის გამოყენებით. პირადად, ხელები ყოველთვის მტკივა, რომ ყველაფერი პრაქტიკაში ვცადო :)

ვინაიდან cURL ძალიან კარგია პარსერებისთვის, მოდით განვიხილოთ გვერდის კოდის მისამართებით მიღების ფუნქცია. ამ შემთხვევაში, გამომავალი იქნება მასივი სათაურით, გვერდის შინაარსით და შეცდომის კოდებითაც კი, თუ რამე არასწორედ მოხდება.

ფუნქცია get_web_page($url) ( $uagent = "Opera/9.80 (Windows NT 6.1; WOW64) Presto/2.12.388 ვერსია/12.14"; $ch = curl_init($url); curl_setopt($ch, CURLOPT_RETRANS1); // აბრუნებს ვებ გვერდს curl_setopt($ch, CURLOPT_HEADER, 0); // არ აბრუნებს სათაურებს curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // მიჰყვება გადამისამართებებს curl_setopt($ch, CURLOPT_ENCODING, ""); // პროცესებს ყველა კოდირება curl_setopt ($ch, CURLOPT_USERAGENT, $uagent); // მომხმარებლის აგენტი curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, 120); // კავშირის დრო curl_setopt ($ch, CURLOPT_TIMEOUT, 120); //პასუხის დროის ამოწურვა , 10); // შეჩერება მეათე გადამისამართების შემდეგ $content = curl_exec($ch); $err = curl_errno($ch); $errmsg = curl_error($ch); $header = curl_getinfo($ch); curl_close($ ch); $header["errno"] = $err; $header["errmsg"] = $errmsg; $header["content"] = $content; დაბრუნება $header; )

შეყვანის პარამეტრები:
url — გვერდის ან საიტის მისამართი.
გამომავალი პარამეტრის მნიშვნელობები (მაივი სამი ელემენტით):
header['errno'] - თუ რამე არასწორედ მოხდა, აქ იქნება შეცდომის კოდი.
header['errmsg'] - შეცდომის ტექსტი გამოჩნდება აქ.
header['content'] - რეალური გვერდი\ფაილი\სურათი და ა.შ.

ჩვენ ვიყენებთ ფუნქციას, მაგალითად, შემდეგნაირად:

$result = get_web_page ("https://ya.ru"); if (($result["errno"] != 0)||($result["http_code"] != 200)) (echo $result["errmsg"]; ) else ($page = $result["content "]; echo $page;)

ყველაფერი შეცდომების გარეშე უნდა წავიდეს და თქვენ მიიღებთ გვერდის კოდს $page ცვლადში. თუ ვცდილობთ მივიღოთ არარსებული გვერდი yaaaaaaaaaaaa.ru, მივიღებთ შეცდომას:

ვერ გადაწყდა მასპინძელი: yaaaaaaaaaaaa.ru; Მასპინძელი ვერ მოიძებნა

ყველაფერი სწორად და ლამაზად არის დამუშავებული :)
შემდეგ შეგიძლიათ გააკეთოთ ის, რაც გსურთ გვერდის კოდით, მაგალითად, გააანალიზოთ ის რეგულარული გამონათქვამებით. მაგრამ ეს ყველაფერი შემდეგ გაკვეთილებზეა, მაგრამ ახლა მოდით ამაზე შევჩერდეთ.

JavaScript დაბლოკილია თქვენს ბრაუზერში. გთხოვთ, ჩართოთ JavaScript საიტის ფუნქციონირებისთვის!

დახვევა

PHP მხარს უჭერს libcurl-ს, დანიელ სტენბერგის მიერ შექმნილ ბიბლიოთეკას, რომელიც შესაძლებელს ხდის სხვადასხვა ტიპის სერვერებთან დაკავშირებას და სხვადასხვა პროტოკოლების გამოყენებით.
libcurl ამჟამად მხარს უჭერს http, https, ftp, gopher, telnet, dict, ფაილი და ldap პროტოკოლებს.
libcurl ასევე მხარს უჭერს HTTPS სერთიფიკატებს, HTTP POST, HTTP PUT, FTP ატვირთვას (ეს ასევე შეიძლება გაკეთდეს ftp PHP გაფართოებით), HTTP ფორმაზე დაფუძნებული ატვირთვა, პროქსიები, ქუქიები და მომხმარებლის+პაროლი ავთენტიფიკაცია.

ეს ფუნქციები დაინერგა PHP 4.0.2-ში.

curl_init

curl_init - ახდენს CURL სესიის ინიციალიზებას.

აღწერა

რესურსი curl_init()

ფუნქცია curl_init ()ახდენს ახალი სესიის ინიციალიზებას და აბრუნებს CURL სახელურს და ფუნქციებში გამოსაყენებლად. თუ არჩევითი პარამეტრი urlმოწოდებულია, მაშინ CURLOPT_URL ვარიანტი მიიღებს ამ პარამეტრის მნიშვნელობას. შეგიძლიათ ხელით დააინსტალიროთ .

curl_setopt

curl_setopt - აყენებს CURL გადაცემის/გადაცემის ვარიანტებს.

აღწერა

ბული curl_setopt(რესურსი ch, სიმებიანი ვარიანტი, შერეული მნიშვნელობა)

ფუნქცია curl_setopt()აყენებს პარამეტრით განსაზღვრულ CURL სესიის ვარიანტებს ჩვ. Პარამეტრი ვარიანტიარის ვარიანტი, რომლის დაყენებაც გსურთ და ღირებულებაეს არის ოფციონის ღირებულება ვარიანტი .

Პარამეტრი ღირებულებაუნდა იყოს გრძელი შემდეგი პარამეტრებისთვის (მითითებულია პარამეტრით ვარიანტი):

  • CURLOPT_INFILESIZE: თუ თქვენ ატვირთავთ ფაილს დისტანციურ საიტზე, ეს პარამეტრი უნდა იქნას გამოყენებული PHP-სთვის სათქმელად, თუ რა იქნება მოსალოდნელი ფაილის ზომა.
  • CURLOPT_VERBOSE: დააყენეთ ეს პარამეტრი ნულოვანი მნიშვნელობით, თუ გსურთ, რომ CURL-მა მოახსენოს ყველა მოქმედება.
  • CURLOPT_HEADER: დააყენეთ ეს პარამეტრი ნულოვანი მნიშვნელობით, თუ გსურთ, რომ სათაური შევიდეს გამომავალში.
  • CURLOPT_NOPROGRESS: დააყენეთ ეს პარამეტრი ნულოვანი მნიშვნელობით, თუ არ გსურთ PHP-მ აჩვენოს CURL გადაცემის პროგრესის ინდიკატორი. (PHP ავტომატურად აყენებს ამ პარამეტრს არა-ნულოვან მნიშვნელობაზე; თქვენ მხოლოდ მისი შეცვლა გჭირდებათ გამართვისას.)
  • CURLOPT_NOBODY: დააყენეთ ეს პარამეტრი ნულოვანი მნიშვნელობით, თუ არ გსურთ, რომ სხეული შევიდეს გამოსავალში.
  • CURLOPT_FAILONERROR: დააყენეთ ეს პარამეტრი ნულოვანი მნიშვნელობით, თუ გსურთ PHP ჩუმად გასვლა, თუ დაბრუნებული HTTP კოდი 300-ზე მეტია. ნაგულისხმევად, გვერდი ჩვეულებრივ ბრუნდება კოდის იგნორირებასთან ერთად.
  • CURLOPT_UPLOAD: დააყენეთ ეს პარამეტრი ნულოვანი მნიშვნელობით, თუ გსურთ PHP-მ მოამზადოს ფაილი ასატვირთად.
  • CURLOPT_POST: დააყენეთ ეს პარამეტრი არანულოვან მნიშვნელობაზე, თუ გსურთ PHP-მ შეასრულოს რეგულარული HTTP POST. ეს POST არის ჩვეულებრივი განაცხადის ფორმაში/x-www-form-urlencoded, ყველაზე ხშირად გამოიყენება HTML ფორმებით.
  • CURLOPT_FTPLISTONLY: დააყენეთ ეს პარამეტრი არანულოვან მნიშვნელობაზე და PHP ჩამოთვლის FTP დირექტორიას სახელებს.
  • CURLOPT_FTPAPPEND: დააყენეთ ეს პარამეტრი არანულოვან მნიშვნელობაზე და PHP ჩაწერის ნაცვლად დაემატება დისტანციურ ფაილს.
  • CURLOPT_NETRC: დააყენეთ ეს პარამეტრი ნულოვანი მნიშვნელობით და PHP დაასკანირებს თქვენს ~./netrc ფაილს, რათა იპოვოთ თქვენი მომხმარებლის სახელი და პაროლი იმ დისტანციური საიტისთვის, რომელსაც უკავშირდებით.
  • CURLOPT_FOLLOWLOCATION: დააყენეთ ეს პარამეტრი ნულოვანი მნიშვნელობით, რათა დაიცვას ნებისმიერი "Location:" სათაური, რომელსაც სერვერი აგზავნის, როგორც HTTP სათაურის ნაწილი (გაითვალისწინეთ, რომ ეს არის რეკურსია, PHP მიჰყვება ყველა გაგზავნილ "Location:" -headers-ს. )
  • CURLOPT_PUT: დააყენეთ ეს პარამეტრი არანულოვან მნიშვნელობაზე HTTP PUT ფაილზე. ფაილი PUT-ისთვის უნდა დაყენდეს CURLOPT_INFILE და CURLOPT_INFILESIZE გამოყენებით.
  • CURLOPT_MUTE: დააყენეთ ეს პარამეტრი არანულოვან მნიშვნელობაზე და PHP იმუშავებს დამალული CURL ფუნქციების მიმართ.
  • CURLOPT_TIMEOUT: გაიარეთ პარამეტრი, რომელიც შეიცავს მაქსიმალურ დროს წამებში, რომლის საშუალებითაც შეგიძლიათ CURL ფუნქციების გაშვება.
  • CURLOPT_CONNECTTIMEOUT: გადაიტანეთ პარამეტრი, რომელიც შეიცავს მაქსიმალურ დროს, წამებში, რომლის ლოდინის უფლებას გაძლევთ დაკავშირების მცდელობისას. გამოიყენეთ 0 სამუდამოდ მოსალოდნელად.
  • CURLOPT_LOW_SPEED_LIMIT: გადაიტანეთ პარამეტრი, რომელიც შეიცავს გადაცემის სიჩქარეს, ბაიტებში წამში, რომლის ქვემოთ გადაცემა უნდა განხორციელდეს CURLOPT_LOW_SPEED_TIME შესრულებისას, წამებში, რათა PHP-მ ჩათვალოს ის ძალიან ნელი და შეაჩეროს იგი.
  • CURLOPT_LOW_SPEED_TIME: გაიარეთ პარამეტრი, რომელიც შეიცავს დროს წამებში, რომლის ქვემოთ უნდა განხორციელდეს გადაცემა CURLOPT_LOW_SPEED_LIMIT იმისთვის, რომ PHP ჩათვალოს ის ძალიან ნელი და გააუქმოს.
  • CURLOPT_RESUME_FROM: გადის პარამეტრს, რომელიც შეიცავს ბაიტის ოფსეტს, რომლითაც უნდა დაიწყოს გადაცემა.
  • CURLOPT_SSLVERSION: გადაიტანეთ პარამეტრი, რომელიც შეიცავს SSL ვერსიას გამოსაყენებლად (2 ან 3). ნაგულისხმევად, PHP ცდილობს თავად განსაზღვროს ეს, თუმცა ზოგიერთ შემთხვევაში თქვენ უნდა დააყენოთ ეს ხელით.
  • CURLOPT_SSL_VERIFYHOST: გაიარეთ ხანგრძლივი, თუ CURL-მა უნდა შეამოწმოს თანატოლების სერტიფიკატის საერთო სახელი SSL ხელის ჩამორთმევისას. 1-ის მნიშვნელობა მიუთითებს, რომ ჩვენ უნდა შევამოწმოთ საერთო/საერთო სახელის არსებობა, 2-ის მნიშვნელობა მიუთითებს, რომ უნდა დავრწმუნდეთ, რომ იგი ემთხვევა მოწოდებულ ჰოსტის სახელს.
  • CURLOPT_TIMECONDITION: გაიარეთ გრძელი პარამეტრი, რომელიც განსაზღვრავს როგორ განიხილება CURLOPT_TIMEVALUE. შეგიძლიათ დააყენოთ ეს პარამეტრი TIMECOND_IFMODSINCE ან TIMECOND_ISUNMODSINCE. ეს მუშაობს მხოლოდ HTTP-სთვის.
  • CURLOPT_TIMEVALUE: გაიარეთ პარამეტრის სახით, რაც არის დრო წამებში 1970 წლის 1 იანვრიდან. ეს დრო გამოიყენება CURLOPT_TIMEVALUE ოფციაში მითითებულად, ან გამოყენებული იქნება ნაგულისხმევი TIMECOND_IFMODSINCE.
  • CURLOPT_RETURNTRANSFER: გადაიტანეთ არა ნულოვანი მნიშვნელობა, თუ გსურთ, რომ CURL-მა პირდაპირ დააბრუნოს მიღებული ინფორმაცია, პირდაპირ დაბეჭდვის ნაცვლად.

Პარამეტრი ღირებულებაუნდა იყოს სტრიქონი შემდეგი პარამეტრის მნიშვნელობებისთვის ვარიანტი :

შემდეგი პარამეტრები ველით ფაილის აღწერს, რომელიც მიიღება ფუნქციის გამოყენებით fopen () :

  • CURLOPT_FILE: ფაილი, სადაც უნდა განთავსდეს თქვენი გადაცემის გამოსავალი, ნაგულისხმევად არის STDOUT.
  • CURLOPT_INFILE: ფაილი, საიდანაც მოდის თქვენი გადაცემის შეყვანა.
  • CURLOPT_WRITEHEADER: ფაილი გამომავალი სათაურის ნაწილის ჩასაწერად.
  • CURLOPT_STDERR: ფაილი შეცდომების ჩასაწერად, stderr-ის ნაცვლად.

Პარამეტრი ღირებულება long write_callback (რესურსი ch, სტრიქონის მონაცემები)( ... return strlen($data);) ვარიანტი :

  • CURLOPT_WRITEFUNCTION: .
  • CURLOPT_HEADERFUNCTION: .

Პარამეტრი ღირებულებაუნდა იყოს შემდეგი ფორმის ფუნქცია string read_callback (რესურსი ch, რესურსი fd, გრძელი სიგრძე)()შემდეგი პარამეტრების მნიშვნელობებისთვის ვარიანტი :

  • CURLOPT_READFUNCTION: .

curl_exec

curl_exec - ახორციელებს CURL სესიას.

აღწერა

ბული curl_exec(რესურსი ჩ)

ეს ფუნქცია უნდა გამოიძახოთ მას შემდეგ, რაც თქვენ დააწყებთ CURL სესიას და ამ სესიისთვის ყველა ვარიანტი უკვე დაყენებულია. მისი მიზანია უბრალოდ შეასრულოს წინასწარ განსაზღვრული CURL სესია (მითითებულია პარამეტრში ჩვ).

დახვევა_დახურვა

curl_close - ხურავს CURL სესიას.

აღწერა

ბათილად დახვევა_დახურვა(რესურსი ჩ)

ეს ფუნქცია ხურავს CURL სესიას და ათავისუფლებს ყველა რესურსს. CURL სახელური ჩვასევე წაშლილია.

curl_errno

curl_errno - აბრუნებს მთელ რიცხვს, რომელიც შეიცავს ბოლო შეცდომის ნომერს.

აღწერა

მაგალითი 1: ახალი CURL სესიის ინიცირება და ვებ გვერდის მოძიება.
მაგალითი 2: PHP-ის CURL მოდულის გამოყენება example.com-ის მისაღებად
მაგალითი 3: URL-ის ხელმისაწვდომობის შემოწმება PHP-ის CURL-ის გამოყენებით
მაგალითი 4: სათაურის გამოყოფა სხეულისგან მიღებული PHP-ის CURL-ის გამოყენებით
მაგალითი 5: რეფერალური URL-ის განსაზღვრა PHP-ის CURL-ის გამოყენებით
პრობლემა: curl_setopt($ch,FOLLOW_LOCATION,1); შეცდომა: პრობლემები open_basedir-თან და safe_mode-თან, გამოსავალი: ფუნქცია უკვე შემუშავებულია ვიღაცის მიერ. გადაწყვეტა n 2: იგივე ფუნქცია, შეცვლილი, მშვენივრად მუშაობს ჩემთვის..= $curl_max_loops) ( $curl_loops = 0; დაბრუნება FALSE; ) curl_setopt ($ch, CURLOPT_HEADER, true); curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); $data = curl_exec($ch); list ($header, $data) = აფეთქება ("\n\n", $data, 2); $http_code = curl_getinfo ($ch, CURLINFO_HTTP_CODE); if ($http_code == 301 || $http_code == 302) ( $matches = ; preg_match("/Location:(.*?)\n/", $header, $matches); $url = @parse_url(trim (array_pop ($ matches))); თუ (!$url) (//ვერ ვერ დაამუშავა url $curl_loops = 0-ზე გადამისამართებლად; $last_url = parse_url(curl_getinfo($ch, CURLINFO_EFFECTIVE_URL)) ; if (!$url["scheme"]) $url["scheme"] = $last_url["scheme"]; if (!$url["host"]) $url["host"] = $last_url[ "მასპინძელი"]; თუ (!$url["გზა"]) $url["გზა"] = $last_url["გზა"]; $new_url = $url["სქემა"] . "://" . $ url["მასპინძელი"] . $url["გზა"] . ($url["შეკითხვა"]?"?".$url["შეკითხვა"]:""); curl_setopt($ch, CURLOPT_URL, $new_url) ; გამართვა ("გადამისამართება", $new_url); დაბრუნება curl_redir_exec($ch); ) else ($curl_loops=0; დაბრუნება $data; )) ?>
უბრალოდ გამოიყენეთ ეს ფუნქცია FOLLOW_LOCATION-ის გარეშე და უნდა იმუშაოს. პრობლემა ის იყო, რომ როდესაც მიდიხართ ხაზთან, სადაც დააბრუნებთ მონაცემებს, თუ http_code განსხვავებული იყო 301 oe 302-ისგან, $data-ს აქვს მოძველებული ინფორმაცია ან არცერთი. ასე რომ, $debbbb აკეთებს საქმეს.
მაგალითი 6: ქუქი-ფაილის გაანალიზება სათაურიდან CURL PHP-ის გამოყენებით
ზოგჯერ ვერ იყენებთ CURLOPT_COOKIEJAR-ს და CURLOPT_COOKIEFILE-ს სერვერის php-პარამეტრებიდან (ისინი ამბობენ, რომ ამ პარამეტრების გამოყენებით შეგიძლიათ სერვერიდან ნებისმიერი ფაილი წაიღოთ). აი გამოსავალი 1) არ გამოიყენოთ CURLOPT_FOLLOWLOCATION 2) გამოიყენეთ curl_setopt($ch, CURLOPT_HEADER; $cookies = implode(";", $results); 4)დააყენეთ ისინი curl_setopt($ch, CURLOPT_COOKIE, $cookies) გამოყენებით;
მაგალითი 7: ქუქი-ფაილის გაანალიზება სათაურიდან CURL PHP-ის გამოყენებით
როგორც ადრე ევგენმა აღინიშნა, ზოგჯერ ჩვენ არ შეგვიძლია გამოვიყენოთ CURLOPT_COOKIEJAR და CURLOPT_COOKIEFILE. ქვემოთ მოცემულია სათაურის გამოძახების ფუნქცია, რომელიც დავწერე იანვარში, რომელიც საშუალებას გაძლევთ შეინახოთ ქუქიები cURL მოთხოვნებს შორის. ქუქიები ემატება $ch-ს ყველა მოთხოვნის დროს, გადამისამართების დროსაც კი, ასე რომ თქვენ შეგიძლიათ. გამოიყენეთ იგი CURLOPT_FOLLOWLOCATION-თან ერთად. აქ არის კოდი: ფუნქცია read_header($ch, $string) ( გლობალური $location; #მიადევნეთ თვალყური მდებარეობას/გადამისამართებს გლობალურ $cookiearr; #store cookies აქ გლობალური $ch; # ^ არღვევს ფუნქციის პარამეტრს $ch # ეს ნორმალურია, რადგან ჩვენ გვჭირდება # განვაახლოთ გლობალური $ch # ახალი ქუქი-ფაილით $length = strlen($string); if(!strncmp($string, "Location:", 9)) ( #keep ტრეკზე ბოლო გადამისამართება $location = trim(substr($string, 9, -1)); ) if(!strncmp($string, "Set-Cookie:", 11)) ( #get ქუქი $cookiestr = trim(substr( $string, 11, -1)); $cookie = აფეთქება (";", $cookiestr); $cookie = აფეთქდა ("=", $cookie); $cookiename = trim(array_shift($cookie)); $cookiearr [$cookiename] = trim(implode("=", $cookie)); ) $cookie = ""; if(trim($string) == "") ( #execut მხოლოდ სათაურის ბოლოში foreach ($cookiearr როგორც $key=>$value) ($cookie .= "$key=$value; "; ) curl_setopt ($ ch, CURLOPT_COOKIE, $cookie); ) დაბრუნება $length; ) curl_setopt ($ch, CURLOPT_HEADERFUNCTION, "წაკითხვის_სათაური"); ეს კოდი ვარაუდობს, რომ თქვენ ხელახლა გამოიყენებთ $ch-ს ყოველ ჯერზე მისი ინიციალიზაციის გარეშე (დასაწყისში დარეკეთ curl_init მხოლოდ ერთხელ). თუ დაგჭირდებათ $ch ხელახლა ინიციალიზაცია თქვენი კოდის ნებისმიერ წერტილში, შეგიძლიათ შეხვიდეთ ამჟამად შენახულ ქუქიებზე $cookiearr-ში და ჩართოთ ისინი ახალ $ch-ში. მე დავწერე ეს ფუნქცია მანამ, სანამ რეგულარულ გამონათქვამებთან საკმარის გამოცდილებას მქონოდა, ასე რომ თქვენ ვერ იპოვით preg_match ზარებს აქ. მე ამ კოდს ვიყენებდი საკმაოდ დიდი ხნის განმავლობაში და უპრობლემოდ შედიოდი gmail, yahoo, hotmail, aol და ა.შ. სადაც მომიწია. გაიარე შესვლა და რამდენიმე გვერდი, სანამ მივიდოდი იმას, რასაც ვეძებდი.
მაგალითი 8: სათაურის დატვირთვის დამმუშავებლის დაყენება CURL PHP-ის გამოყენებით
cURL-ის გამოყენებით, მე მჭირდებოდა მესამე მხარის სკრიპტის გამოძახება, რომელიც აბრუნებდა ორობით მონაცემებს დანართად, რათა მოძიებული მონაცემები კვლავ გადამეღო დანართად. პრობლემა ის იყო, რომ მესამე მხარის სკრიპტი დროდადრო აბრუნებდა HTTP შეცდომებს და მე მინდოდა ამ შემთხვევაში არ გადამეღო ნულოვანი სიგრძის დანართი. CURLOPT_FAILONERROR და CURLOPT_HEADERFUNCTION გამოძახების კომბინაცია დაეხმარა მესამე მხარის სკრიპტის HTTP შეცდომების სწორად დამუშავებას: ფუნქცია curlHeaderCallback($resURL, $strHeader) ( if (preg_match("/^HTTP/i", $strHeader($str) header("Content-Disposition: დანართი; ფაილის სახელი="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) ( დაბეჭდეთ "შეცდომა კოდით: " . $intReturnCode; )
მაგალითი 9. გვერდის ფაილში შენახვა და გადაცემის სიჩქარის გამოთვლა CURL PHP-ის გამოყენებით
WritePageToFile ("http://es.php.net", "es.php.net.txt"); ფუნქცია WritePageToFile ($sHTMLpage, $sTxtfile) ( $sh = curl_init ($sHTMLpage); $hFile = FOpen ($sTxtfile, "w"); curl_setopt ($sh, CURLOPT_FILE, $hFile); curl_setopt ($sh, CURLOPT_ 0); curl_exec ($sh); $sAverageSpeedDownload = curl_getInfo ($sh, CURLINFO_SPEED_DOWNLOAD); $sAverageSpeedUpload = curl_getInfo ($sh, CURLINFO_SPEED_UPLOAD); ექო " 
"; echo "ჩამოტვირთვის საშუალო სიჩქარე == " . $sAverageSpeedDownload. " 
"; echo "ატვირთვის საშუალო სიჩქარე == ". $sAverageSpeedUpload." 
"; ექო" 
"; $aCURLinfo = curl_getInfo ($sh); print_r ($aCURLinfo); echo "
"; curl_close ($sh); FClose ($hFile); echo "( იხილეთ ფაილი "".$sTxtfile."" ჰოსტინგის იმავე გზაზე." " სადაც ეს სკრიპტი PHP).
"; }
მაგალითი 9. გვერდის მიღება SSL კავშირის საშუალებით (https)
$ch=curl_init ("https://site"); curl_setopt($ch, CURLOPT_HEADER, 0); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // გამორთეთ შეცდომა "SSL სერტიფიკატის პრობლემა, შეამოწმეთ რომ CA სერთიფიკატი OK" curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0); // გამორთე შეცდომა "SSL: სერტიფიკატის საგნის სახელი "hostname.ru" არ ემთხვევა სამიზნე ჰოსტის სახელს "123.123"" 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: სესიებისა და ქუქიების გამოყენება curl-ში
$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);//მიღებული COOKIE-ების შენახვა ფაილში curl_setopt($curl, CURLOPT_COOKIEFILE, $cookie_filename); //გაუგზავნე სერვერს ავტორიზაციის დროს მისგან მიღებული COOKIE $out=curl_exec($curl);
მაგალითი 11: ფაილის ატვირთვა და მრავალგანზომილებიანი მასივი Curl-ში. CURLOPT_POSTFIELDS + CurlFile

თუ თქვენ გჭირდებათ მრავალგანზომილებიანი მასივის და ფაილის გაგზავნა POST მოთხოვნაში, თქვენ წააწყდებით გადაუჭრელ პრობლემას. თუ მრავალგანზომილებიან მასივს გადასცემთ CURLOPT_POSTFIELDS-ს, მეორე დონე გადაეცემა როგორც სტრიქონი "Array". თუ თქვენ გადაიყვანთ http_build_query-ის გამოყენებით, თქვენ ვერ შეძლებთ ფაილის გადატანას.

ქვემოთ მოცემულია ორგანზომილებიანი მასივის კოდირების ფუნქცია Curl-ისთვის ფაილის ჩატვირთვით, რომელიც იმუშავებს PHP 5.3, PHP 5.4 და PHP 5.6 ძველ ვერსიებში.

/** გარდაქმნის მრავალგანზომილებიან მასივს ერთგანზომილებიან მასივში რთული ინდექსების გამოყენებით და ანაცვლებს @ პრეფიქსით CurlFile-ით Curl-ში გამოსაყენებლად * @param $inputArray * @param string $inputKey * @return მასივი $requestVars = მასივი ("id" => მასივი( 1, 2,"id"=>1234), "name" => "log", "logfile" => "@/tmp/test.log"); ვიღებთ: ["id"]=> int(1) ["id"]=> int(2) ["id"]=> int(1234) ["name"]=> string(3) "log" [ "logfile"]=> string(13) "/tmp/test.log" ) */ ფუნქცია convertToStringArray($inputArray, $inputKey="") ( $resultArray=; foreach ($inputArray როგორც $key => $value ) ( $tmpKey = (bool)$inputKey ? $inputKey."[$key]" : $key; if (is_array($value)) ( $resultArray+=convertToStringArray($value, $tmpKey); ) elseif ($value = = "@")( $resultArray[$tmpKey] = (class_exists("CURLFile", false)) ? new CurlFile(ltrim($value, "@")) : $value; ) else ($resultArray[$tmpKey ] = $value; ) ) დააბრუნეთ $resultArray; ) // შეამოწმეთ $requestVars = array("id" => array(1, 2,"id"=>1234), "name" => "log", "logfile" " => "@/tmp/test.log"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, "საიტი"); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, convertToStringArray($requestVars)); $res = curl_exec ($ch); curl_close ($ch); Curl-ის გამოყენების აპლიკაციის მაგალითები



დაკავშირებული პუბლიკაციები