ฝึกฝนทักษะการดัดผมของคุณ CURL PHP: มันคืออะไรและใช้อย่างไร PHP curl รับตัวอย่างคำขอ

cURL เป็นเครื่องมือพิเศษสำหรับถ่ายโอนไฟล์และข้อมูลโดยใช้ไวยากรณ์ URL เทคโนโลยีนี้รองรับโปรโตคอลมากมาย เช่น HTTP, FTP, TELNET และอื่นๆ อีกมากมาย CURL ถูกออกแบบให้เป็นเครื่องมือบรรทัดคำสั่ง โชคดีสำหรับเรา ไลบรารี cURL ได้รับการสนับสนุนโดยภาษาการเขียนโปรแกรม PHP ในบทความนี้ เราจะพิจารณาคุณลักษณะขั้นสูงบางอย่างของ cURL และสัมผัสกับการใช้งานจริงของความรู้นี้โดยใช้เครื่องมือ PHP

ทำไมต้องขด?

จริงๆก็มีเยอะนะ ทางเลือกอื่นสุ่มตัวอย่างเนื้อหาของหน้าเว็บ ในหลายกรณี ส่วนใหญ่เนื่องจากความเกียจคร้าน ฉันได้ใช้ง่าย ฟังก์ชัน PHPแทน cURL:

$ content = file_get_contents ("http://www.nettuts.com"); // หรือ $ lines = file ("http://www.nettuts.com"); // หรือ readfile ("http://www.nettuts.com");

อย่างไรก็ตาม ฟังก์ชันเหล่านี้แทบไม่มีความยืดหยุ่นและมีข้อบกพร่องจำนวนมากในแง่ของการจัดการข้อผิดพลาด ฯลฯ นอกจากนี้ยังมีงานบางอย่างที่คุณไม่สามารถแก้ไขได้ด้วยฟังก์ชันมาตรฐานเหล่านี้: การโต้ตอบกับคุกกี้ การตรวจสอบสิทธิ์ การส่งแบบฟอร์ม การอัปโหลดไฟล์ ฯลฯ

cURL เป็นไลบรารีที่มีประสิทธิภาพซึ่งสนับสนุนโปรโตคอล ตัวเลือกต่างๆ และให้ข้อมูลโดยละเอียดเกี่ยวกับคำขอ URL

โครงสร้างพื้นฐาน

การเริ่มต้น
การกำหนดพารามิเตอร์
ดำเนินการและดึงผลลัพธ์
ปลดปล่อยหน่วยความจำ

// 1.การกำหนดค่าเริ่มต้น $ ch = curl_init (); // 2. ระบุพารามิเตอร์ รวมทั้ง url curl_setopt ($ ch, CURLOPT_URL, "http://www.nettuts.com"); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt ($ ch, CURLOPT_HEADER, 0); // 3. รับ HTML เป็นผลลัพธ์ $ output = curl_exec ($ ch); // 4. ปิดการเชื่อมต่อ curl_close ($ ch);

ขั้นตอนที่ # 2 (นั่นคือการเรียก curl_setopt ()) จะมีการกล่าวถึงในบทความนี้มากกว่าขั้นตอนอื่นๆ ทั้งหมด เนื่องจาก ในขั้นตอนนี้ สิ่งที่น่าสนใจและมีประโยชน์ที่สุดทั้งหมดที่คุณต้องรู้เกิดขึ้น cURL มีตัวเลือกต่างๆ มากมายที่ต้องระบุเพื่อให้สามารถกำหนดค่าคำขอ URL ได้อย่างระมัดระวังที่สุด เราจะไม่พิจารณารายการทั้งหมดโดยรวม แต่จะเน้นเฉพาะสิ่งที่ฉันคิดว่าจำเป็นและมีประโยชน์สำหรับบทเรียนนี้เท่านั้น คุณสามารถศึกษาส่วนที่เหลือเองได้หากหัวข้อนี้สนใจ

การตรวจสอบข้อผิดพลาด

นอกจากนี้ คุณยังสามารถใช้คำสั่งแบบมีเงื่อนไขเพื่อทดสอบความสำเร็จได้:

// ... $ เอาต์พุต = curl_exec ($ ch); if ($ output === FALSE) (echo "cURL Error:". curl_error ($ ch);) // ...

โปรดสังเกตจุดที่สำคัญมากสำหรับตัวคุณเอง: เราต้องใช้ “=== false” เพื่อเปรียบเทียบ แทนที่จะใช้ “== false” สำหรับผู้ที่ไม่ทราบ วิธีนี้จะช่วยให้เราแยกแยะผลลัพธ์ที่ว่างเปล่าจากค่าเท็จบูลีน ซึ่งจะบ่งบอกถึงข้อผิดพลาด

การรับข้อมูล

ขั้นตอนเพิ่มเติมอีกประการหนึ่งคือการรับข้อมูลคำขอ cURL หลังจากดำเนินการแล้ว

// ... curl_exec ($ ch); $ ข้อมูล = curl_getinfo ($ ch); เสียงสะท้อน "เอา". ข้อมูล $ ["total_time"] "วินาทีสำหรับ url" $ ข้อมูล ["url"]; // ...

อาร์เรย์ที่ส่งคืนมีข้อมูลต่อไปนี้:

"URL"
"ชนิดของเนื้อหา"
"Http_code"
"Header_size"
“คำขอ_ขนาด”
"ไฟล์ไทม์"
Ssl_verify_result
"Redirect_count"
"เวลารวม"
"Namelookup_time"
“Connect_time”
"Pretransfer_time"
"ขนาด_อัปโหลด"
Size_download
“Speed_download”
“Speed_upload”
"ดาวน์โหลด_content_length"
"Upload_content_length"
"เริ่มโอน_เวลา"
"เปลี่ยนเส้นทาง_เวลา"

การตรวจจับการเปลี่ยนเส้นทางตามเบราว์เซอร์

ในตัวอย่างนี้ เราจะเขียนโค้ดที่สามารถตรวจจับการเปลี่ยนเส้นทาง URL ตามการตั้งค่าเบราว์เซอร์ต่างๆ ตัวอย่างเช่น บางเว็บไซต์เปลี่ยนเส้นทางเบราว์เซอร์ของโทรศัพท์มือถือหรืออุปกรณ์อื่นๆ

เราจะใช้ตัวเลือก CURLOPT_HTTPHEADER เพื่อกำหนดส่วนหัว HTTP ขาออก ซึ่งรวมถึงชื่อเบราว์เซอร์ของผู้ใช้และภาษาที่ใช้ได้ ในที่สุด เราจะสามารถระบุได้ว่าไซต์ใดเปลี่ยนเส้นทางเราไปยัง URL ต่างๆ

// ทดสอบ URL $ urls = array ("http://www.cnn.com", "http://www.mozilla.com", "http://www.facebook.com"); // ทดสอบเบราว์เซอร์ $ browsers = array ("มาตรฐาน" => 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) "," ภาษา "=>" en-us, en; q = 0.5 ")," iphone "=> array (" user_agent "=>" Mozilla / 5.0 (iPhone; U ; CPU เช่น Mac OS X; en) AppleWebKit / 420 + (KHTML เช่น Gecko) เวอร์ชัน / 3.0 Mobile / 1A537a Safari / 419.3 "," ภาษา "=>" en ")," ฝรั่งเศส "=> array (" user_agent " => "Mozilla / 4.0 (เข้ากันได้; MSIE 7.0; Windows NT 5.1; GTB6; .NET CLR 2.0.50727)", "ภาษา" => "fr, fr-FR; q = 0.5")); foreach ($ urls เป็น $ url) (echo "URL: $ url \ n"; foreach ($ เบราว์เซอร์เป็น $ test_name => $ browser) ($ ch = curl_init (); // ระบุ url curl_setopt ($ ch, CURLOPT_URL, $ url); // ตั้งค่าส่วนหัวสำหรับเบราว์เซอร์ curl_setopt ($ ch, CURLOPT_HTTPHEADER, อาร์เรย์ ("User-Agent: ($ browser [" user_agent "])", "Accept-Language: ($ browser [" ภาษา "]) " )); // เราไม่ต้องการเนื้อหาหน้า curl_setopt ($ ch, CURLOPT_NOBODY, 1); // เราจำเป็นต้องได้รับส่วนหัว HTTP curl_setopt ($ ch, CURLOPT_HEADER, 1); // ส่งคืนผลลัพธ์แทนเอาต์พุต curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); $ output = curl_exec ($ ch); curl_close ($ ch); // มีการเปลี่ยนเส้นทาง HTTP หรือไม่ ถ้า (preg_match ("! Location: (. *)!", $ เอาต์พุต , $ ตรงกัน)) (echo " $ test_name: เปลี่ยนเส้นทางไปที่ $ ตรงกัน \ n ";) อื่น ๆ (echo" $ test_name: ไม่มีการเปลี่ยนเส้นทาง \ n ";)) echo" \ n \ n ";)

อันดับแรก เราจัดเตรียมรายการ URL ของไซต์ที่เราจะตรวจสอบ เราต้องการที่อยู่ของไซต์เหล่านี้อย่างแม่นยำยิ่งขึ้น ต่อไป เราต้องกำหนดการตั้งค่าเบราว์เซอร์เพื่อทดสอบแต่ละ URL เหล่านี้ หลังจากนั้นเราจะใช้การวนซ้ำซึ่งเราจะพูดถึงผลลัพธ์ทั้งหมดที่ได้รับ

เคล็ดลับที่เราใช้ในตัวอย่างนี้เพื่อตั้งค่า cURL จะช่วยให้เราไม่ได้รับเนื้อหาของหน้า แต่เฉพาะส่วนหัว HTTP (เก็บไว้ใน $ เอาต์พุต) ต่อไป โดยใช้ regex อย่างง่าย เราสามารถระบุได้ว่าบรรทัด "ตำแหน่ง:" มีอยู่ในส่วนหัวที่ได้รับหรือไม่

เมื่อคุณวิ่ง ให้รหัสคุณควรได้รับสิ่งต่อไปนี้:

การส่งคำขอ POST ไปยัง URL เฉพาะ

เมื่อสร้างคำขอ GET ข้อมูลที่ส่งสามารถถ่ายโอนไปยัง URL ผ่าน "สตริงการสืบค้น" ตัวอย่างเช่น เมื่อคุณทำการค้นหาโดย Google ข้อความค้นหาจะปรากฏในแถบที่อยู่ของ URL ใหม่:

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

เพื่อจำลอง ได้รับการร้องขอคุณไม่จำเป็นต้องใช้เครื่องมืออำนวยความสะดวก cURL หากความเกียจคร้านทำให้คุณหมดใจ ให้ใช้ฟังก์ชัน file_get_contents () เพื่อให้ได้ผลลัพธ์

แต่ประเด็นก็คือ แบบฟอร์ม HTML บางรูปแบบส่งคำขอ POST ข้อมูลของแบบฟอร์มเหล่านี้ถูกส่งผ่านเนื้อหาของคำขอ HTTP ไม่ใช่ในกรณีก่อนหน้า ตัวอย่างเช่น หากคุณกรอกแบบฟอร์มในฟอรัมและคลิกที่ปุ่มค้นหา เป็นไปได้มากว่าจะมีการร้องขอ POST:

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

เราเขียนได้ สคริปต์ PHPซึ่งสามารถเลียนแบบ URL คำขอประเภทนี้ได้ ขั้นแรก ให้สร้างไฟล์อย่างง่ายเพื่อยอมรับและแสดงข้อมูล POST เรียกมันว่า post_output.php:

Print_r ($ _ POST);

จากนั้นเราสร้างสคริปต์ PHP เพื่อดำเนินการตามคำขอ cURL:

$ url = "http: //localhost/post_output.php"; $ post_data = array ("foo" => "bar", "query" => "Nettuts", "action" => "Submit"); $ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); // ระบุว่าเรามีคำขอ POST curl_setopt ($ ch, CURLOPT_POST, 1); // เพิ่มตัวแปร curl_setopt ($ ch, CURLOPT_POSTFIELDS, $ post_data); $ เอาต์พุต = curl_exec ($ ch); curl_close ($ ch); ก้อง $ เอาท์พุท;

เมื่อคุณเรียกใช้สคริปต์นี้ คุณควรได้ผลลัพธ์ที่คล้ายกัน:

ดังนั้น คำขอ POST จึงถูกส่งไปยังสคริปต์ post_output.php ซึ่งจะสร้างอาร์เรย์ซูเปอร์โกลบอล $ _POST ซึ่งเป็นเนื้อหาที่เราดึงข้อมูลโดยใช้ cURL

อัปโหลดไฟล์

ขั้นแรก ให้สร้างไฟล์เพื่อสร้างและส่งไปที่ upload_output.php:

Print_r ($ _ ไฟล์);

และนี่คือรหัสสคริปต์ที่ทำหน้าที่ด้านบน:

$ url = "http: //localhost/upload_output.php"; $ post_data = array ("foo" => "bar", // ไฟล์ที่จะอัปโหลด "upload" => "@C: /wamp/www/test.zip"); $ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt ($ ch, CURLOPT_POST, 1); curl_setopt ($ ch, CURLOPT_POSTFIELDS, $ post_data); $ เอาต์พุต = curl_exec ($ ch); curl_close ($ ch); ก้อง $ เอาท์พุท;

เมื่อคุณต้องการอัปโหลดไฟล์ สิ่งที่คุณต้องทำคือส่งผ่านเป็นตัวแปรโพสต์ปกติ นำหน้าด้วยสัญลักษณ์ @ เมื่อคุณเรียกใช้สคริปต์ที่คุณเขียน คุณจะได้ผลลัพธ์ต่อไปนี้:

หลาย cURL

จุดแข็งที่ใหญ่ที่สุดอย่างหนึ่งของ cURL คือความสามารถในการสร้างตัวจัดการ cURL "หลายตัว" วิธีนี้ทำให้คุณสามารถเปิดการเชื่อมต่อกับ URL หลายรายการพร้อมกันและแบบอะซิงโครนัสได้

ในคำขอ cURL เวอร์ชันคลาสสิก การดำเนินการของสคริปต์จะหยุดชั่วคราว และรอการดำเนินการ URL คำขอให้เสร็จสิ้น หลังจากนั้นสคริปต์จะดำเนินการต่อได้ หากคุณต้องการโต้ตอบกับ URL จำนวนมาก จะใช้เวลาค่อนข้างนาน เนื่องจากในเวอร์ชันคลาสสิก คุณสามารถทำงานกับ URL ได้ครั้งละหนึ่งรายการเท่านั้น อย่างไรก็ตาม เราสามารถแก้ไขสถานการณ์นี้ได้โดยใช้ตัวจัดการพิเศษ

มาดูตัวอย่างโค้ดบางส่วนที่ฉันเอามาจาก php.net:

// สร้างทรัพยากร cURL $ ch1 = curl_init (); $ ch2 = curl_init (); // ระบุ URL และพารามิเตอร์อื่นๆ 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); $ ใช้งานอยู่ = null; // การดำเนินการทำ ($ mrc = curl_multi_exec ($ mh, $ active);) ในขณะที่ ($ mrc == CURLM_CALL_MULTI_PERFORM); ในขณะที่ ($ ใช้งาน && $ mrc == CURLM_OK) (ถ้า (curl_multi_select ($ mh)! = -1) (ทำ ($ mrc = curl_multi_exec ($ mh, $ ใช้งานอยู่);) ในขณะที่ ($ mrc == CURLM_CALL_MULTI_PERFORM);) ) // ปิด curl_multi_remove_handle ($ mh, $ ch1); curl_multi_remove_handle ($ mh, $ ch2); curl_multi_close ($ mh);

แนวคิดคือคุณสามารถใช้ตัวจัดการ cURL ได้หลายตัว เมื่อใช้การวนซ้ำแบบง่าย คุณสามารถติดตามว่าคำขอใดที่ยังไม่เสร็จสมบูรณ์

มีสองลูปหลักในตัวอย่างนี้ do-while loop แรกเรียกฟังก์ชัน curl_multi_exec () ฟังก์ชันนี้ไม่สามารถบล็อกได้ มันทำงานเร็วเท่าที่จะทำได้และส่งคืนสถานะของคำขอ ตราบใดที่ค่าที่ส่งคืนเป็นค่าคงที่ 'CURLM_CALL_MULTI_PERFORM' แสดงว่างานยังไม่เสร็จสิ้น (เช่น ใน ช่วงเวลานี้ส่วนหัว http จะถูกส่งไปยัง URL); นี่คือเหตุผลที่เราคอยตรวจสอบค่าที่ส่งคืนนี้จนกว่าเราจะได้ผลลัพธ์ที่ต่างออกไป

ในลูปถัดไป เราจะตรวจสอบเงื่อนไขในขณะที่ตัวแปร $ active = "true" เป็นพารามิเตอร์ที่สองของฟังก์ชัน curl_multi_exec () ค่าของตัวแปรนี้จะเป็น "จริง" ตราบใดที่การเปลี่ยนแปลงใดๆ ที่มีอยู่ยังทำงานอยู่ ต่อไป เราเรียกฟังก์ชัน curl_multi_select () การดำเนินการจะถูก "บล็อก" ตราบใดที่มีการเชื่อมต่อที่ใช้งานอยู่อย่างน้อยหนึ่งรายการ จนกว่าจะได้รับการตอบกลับ เมื่อสิ่งนี้เกิดขึ้น เราจะกลับไปที่ลูปหลักเพื่อดำเนินการค้นหาต่อไป

ทีนี้ มาลองใช้ความรู้ที่ได้รับจากตัวอย่างที่จะเป็นประโยชน์กับคนจำนวนมากกันจริง ๆ

การตรวจสอบลิงก์ใน WordPress

ลองนึกภาพบล็อกที่มีโพสต์และโพสต์จำนวนมาก ซึ่งแต่ละบล็อกมีลิงก์ไปยังแหล่งข้อมูลทางอินเทอร์เน็ตภายนอก ลิงก์เหล่านี้บางส่วนอาจ "ตาย" แล้วด้วยเหตุผลหลายประการ หน้าอาจถูกลบออกหรือไซต์อาจไม่ทำงานเลย

เราจะสร้างสคริปต์ที่จะวิเคราะห์ลิงก์ทั้งหมดและค้นหาเว็บไซต์ที่ไม่โหลดและหน้า 404 หน้า จากนั้นจึงจัดทำรายงานโดยละเอียด

ฉันต้องบอกทันทีว่านี่ไม่ใช่ตัวอย่างการสร้างปลั๊กอินสำหรับ WordPress นี่เป็นเพียงพื้นที่ทดสอบที่ดีสำหรับการทดสอบของเรา

มาเริ่มกันเลยดีกว่า อันดับแรก เราต้องดึงลิงค์ทั้งหมดจากฐานข้อมูล:

// การกำหนดค่า $ db_host = "localhost"; $ db_user = "รูท"; $ db_pass = ""; $ db_name = "เวิร์ดเพรส"; $cluded_domains = array ("localhost", "www.mydomain.com"); $ max_connections = 10; // เริ่มต้นตัวแปร $ url_list = array (); $ working_urls = อาร์เรย์ (); $ dead_urls = อาร์เรย์ (); $ not_found_urls = อาร์เรย์ (); $ ใช้งานอยู่ = null; // เชื่อมต่อกับ MySQL if (! 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) หรือตาย (mysql_error ()); ในขณะที่ ($ d = mysql_fetch_assoc ($ r)) (// ดึงลิงก์โดยใช้นิพจน์ทั่วไปหาก (preg_match_all ("! href = \" (. *?) \"!", $ d ["post_content"], $ ตรงกัน) ) (foreach ($ ตรงกับ $ url) ($ tmp = parse_url ($ url); if (in_array ($ tmp ["host"], $ excluded_domains)) (ต่อ;) $ url_list = $ url;)) ) / / ลบรายการที่ซ้ำกัน $ url_list = array_values (array_unique ($ url_list)); if (! $ url_list) (die ("ไม่มี URL ที่จะตรวจสอบ");)

ขั้นแรก เราสร้างข้อมูลการกำหนดค่าสำหรับการโต้ตอบกับฐานข้อมูล จากนั้นเราเขียนรายการโดเมนที่จะไม่เข้าร่วมในการตรวจสอบ ($excluded_domains) เรายังกำหนดตัวเลขที่กำหนดจำนวนการเชื่อมต่อพร้อมกันสูงสุดที่เราจะใช้ในสคริปต์ของเรา ($ max_connections) จากนั้นเราแนบไปกับฐานข้อมูล เลือกโพสต์ที่มีลิงก์ และจัดเก็บไว้ในอาร์เรย์ ($ url_list)

รหัสต่อไปนี้ค่อนข้างยุ่งยาก ดังนั้นควรทำความเข้าใจตั้งแต่ต้นจนจบ:

// 1.ตัวจัดการหลายตัว $ mh = curl_multi_init (); // 2. เพิ่มชุด URL สำหรับ ($ i = 0; $ i< $max_connections; $i++) { add_url_to_multi_handle($mh, $url_list); } // 3. инициализация выполнения do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); // 4. основной цикл while ($active && $mrc == CURLM_OK) { // 5. если всё прошло успешно if (curl_multi_select($mh) != -1) { // 6. делаем дело do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); // 7. если есть инфа? if ($mhinfo = curl_multi_info_read($mh)) { // это значит, что запрос завершился // 8. извлекаем инфу $chinfo = curl_getinfo($mhinfo["handle"]); // 9. мёртвая ссылка? if (!$chinfo["http_code"]) { $dead_urls = $chinfo["url"]; // 10. 404? } else if ($chinfo["http_code"] == 404) { $not_found_urls = $chinfo["url"]; // 11. рабочая } else { $working_urls = $chinfo["url"]; } // 12. чистим за собой curl_multi_remove_handle($mh, $mhinfo["handle"]); // в случае зацикливания, закомментируйте данный вызов curl_close($mhinfo["handle"]); // 13. добавляем новый url и продолжаем работу if (add_url_to_multi_handle($mh, $url_list)) { do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); } } } } // 14. завершение curl_multi_close($mh); echo "==Dead URLs==\n"; echo implode("\n",$dead_urls) . "\n\n"; echo "==404 URLs==\n"; echo implode("\n",$not_found_urls) . "\n\n"; echo "==Working URLs==\n"; echo implode("\n",$working_urls); function add_url_to_multi_handle($mh, $url_list) { static $index = 0; // если у нас есть ещё url, которые нужно достать if ($url_list[$index]) { // новый curl обработчик $ch = curl_init(); // указываем url curl_setopt($ch, CURLOPT_URL, $url_list[$index]); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); curl_setopt($ch, CURLOPT_NOBODY, 1); curl_multi_add_handle($mh, $ch); // переходим на следующий url $index++; return true; } else { // добавление новых URL завершено return false; } }

ที่นี่ฉันจะพยายามวางทุกอย่างไว้บนชั้นวาง ตัวเลขในรายการตรงกับตัวเลขในความคิดเห็น

1. สร้างตัวจัดการหลายตัว
2. เราจะเขียนฟังก์ชัน add_url_to_multi_handle () ในภายหลัง ทุกครั้งที่มีการเรียก จะเริ่มประมวลผล URL ใหม่ เริ่มแรก เราเพิ่ม URL 10 ($ max_connections)
3. ในการเริ่มต้น เราต้องเรียกใช้ฟังก์ชัน curl_multi_exec () ตราบใดที่ส่งคืน CURLM_CALL_MULTI_PERFORM เราก็ยังมีอีกมากที่ต้องทำ เราต้องการสิ่งนี้เป็นหลักเพื่อสร้างการเชื่อมต่อ
4. ถัดมาคือลูปหลัก ซึ่งจะทำงานตราบเท่าที่เรามีการเชื่อมต่อที่ใช้งานอยู่อย่างน้อยหนึ่งรายการ
5. curl_multi_select () ค้างเพื่อรอให้การค้นหา URL เสร็จสิ้น
6. อีกครั้ง เราต้องทำให้ cURL ทำงาน กล่าวคือดึงข้อมูลของการตอบกลับที่ส่งคืน
7. นี่คือที่ตรวจสอบข้อมูล อันเป็นผลมาจากการดำเนินการตามคำขอ อาร์เรย์จะถูกส่งคืน
8. อาร์เรย์ที่ส่งคืนมีตัวจัดการ cURL เราจะใช้เพื่อดึงข้อมูลเกี่ยวกับคำขอ cURL แต่ละรายการ
9. หากลิงก์ตายหรือหมดเวลาการเรียกใช้สคริปต์ เราก็ไม่ควรมองหาโค้ด http ใดๆ
10. หากลิงก์ส่งคืนหน้า 404 ให้เรา โค้ด http จะมีค่า 404
11. มิฉะนั้น เรามีลิงค์ที่ใช้งานได้อยู่ข้างหน้าเรา (คุณสามารถเพิ่มการตรวจสอบเพิ่มเติมสำหรับรหัสข้อผิดพลาด 500 ฯลฯ ... );
12. ต่อไป เราลบตัวจัดการ cURL เนื่องจากเราไม่ต้องการมันอีกต่อไป
13. ตอนนี้เราสามารถเพิ่ม url อื่นและเรียกใช้ทุกสิ่งที่เราพูดถึงก่อนหน้านี้
14. ในขั้นตอนนี้ สคริปต์จะเสร็จสิ้นการทำงาน เราสามารถลบทุกอย่างที่เราไม่ต้องการและสร้างรายงาน
15. สุดท้าย เราจะเขียนฟังก์ชันที่จะเพิ่ม url ให้กับตัวจัดการ ตัวแปรคงที่ $ ดัชนีจะเพิ่มขึ้นทุกครั้งที่เรียกใช้ฟังก์ชันนี้

ฉันใช้สคริปต์นี้ในบล็อกของฉัน (โดยมีลิงก์เสียที่ฉันเพิ่มโดยตั้งใจเพื่อทดสอบ) และได้ผลลัพธ์ดังต่อไปนี้:

ในกรณีของฉัน สคริปต์ใช้เวลาน้อยกว่า 2 วินาทีเล็กน้อยในการเข้าถึง 40 URL ประสิทธิภาพที่เพิ่มขึ้นมีความสำคัญเมื่อต้องจัดการกับ URL ที่มากขึ้น หากคุณเปิดการเชื่อมต่อสิบครั้งพร้อมกัน สคริปต์จะทำงานเร็วขึ้นสิบเท่า

คำสองสามคำเกี่ยวกับตัวเลือก cURL ที่มีประโยชน์อื่นๆ

การตรวจสอบสิทธิ์ HTTP

หาก URL มีการตรวจสอบสิทธิ์ 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); $ เอาต์พุต = curl_exec ($ ch); curl_close ($ ch);

อัพโหลด FTP

PHP ยังมีไลบรารี่สำหรับการทำงานกับ FTP แต่ไม่มีอะไรป้องกันคุณจากการใช้เครื่องมือ cURL:

// เปิดไฟล์ $ file = fopen ("/ path / to / file", "r"); // url ควรมีเนื้อหาต่อไปนี้ $ url = "ftp: // username: [ป้องกันอีเมล]: 21 / เส้นทาง / ถึง / ใหม่ / ไฟล์ "; $ 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, ขนาดไฟล์ ("/ เส้นทาง / ถึง / ไฟล์")); // ระบุ ASCII mod curl_setopt ($ ch, CURLOPT_FTPASCII, 1); $ curl output = curl ( $ ch); curl_close ($ ch);

การใช้พร็อกซี่

คุณสามารถดำเนินการคำขอ url ของคุณผ่านพร็อกซี:

$ 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"); $ เอาต์พุต = curl_exec ($ ch); curl_close ($ ch);

ฟังก์ชั่นการโทรกลับ

นอกจากนี้ยังสามารถระบุฟังก์ชันที่จะทริกเกอร์ได้ก่อนที่คำขอ cURL จะเสร็จสิ้น ตัวอย่างเช่น ในขณะที่กำลังโหลดเนื้อหาของการตอบกลับ คุณสามารถเริ่มใช้ข้อมูลโดยไม่ต้องรอให้โหลดจนเต็ม

$ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, "http://net.tutsplus.com"); curl_setopt ($ ch, CURLOPT_WRITEFUNCTION, "progress_function"); curl_exec ($ ch); curl_close ($ ch); ฟังก์ชัน progress_function ($ ch, $ str) (echo $ str; return strlen ($ str);)

ฟังก์ชันเช่นนี้ต้องส่งคืนความยาวของสตริง ซึ่งจำเป็น

บทสรุป

วันนี้เราได้ทำความคุ้นเคยกับวิธีการใช้ห้องสมุด cURL เพื่อจุดประสงค์ที่เห็นแก่ตัวของคุณเอง ฉันหวังว่าคุณจะสนุกกับบทความนี้

ขอบคุณ! ขอให้เป็นวันที่ดี!

บทความนี้อนุมานว่าคุณคุ้นเคยกับพื้นฐานของเครือข่ายและ HTML

การเขียนสคริปต์เป็นสิ่งสำคัญในการสร้างระบบคอมพิวเตอร์ที่ดี ความสามารถในการขยายของระบบ Unix ที่มีเชลล์สคริปต์และโปรแกรมต่างๆ ที่รันคำสั่งอัตโนมัติเป็นหนึ่งในสาเหตุที่ทำให้ประสบความสำเร็จ

จำนวนแอปพลิเคชันที่ย้ายไปยังเว็บที่เพิ่มขึ้นทำให้หัวข้อของสคริปต์ HTTP เป็นที่ต้องการมากขึ้นเรื่อยๆ งานสำคัญในพื้นที่นี้คือดึงข้อมูลจากอินเทอร์เน็ตโดยอัตโนมัติ การส่งหรือดาวน์โหลดข้อมูลไปยังเว็บเซิร์ฟเวอร์ ฯลฯ

Curl เป็นเครื่องมือบรรทัดคำสั่งที่ให้คุณจัดการและโอน URL ได้ทุกประเภท บทความนี้เน้นที่การสร้างคำขอ HTTP อย่างง่าย ถือว่าคุณรู้แล้วว่าต้องพิมพ์ที่ไหน

# curl --help

# curl --manual

สำหรับข้อมูลเกี่ยวกับ curl

Curl ไม่ใช่เครื่องมือที่จะทำทุกอย่างเพื่อคุณ สร้างคำขอ รับข้อมูล และส่งข้อมูล คุณอาจต้องการกาวบางชนิดในการรวมทุกอย่างเข้าด้วยกัน บางทีอาจเป็นภาษาสคริปต์ (เช่น bash) หรือการเรียกใช้ด้วยตนเองเล็กน้อย

1. โปรโตคอล HTTP

HTTP เป็นโปรโตคอลที่ใช้เมื่อรับข้อมูลจากเว็บเซิร์ฟเวอร์ เป็นโปรโตคอลที่ง่ายมากที่สร้างขึ้นบน TCP / IP โปรโตคอลยังอนุญาตให้ส่งข้อมูลไปยังเซิร์ฟเวอร์จากไคลเอนต์โดยใช้วิธีการต่างๆ ดังที่แสดงด้านล่าง

HTTP คือสตริงของข้อความ ASCII ที่ส่งจากไคลเอนต์ไปยังเซิร์ฟเวอร์เพื่อร้องขอการดำเนินการ เมื่อได้รับคำขอ เซิร์ฟเวอร์จะตอบกลับลูกค้าด้วยบรรทัดข้อความบริการหลายบรรทัด และตามด้วยเนื้อหาจริง

ด้วยการใช้สวิตช์ curl -v คุณสามารถดูคำสั่งที่ curl ส่งไปยังเซิร์ฟเวอร์ รวมถึงข้อความแสดงข้อมูลอื่นๆ สวิตช์ -v อาจเป็นวิธีเดียวที่จะดีบักหรือทำความเข้าใจการโต้ตอบระหว่าง curl และเว็บเซิร์ฟเวอร์

2. URL

รูปแบบ Uniform Resource Locator (URL) ระบุที่อยู่ของทรัพยากรเฉพาะบนอินเทอร์เน็ต คุณอาจทราบสิ่งนี้แล้ว ตัวอย่างเช่น URL: http://curl.haxx.se หรือ https://yourbank.com

3. รับ (GET) หน้า

คำขอ HTTP ที่ง่ายและธรรมดาที่สุดคือการรับเนื้อหาของ URL URL สามารถเชื่อมโยงไปยังหน้าเว็บ รูปภาพ หรือไฟล์ ลูกค้าส่งคำขอ GET ไปยังเซิร์ฟเวอร์และรับเอกสารที่ร้องขอ หากคุณเรียกใช้คำสั่ง

# curl http://curl.haxx.se

คุณจะได้รับหน้าเว็บที่แสดงในหน้าต่างเทอร์มินัลของคุณ เอกสาร HTML ฉบับสมบูรณ์ที่อยู่ใน URL นี้

การตอบสนอง HTTP ทั้งหมดมีชุดของส่วนหัวที่มักจะซ่อนอยู่ หากต้องการดูพร้อมกับเอกสาร ให้ใช้สวิตช์ curl -i คุณยังสามารถขอเฉพาะส่วนหัวด้วยสวิตช์ -I (ซึ่งจะทำให้ curl ทำการร้องขอ HEAD)

4. แบบฟอร์ม

แบบฟอร์มเป็นวิธีหลักในการนำเสนอเว็บไซต์เป็นหน้า HTML พร้อมฟิลด์ที่ผู้ใช้ป้อนข้อมูลแล้วคลิกปุ่ม "ตกลง" หรือ "ส่ง" หลังจากนั้นข้อมูลจะถูกส่งไปยังเซิร์ฟเวอร์ จากนั้นเซิร์ฟเวอร์จะใช้ข้อมูลที่ได้รับและตัดสินใจว่าจะดำเนินการอย่างไร: ค้นหาข้อมูลในฐานข้อมูล แสดงที่อยู่ที่ป้อนบนแผนที่ เพิ่มข้อความแสดงข้อผิดพลาด หรือใช้ข้อมูลเพื่อตรวจสอบสิทธิ์ผู้ใช้ แน่นอน มีบางโปรแกรมที่ฝั่งเซิร์ฟเวอร์ที่ยอมรับข้อมูลของคุณ

4.1 รับ

แบบฟอร์ม GET ใช้ GET วิธี, เช่นดังต่อไปนี้:

หากคุณเปิดรหัสนี้ในเบราว์เซอร์ คุณจะเห็นแบบฟอร์มพร้อมกล่องข้อความและปุ่มที่ระบุว่า "ตกลง" หากคุณป้อน "1905" และคลิกตกลง เบราว์เซอร์จะสร้าง URL ใหม่ให้ติดตาม URL จะแสดงเป็นสตริงที่ประกอบด้วยเส้นทางของ URL ก่อนหน้าและสตริงเช่น "junk.cgi? Birthyear = 1905 & press = OK"

ตัวอย่างเช่น หากแบบฟอร์มอยู่ที่ "www.hotmail.com/when/birth.html" การคลิกตกลงจะนำคุณไปยัง URL "www.hotmail.com/ when/junk.cgi?birthyear=1905&press=OK " ...

ข้างมาก เครื่องมือค้นหาทำงานแบบนั้น

หากต้องการสร้าง curl ให้เป็นคำขอ GET เพียงป้อนสิ่งที่คาดหวังจากแบบฟอร์ม:

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

4.2 โพสต์

วิธี GET ทำให้ข้อมูลที่ป้อนทั้งหมดแสดงในแถบที่อยู่ของเบราว์เซอร์ของคุณ การดำเนินการนี้อาจใช้ได้เมื่อคุณต้องการบุ๊กมาร์กหน้า แต่จะเป็นข้อเสียที่ชัดเจนเมื่อคุณป้อนข้อมูลที่สำคัญลงในช่องแบบฟอร์ม หรือเมื่อปริมาณข้อมูลที่ป้อนลงในช่องมีขนาดใหญ่เกินไป (ส่งผลให้ URL อ่านไม่ได้)

โปรโตคอล HTTP มีวิธีการ POST ด้วยวิธีนี้ ลูกค้าจะส่งข้อมูลแยกต่างหากจาก URL ดังนั้นคุณจะไม่เห็นข้อมูลดังกล่าวในแถบที่อยู่

แบบฟอร์มที่สร้างคำขอ POST จะคล้ายกับแบบฟอร์มก่อนหน้า:

Curl สามารถสร้างคำขอ POST ด้วยข้อมูลเดียวกันดังนี้:

# curl -d "ปีเกิด = 1905 & กด =% 20OK% 20" www.hotmail.com/ when/junk.cgi

คำขอ POST นี้ใช้ "แอปพลิเคชันประเภทเนื้อหา / x-www-form-urlencoded" ซึ่งเป็นวิธีการที่ใช้กันอย่างแพร่หลายมากที่สุด

ข้อมูลที่คุณส่งไปยังเซิร์ฟเวอร์ต้องเข้ารหัสอย่างถูกต้อง curl จะไม่ทำเพื่อคุณ ตัวอย่างเช่น หากคุณต้องการให้ข้อมูลของคุณมีช่องว่าง คุณต้องแทนที่พื้นที่นั้นด้วย% 20 เป็นต้น การไม่สนใจปัญหานี้เป็นข้อผิดพลาดทั่วไป เนื่องจากข้อมูลไม่ถูกถ่ายโอนอย่างที่ควรจะเป็น

ย้อนกลับไปในปี 1995 มีการกำหนดวิธีเพิ่มเติมในการถ่ายโอนข้อมูลผ่าน HTTP มีการบันทึกไว้ใน RFC 1867 ซึ่งเป็นสาเหตุที่บางครั้งเรียกว่าการโพสต์ RFC1867

วิธีนี้ได้รับการออกแบบมาเพื่อรองรับการอัปโหลดไฟล์ได้ดีขึ้น แบบฟอร์มที่อนุญาตให้ผู้ใช้อัปโหลดไฟล์มีลักษณะดังนี้ใน HTML:

โปรดทราบว่า Content-Type ถูกตั้งค่าเป็น multipart / form-data

ในการส่งข้อมูลไปยังแบบฟอร์มโดยใช้ curl ให้ป้อนคำสั่ง:

# curl -F [ป้องกันอีเมล]-F กด = OK

4.4 ช่องที่ซ่อนอยู่

วิธีทั่วไปในการสื่อสารข้อมูลสถานะในแอปพลิเคชัน HTML คือการใช้ฟิลด์ที่ซ่อนอยู่ในแบบฟอร์ม ฟิลด์ที่ซ่อนอยู่จะไม่ถูกเติม ฟิลด์เหล่านี้จะไม่ปรากฏแก่ผู้ใช้ และส่งผ่านในลักษณะเดียวกับฟิลด์ปกติ

ตัวอย่างง่ายๆ ของแบบฟอร์มที่มีหนึ่งฟิลด์ที่มองเห็นได้ หนึ่งฟิลด์ที่ซ่อนอยู่ และปุ่ม OK:

ในการส่งคำขอ POST โดยใช้ curl คุณไม่ต้องคิดว่าฟิลด์นั้นถูกซ่อนหรือไม่ สำหรับ curl จะเหมือนกันทั้งหมด:

# curl -d "ปีเกิด = 1905 & กด = ตกลง & คน = daniel"

4.5 ค้นหาว่าคำขอ POST เป็นอย่างไร

เมื่อคุณต้องการกรอกแบบฟอร์มและส่งข้อมูลไปยังเซิร์ฟเวอร์โดยใช้ curl คุณอาจต้องการให้คำขอ POST มีลักษณะเหมือนกับคำขอที่ดำเนินการโดยใช้เบราว์เซอร์

วิธีง่ายๆ ในการดูคำขอ POST ของคุณคือบันทึกหน้า HTML ด้วยแบบฟอร์มลงในดิสก์ เปลี่ยนวิธีการเป็น GET แล้วคลิกปุ่มส่ง (คุณยังสามารถเปลี่ยน URL ที่จะส่งข้อมูลได้)

คุณจะเห็นข้อมูลต่อท้าย URL คั่นด้วยอักขระ "?" ตามที่คาดไว้เมื่อใช้แบบฟอร์ม GET

5. วาง

บางที, วิธีที่ดีที่สุดในการอัปโหลดข้อมูลไปยังเซิร์ฟเวอร์ HTTP ให้ใช้ PUT อีกครั้ง สิ่งนี้ต้องการโปรแกรม (สคริปต์) ที่ส่วนหลังที่รู้ว่าต้องทำอะไรและจะรับสตรีม HTTP PUT ได้อย่างไร

ส่งไฟล์ไปยังเซิร์ฟเวอร์โดยใช้ curl:

# curl -T ไฟล์อัพโหลด www.uploadhttp.com/receive.cgi

6. การตรวจสอบสิทธิ์

การตรวจสอบสิทธิ์ - ส่งชื่อผู้ใช้และรหัสผ่านไปยังเซิร์ฟเวอร์ จากนั้นจะตรวจสอบว่าคุณมีสิทธิ์ส่งคำขอที่ร้องขอหรือไม่ การตรวจสอบสิทธิ์ขั้นพื้นฐาน (ซึ่ง curl ใช้เป็นค่าเริ่มต้น) เป็นข้อความที่ชัดเจน ซึ่งหมายความว่าชื่อผู้ใช้และรหัสผ่านจะไม่ถูกเข้ารหัส แต่ Base64 จะปิดบังเพียงเล็กน้อยเท่านั้น ซึ่งทำให้ผู้โจมตีเปิดกว้างระหว่างคุณกับเซิร์ฟเวอร์ HTTP

การบอก curl ให้ใช้ชื่อผู้ใช้และรหัสผ่าน:

# curl -u ชื่อ: รหัสผ่าน www.secrets.com

ไซต์อาจต้องใช้วิธีการตรวจสอบสิทธิ์แบบอื่น (ดูว่าเซิร์ฟเวอร์เขียนอะไรในส่วนหัว) ในกรณีเหล่านี้ คุณสามารถใช้คีย์ --ntlm, --digest, --negotiate หรือแม้แต่ --anyauth บางครั้งการเข้าถึงเซิร์ฟเวอร์ HTTP ภายนอกนั้นผ่านพร็อกซี ซึ่งมักจะทำในบริษัทและบริษัท พร็อกซี HTTP อาจต้องใช้ชื่อผู้ใช้และรหัสผ่านของตนเองเพื่อเข้าถึงอินเทอร์เน็ต คีย์ curl ที่สอดคล้องกัน:

# curl -U proxyuser: proxypassword curl.haxx.se

หากพร็อกซีต้องการการพิสูจน์ตัวตน NTLM ให้ระบุ --proxy-ntlm หากเป็นเมธอด Digest ให้ระบุ --proxy-digest

หากคุณไม่ได้ระบุรหัสผ่านในสวิตช์ -u และ -U curl จะถามคุณแบบโต้ตอบ

โปรดทราบว่าเมื่อเรียกใช้ curl บรรทัดเริ่มต้น (พร้อมกับคีย์และรหัสผ่าน) อาจปรากฏแก่ผู้ใช้รายอื่นในระบบของคุณในรายการงาน มีวิธีป้องกันสิ่งนี้ เพิ่มเติมเกี่ยวกับเรื่องนี้ด้านล่าง

7. ผู้อ้างอิง

คำขอ HTTP อาจมีฟิลด์ "ผู้อ้างอิง" ที่ระบุ URL ที่ผู้ใช้มาที่ทรัพยากรนี้ โปรแกรม / สคริปต์บางโปรแกรมตรวจสอบช่อง "ผู้อ้างอิง" และไม่ดำเนินการตามคำขอหากผู้ใช้มาจากหน้าที่ไม่รู้จัก แม้ว่านี่จะเป็นวิธีการตรวจสอบที่งี่เง่า แต่ก็มีสคริปต์จำนวนมากที่ใช้มัน ด้วย curl คุณสามารถใส่อะไรก็ได้ในช่อง "ผู้อ้างอิง" และทำให้มันทำในสิ่งที่คุณต้องการให้ทำ

สิ่งนี้ทำได้ดังนี้:

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

8. ตัวแทนผู้ใช้

คำขอ HTTP ทั้งหมดรองรับช่อง "ตัวแทนผู้ใช้" ซึ่งระบุแอปพลิเคชันไคลเอนต์ของผู้ใช้ เว็บแอปพลิเคชันจำนวนมากใช้ข้อมูลนี้เพื่อแสดงหน้าเว็บไม่ทางใดก็ทางหนึ่ง โปรแกรมเมอร์เว็บสร้างหน้าเว็บหลายเวอร์ชันสำหรับผู้ใช้เบราว์เซอร์ต่างๆ เพื่อปรับปรุง รูปร่างโดยใช้สคริปต์ต่างๆ เช่น javascript, vbscript เป็นต้น

บางครั้งคุณอาจพบว่า curl กำลังส่งคืนหน้าที่แตกต่างจากที่คุณเห็นในเบราว์เซอร์ของคุณ ในกรณีนี้ เป็นการเหมาะสมที่จะใช้ฟิลด์ "ตัวแทนผู้ใช้" เพื่อหลอกลวงเซิร์ฟเวอร์อีกครั้ง

ปลอมตัวเป็นขด Internet Explorerบนเครื่อง Windows 2000:

# curl -A "Mozilla / 4.0 (เข้ากันได้; MSIE 5.01; Windows NT 5.0)"

ทำไมไม่เป็น Netscape 4.73 บนกล่อง Linux (PIII):

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

9. เปลี่ยนเส้นทาง

ในการตอบสนองต่อคำขอของคุณ เซิร์ฟเวอร์แทนที่จะแสดงหน้าเพจเอง สามารถแสดงตำแหน่งที่เบราว์เซอร์ควรไปถัดจากหน้าที่ต้องการ ส่วนหัวที่บอกเบราว์เซอร์ว่าการเปลี่ยนเส้นทางนี้คือ "ตำแหน่ง:"

ตามค่าเริ่มต้น curl จะไม่ไปที่ตำแหน่งที่ระบุใน "Location:" แต่จะแสดงหน้าตามปกติ แต่คุณสามารถกำกับได้ดังนี้:

# curl -L www.sitethatredirects.com

หากคุณกำลังใช้ curl สำหรับคำขอ POST ไปยังไซต์ที่เปลี่ยนเส้นทางไปยังหน้าอื่นทันที คุณสามารถใช้ชุดค่าผสม -L และ -d / -F ได้อย่างปลอดภัย Curl จะสร้างคำขอ POST สำหรับหน้าแรก แล้วจึงขอ GET สำหรับหน้าถัดไป

10. คุกกี้

ด้วยคุกกี้ เว็บเบราว์เซอร์จะควบคุมสถานะฝั่งไคลเอ็นต์ คุกกี้เป็นชื่อที่มีเนื้อหาที่แนบมา เซิร์ฟเวอร์ส่งคุกกี้บอกลูกค้าถึงเส้นทางและชื่อโฮสต์ที่ควรส่งคุกกี้ในครั้งต่อไป บอกอายุการใช้งานคุกกี้และพารามิเตอร์อื่น ๆ

เมื่อไคลเอนต์เชื่อมต่อกับเซิร์ฟเวอร์ตามที่อยู่ที่ระบุในคุกกี้ที่ยอมรับ ไคลเอนต์จะส่งคุกกี้นั้นไปยังเซิร์ฟเวอร์ (เว้นแต่อายุการใช้งานจะหมดอายุ)

แอปพลิเคชันและเซิร์ฟเวอร์จำนวนมากใช้เทคนิคนี้เพื่อรวมคำขอหลายรายการไว้ในเซสชันเดียว เพื่อให้ curl ใช้งานฟังก์ชันนี้ได้ เราต้องสามารถบันทึกและส่งคุกกี้ได้ เช่นเดียวกับเบราว์เซอร์

วิธีที่ง่ายที่สุดในการส่งคุกกี้ไปยังเซิร์ฟเวอร์เมื่อได้รับหน้าโดยใช้ curl คือการเพิ่มสวิตช์ที่เหมาะสมบนบรรทัดคำสั่ง:

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

คุกกี้จะถูกส่งเป็นส่วนหัว HTTP ปกติ ซึ่งช่วยให้ curl บันทึกคุกกี้ในขณะที่รักษาส่วนหัวไว้ การบันทึกคุกกี้โดยใช้ curl ทำได้โดยใช้คำสั่ง:

# curl -D headers_and_cookies www.cookiesite.com

(อีกอย่าง หากต้องการบันทึกคุกกี้ ควรใช้สวิตช์ -c ดูรายละเอียดเพิ่มเติมด้านล่าง)

Curl มีตัวจัดการคุกกี้ที่ทำงานได้อย่างสมบูรณ์ ซึ่งมีประโยชน์เมื่อคุณต้องการเชื่อมต่อกับเซิร์ฟเวอร์อีกครั้งและใช้คุกกี้ที่บันทึกไว้ในครั้งล่าสุด (หรือทำงานด้วยตนเอง) ในการใช้คุกกี้ที่จัดเก็บไว้ในไฟล์ ให้เรียก curl ดังนี้:

# curl -b stores_cookies_in_file www.cookiesite.com

กลไกจัดการคุกกี้ curl ถูกเปิดใช้งานเมื่อคุณระบุสวิตช์ -b หากคุณต้องการให้ curl ยอมรับเฉพาะคุกกี้ ให้ใช้ -b กับไฟล์ที่ไม่มีอยู่ ตัวอย่างเช่น หากคุณต้องการให้ curl ยอมรับคุกกี้จากหน้าเว็บแล้วทำตามการเปลี่ยนเส้นทาง (อาจโดยการส่งคืนคุกกี้ที่คุณเพิ่งยอมรับ) คุณสามารถเรียก curl ดังนี้:

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

Curl สามารถอ่านและเขียนคุกกี้ Netscape และ Mozilla เป็นวิธีที่สะดวกในการแลกเปลี่ยนคุกกี้ระหว่างเบราว์เซอร์และสคริปต์อัตโนมัติ สวิตช์ -b จะตรวจจับโดยอัตโนมัติว่า ไฟล์นี้คุกกี้ของเบราว์เซอร์ที่ระบุและจัดการอย่างเหมาะสม และด้วยการใช้สวิตช์ -c / - cookie-jar คุณสามารถบังคับให้ curl เขียนคุกกี้ใหม่เมื่อการดำเนินการเสร็จสิ้น:

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

11. HTTPS

มีหลายวิธีในการรักษาความปลอดภัยการถ่ายโอน HTTP ของคุณ โปรโตคอลที่เป็นที่รู้จักมากที่สุดสำหรับงานนี้คือ HTTPS หรือ HTTP ผ่าน SSL SSL เข้ารหัสข้อมูลทั้งหมดที่ส่งและรับผ่านเครือข่าย ซึ่งเพิ่มโอกาสที่ข้อมูลของคุณจะถูกเก็บเป็นความลับ

Curl รองรับคำขอไปยังเซิร์ฟเวอร์ HTTPS ด้วยไลบรารี OpenSSL ฟรี คำขอเกิดขึ้น ตามปกติ:

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

11.1 ใบรับรอง

ในโลก HTTPS คุณใช้ใบรับรองนอกเหนือจากชื่อผู้ใช้และรหัสผ่านสำหรับการตรวจสอบสิทธิ์ Curl รองรับใบรับรองฝั่งไคลเอ็นต์ ใบรับรองทั้งหมดถูกล็อคด้วยข้อความรหัสผ่านที่คุณต้องป้อนก่อนที่ curl จะสามารถเริ่มทำงานได้ สามารถระบุข้อความรหัสผ่านบนบรรทัดคำสั่งหรือป้อนแบบโต้ตอบได้ Curl ใช้ใบรับรองเช่นนี้:

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

Curl ยังตรวจสอบข้อมูลประจำตัวของเซิร์ฟเวอร์ด้วยการตรวจสอบใบรับรองของเซิร์ฟเวอร์กับใบรับรองที่จัดเก็บไว้ในเครื่อง หากพบว่าไม่ตรงกัน curl จะปฏิเสธที่จะเชื่อมต่อ หากต้องการละเว้นการรับรองความถูกต้อง ให้ใช้สวิตช์ -k

มากกว่า รายละเอียดข้อมูลเกี่ยวกับใบรับรองสามารถพบได้ที่ http://curl.haxx.se/docs/sslcerts.html

12. ส่วนหัวคำขอโดยพลการ

คุณอาจต้องแก้ไขหรือเพิ่มองค์ประกอบของคำขอ curl แต่ละรายการ

ตัวอย่างเช่น คุณสามารถเปลี่ยนคำขอ POST เป็น PROPFIND และส่งข้อมูลเป็น "Content-Type: text / xml" (แทนที่จะเป็น Content-Type ปกติ):

# curl -d " "-H" ประเภทเนื้อหา: text / xml "-X PROPFIND url.com

คุณสามารถนำส่วนหัวออกได้โดยการระบุโดยไม่มีเนื้อหา ตัวอย่างเช่น คุณสามารถลบส่วนหัว "โฮสต์:" ซึ่งจะทำให้คำขอ "ว่างเปล่า":

# curl -H "โฮสต์:" http://mysite.com

นอกจากนี้ คุณสามารถเพิ่มชื่อเรื่อง เซิร์ฟเวอร์ของคุณอาจต้องการส่วนหัว "ปลายทาง:":

# curl -H "ปลายทาง: http://moo.com/nowhere" http://url.com

13. การดีบัก

บ่อยครั้งที่ไซต์ตอบสนองต่อคำขอ curl แตกต่างจากคำขอของเบราว์เซอร์ ในกรณีนี้ คุณต้องทำให้เบราว์เซอร์ดูเหมือน curl มากที่สุด:

ใช้สวิตช์ --trace-ascii เพื่อบันทึกรายงานโดยละเอียดของคำขอ เพื่อให้คุณสามารถตรวจสอบรายละเอียดในภายหลังและทำความเข้าใจปัญหาได้
ตรวจสอบให้แน่ใจว่าคุณได้ตรวจสอบคุกกี้และใช้งานหากจำเป็น (อ่านสวิตช์ -b และบันทึก -c)
ป้อนหนึ่งในเบราว์เซอร์ยอดนิยมล่าสุดในช่อง "ตัวแทนผู้ใช้"
กรอกข้อมูลในฟิลด์ "ผู้อ้างอิง" ตามที่เบราว์เซอร์ทำ
หากคุณกำลังใช้คำขอ POST ตรวจสอบให้แน่ใจว่าฟิลด์ทั้งหมดถูกส่งผ่านไปในลำดับเดียวกันกับเบราว์เซอร์ (ดูด้านบน ข้อ 4.5)

ผู้ช่วยที่ดีในงานยากนี้คือปลั๊กอิน LiveHTTPHeader สำหรับ Mozilla / Firefox ซึ่งช่วยให้คุณดูส่วนหัวทั้งหมดที่เบราว์เซอร์นี้ส่งและรับ (แม้เมื่อใช้ HTTPS)

แนวทางระดับล่างคือการดักจับทราฟฟิก HTTP บนเว็บโดยใช้โปรแกรมอย่าง ethereal หรือ tcpdump จากนั้นวิเคราะห์ว่าเบราว์เซอร์รับและส่งส่วนหัวใด (HTTPS ทำให้วิธีนี้ไม่ได้ผล)

RFC 2616 เป็นสิ่งที่ต้องอ่านสำหรับทุกคนที่ต้องการทำความเข้าใจโปรโตคอล HTTP

RFC 2396 อธิบายไวยากรณ์สำหรับ URL

RFC 2109 กำหนดวิธีการทำงานของคุกกี้

RFC 1867 กำหนดรูปแบบโพสต์อัปโหลดไฟล์

http://openssl.planetmirror.com - หน้าแรกโครงการ OpenSSL

http://curl.haxx.se - หน้าแรกของโครงการ cURL

ไลบรารี CURL (URL ไคลเอนต์) ช่วยให้คุณสามารถถ่ายโอนไฟล์ไปยังคอมพิวเตอร์ระยะไกลโดยใช้อินเทอร์เน็ตโปรโตคอลที่หลากหลาย มีการกำหนดค่าที่ยืดหยุ่นมากและช่วยให้คุณสามารถดำเนินการตามคำขอระยะไกลได้เกือบทุกชนิด

CURL รองรับโปรโตคอล HTTP, HTTPS, FTP, FTPS, DICT, TELNET, LDAP, FILE และ GOPHER เช่นเดียวกับ HTTP-post, HTTP-put, คุกกี้, การอัปโหลด FTP, การถ่ายโอนไฟล์ที่ถูกขัดจังหวะอย่างต่อเนื่อง, รหัสผ่าน, หมายเลขพอร์ต, ใบรับรอง SSL , Kerberos และผู้รับมอบฉันทะ

เมื่อใช้ CURL เว็บเซิร์ฟเวอร์สามารถทำหน้าที่เป็นไคลเอ็นต์เต็มรูปแบบสำหรับบริการที่ใช้ HTTP เช่น XML-RPC, SOAP หรือ WebDAV

โดยทั่วไป การใช้ห้องสมุดจะมีสี่ขั้นตอน:

การสร้างทรัพยากร CURL โดยใช้ฟังก์ชัน curl_init
การตั้งค่าพารามิเตอร์โดยใช้ฟังก์ชัน curl_setopt
ดำเนินการตามคำขอโดยใช้ฟังก์ชัน curl_exec
การทำให้ทรัพยากร CURL ว่างโดยใช้ฟังก์ชัน curl_close

ตัวอย่างง่ายๆ ของการใช้ CURL

// เริ่มต้น curl ไลบรารี่
ถ้า ($ ch = @ curl_init ())
{
// ตั้งค่า URL คำขอ
@ curl_setopt ($ ch, CURLOPT_URL, "http://server.com/");
// ถ้าเป็นจริง CURL จะรวมส่วนหัวในเอาต์พุต
@
// จะใส่ผลลัพธ์การสืบค้นไว้ที่ไหน:
// false - ไปยังสตรีมเอาต์พุตมาตรฐาน
// true - เป็นค่าส่งคืนของฟังก์ชัน curl_exec
@
// เวลารอสูงสุดเป็นวินาที
@
// ตั้งค่าฟิลด์ User-agent
@ curl_setopt ($ ch, CURLOPT_USERAGENT, " PHP Bot (http://blog.yousoft.ru)");
// ดำเนินการตามคำขอ
$ data = @ curl_exec ($ ch);
// แสดงข้อมูลที่ได้รับ
ข้อมูลสะท้อน $;
// ความเชี่ยวชาญของทรัพยากร
@ curl_close ($ ch);
}
?>

ตัวอย่างการใช้คำขอ GET

$ ch = curl_init ();
// คำขอ GET ระบุไว้ในสตริง URL
curl_setopt ($ ch, CURLOPT_URL, "http://server.com/?s=CURL");
curl_setopt ($ ch, CURLOPT_HEADER, เท็จ);
curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, จริง);
curl_setopt ($ ch, CURLOPT_CONNECTTIMEOUT, 30);

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

การส่งคำขอ GET ไม่แตกต่างจากการรับเพจ สิ่งสำคัญคือต้องสังเกตว่าสตริงการสืบค้นมีรูปแบบดังนี้:

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

โดยที่ http://server.com/index.php คือที่อยู่เพจ nameX คือชื่อของตัวแปร valueX คือค่าของตัวแปร

ตัวอย่างการใช้คำขอ POST

$ ch = curl_init ();
curl_setopt ($ ch, CURLOPT_URL, "http://server.com/index.php");
curl_setopt ($ ch, CURLOPT_HEADER, เท็จ);
curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, จริง);
// คุณต้องระบุให้ชัดเจนว่าจะมีคำขอ POST
curl_setopt ($ ch, CURLOPT_POST จริง);
// ค่าตัวแปรถูกส่งผ่านมาที่นี่
curl_setopt ($ ch, CURLOPT_POSTFIELDS, "s = CURL");
curl_setopt ($ ch, CURLOPT_CONNECTTIMEOUT, 30);
curl_setopt ($ ch, CURLOPT_USERAGENT, "PHP Bot (http://mysite.ru)");
$ data = curl_exec ($ ch);
curl_close ($ ch);
?>

การส่งคำขอ POST นั้นไม่ได้แตกต่างจากการส่งคำขอ GET มากนัก ขั้นตอนพื้นฐานทั้งหมดยังคงเหมือนเดิม ตัวแปรยังถูกกำหนดเป็นคู่: name1 = value1 & name2 = value2

ตัวอย่างการอนุญาต HTTP

// การอนุญาต HTTP
$ url = "http://server.com/protected/";
$ ch = curl_init ();

curl_setopt ($ ch, CURLOPT_USERPWD, "ชื่อผู้ใช้ของฉัน: mypassword");
$ ผล = curl_exec ($ ch);
curl_close ($ ch);
สะท้อน $ ผล;
?>

ตัวอย่างเซสชัน FTP

$ fp = fopen (__FILE__, "r");
$ url = "ftp: // ชื่อผู้ใช้: [ป้องกันอีเมล]: 21 / เส้นทาง / ถึง / newfile.php ";
$ ch = curl_init ();
curl_setopt ($ ch, CURLOPT_URL, $ url);
curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt ($ ch, CURLOPT_UPLOAD, 1);
curl_setopt ($ ch, CURLOPT_INFILE, $ fp);
curl_setopt ($ ch, CURLOPT_FTPASCII, 1);
curl_setopt ($ ch, CURLOPT_INFILESIZE, ขนาดไฟล์ (__FILE__));
$ ผล = curl_exec ($ ch);
curl_close ($ ch);
?>

หากคุณมีปัญหาในการใช้ cURL คุณต้องเพิ่มบรรทัดต่อไปนี้ก่อนที่จะเรียก curl_close เพื่อรับรายงานเกี่ยวกับคำขอที่ดำเนินการล่าสุด:

print_r (curl_getinfo ($ ch));
echo "หมายเลขข้อผิดพลาดของ cURL:" curl_errno ($ ch). "
" ;
echo "ข้อผิดพลาดของ cURL:" curl_error ($ ch) "
" ;
curl_close ($ ch);
?>

ทำไมเราถึงต้องการ PHP CURL?
ในการส่งคำขอ HTTP GET เพียงแค่เราใช้ file_get_contents ()กระบวนการ.

File_get_contents ("http: // ไซต์")

แต่การส่งคำขอ POST และการจัดการข้อผิดพลาดนั้นไม่ใช่เรื่องง่ายด้วย file_get_contents ()

การส่งคำขอ HTTP นั้นง่ายมากด้วย PHP CURL คุณต้องทำตามสี่ขั้นตอนเพื่อส่งคำขอ

ขั้นตอนที่ 1)... เริ่มต้นเซสชัน CURL

$ ch = curl_init ();

ขั้นตอนที่ 2)... ระบุตัวเลือกสำหรับเซสชัน CURL

Curl_setopt ($ ch, CURLOPT_URL, "http: // ไซต์"); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, จริง); // curl_setopt ($ ch, CURLOPT_HEADER, จริง); // ถ้าคุณต้องการส่วนหัว

CURLOPT_URL-> URL ที่จะดึง
CURLOPT_HEADER-> เพื่อรวมส่วนหัว / not
CURLOPT_RETURNTRANSFER-> หากตั้งค่าเป็น true ข้อมูลจะถูกส่งกลับเป็นสตริงแทนการส่งออก

ขั้นตอนที่ 3).ดำเนินการ CURL เซสชัน

$ เอาต์พุต = curl_exec ($ ch);

ขั้นตอนที่ 4).ปิดเซสชั่น

Curl_close ($ ch);

บันทึก: คุณสามารถตรวจสอบว่าเปิดใช้งาน CURL / ไม่ใช่ด้วยรหัสต่อไปนี้.

If (is_callable ("curl_init")) (echo "Enabled";) อื่น ๆ (echo "ไม่ได้เปิดใช้งาน";)

1. PHP CURL GET ตัวอย่าง

คุณสามารถใช้รหัสด้านล่างเพื่อส่งคำขอ GET

ฟังก์ชั่น httpGet ($ url) ($ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, จริง); // curl_setopt ($ ch, CURLOPT_HEADER, เท็จ) curl_exec ($ ch ); curl_close ($ ch); return $ เอาต์พุต;) echo httpGet ("http: // ไซต์");

2. PHP CURL POST ตัวอย่าง

คุณสามารถใช้รหัสด้านล่างเพื่อส่งแบบฟอร์มโดยใช้ PHP CURL

ฟังก์ชั่น httpPost ($ url, $ params) ($ postData = ""; // สร้างคู่ค่าชื่อคั่นด้วย & foreach ($ params เป็น $ k => $ v) ($ postData. = $ K. "=". $ v. "&";) $ postData = rtrim ($ postData, "&"); $ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, จริง); curl_setopt ( $ ch, CURLOPT_HEADER, เท็จ); curl_setopt ($ ch, CURLOPT_POST นับ ($ postData)); curl_setopt ($ ch, CURLOPT_POSTFIELDS, $ postData); $ เอาต์พุต = curl_exec ($ ch); curl_close ($ ch); ส่งคืนเอาต์พุต ;)

วิธีใช้ฟังก์ชัน:

$ params = array ("name" => "Ravishanker Kusuma", "age" => "32", "location" => "India"); echo httpPost ("http: //site/examples/php/curl-examples/post.php", $ params);

3.ส่ง User-Agent แบบสุ่มในคำขอ

คุณสามารถใช้ฟังก์ชันด้านล่างเพื่อรับ Random User-Agent

ฟังก์ชัน getRandomUserAgent () ($ userAgents = array ("Mozilla / 5.0 (Windows; U; Windows NT 5.1; en-GB; rv: 1.8.1.6) Gecko / 20070725 Firefox / 2.0.0.6", "Mozilla / 4.0 (เข้ากันได้; MSIE 7.0; Windows NT 5.1) "," Mozilla / 4.0 (เข้ากันได้; MSIE 7.0; Windows NT 5.1; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30) "," Opera / 9.20 (Windows NT 6.0; U; en) "," Mozilla / 4.0 (เข้ากันได้; MSIE 6.0; Windows NT 5.1; en) Opera 8.50 "," Mozilla / 4.0 (เข้ากันได้; MSIE 6.0; MSIE 5.5; Windows NT 5.1) Opera 7.02 "," Mozilla / 5.0 (Macintosh; U; PPC Mac OS X Mach-O; fr; rv: 1.7) Gecko / 20040624 Firefox / 0.9 "," Mozilla / 5.0 (Macintosh; U; PPC Mac OS X; en) AppleWebKit / 48 (เช่น Gecko) Safari / 48 "); $ สุ่ม = rand (0, นับ ($ userAgents) -1); ส่งคืน $ userAgents [$ สุ่ม];)

โดยใช้ CURLOPT_USERAGENTคุณสามารถตั้งค่าสตริง User-Agent

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

4.จัดการการเปลี่ยนเส้นทาง (HTTP 301,302)

ในการจัดการการเปลี่ยนเส้นทาง URL ให้ตั้งค่า CURLOPT_FOLLOWLOCATION เป็น TRUE จำนวนสูงสุดของการเปลี่ยนเส้นทางสามารถควบคุมได้โดยใช้ CURLOPT_MAXREDIRS

Curl_setopt ($ ch, CURLOPT_FOLLOWLOCATION, TRUE); curl_setopt ($ ch, CURLOPT_MAXREDIRS, 2); // เปลี่ยนเส้นทางเพียง 2 ครั้ง

5.วิธีจัดการกับข้อผิดพลาด CURL

เราสามารถใช้วิธี curl_errno (), curl_error () เพื่อรับข้อผิดพลาดล่าสุดสำหรับเซสชันปัจจุบัน
curl_error ($ ch)-> ส่งกลับข้อผิดพลาดเป็น string
curl_errno ($ ch)-> ส่งกลับหมายเลขข้อผิดพลาด
คุณสามารถใช้รหัสด้านล่างเพื่อจัดการกับข้อผิดพลาด

ฟังก์ชัน httpGetWithErros ($ url) ($ ch = curl_init (); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, จริง); $ output = curl_exec ($ ch=); if ($ output = = false) (echo "หมายเลขข้อผิดพลาด:" curl_errno ($ ch) "
"; echo" Error String: ". curl_error ($ ch);) curl_close ($ ch); return $ output;)