Home > Developer > PHP

Multi-threaded cURL

Source: Internet
Author: User
Developer on Alibaba Coud: Build your first app with APIs, SDKs, and tutorials on the Alibaba Cloud. Read more ＞
Multi-threaded cURL
This is a flexible multi-thread call cURL.
This is different from the sample provided in the php manual http://us2.php.net/manual/zh/function.curl-multi-select.php, the code execution efficiency is much higher
There are two files in this section. one is a muti_curl file, which contains two classes.
One method is to use, here is to check whether the proxy ip is available in batches

  2. Class request_setting {
  3. Public $ url = false;
  4. Public $ method = 'get ';
  5. Public $ post_data = null;
  6. Public $ headers = null;
  7. Public $ options = null;
  8. Function _ construct ($ url, $ method = "GET", $ post_data = null, $ headers = null, $ options = null ){
  9. $ This-> url = $ url;
  10. $ This-> method = $ method;
  11. $ This-> post_data = $ post_data;
  12. $ This-> headers = $ headers;
  13. $ This-> options = $ options;
  14. }
  15. Public function _ destruct (){
  16. Unset ($ this-> url, $ this-> method, $ this-> post_data, $ this-> headers, $ this-> options );
  17. }
  18. }
  19. /*************************************** **************************************** ****************
  20. Batch operation class
  21. **************************************** **************************************** ***********/
  22. Class muti_curl {
  23. Protected $ thread_size = 100;
  24. Protected $ timeout = 30;
  25. Private $ callback;
  26. Protected $ options = array (
  27. CURLOPT_SSL_VERIFYPEER => false, // after the cURL is disabled, it is terminated from the server for verification. Use the CURLOPT_CAINFO option to set the certificate. use the CURLOPT_CAPATH option to set the certificate Directory. if CURLOPT_SSL_VERIFYPEER (default value: 2) is enabled, set CURLOPT_SSL_VERIFYHOST to TRUE or FALSE. The default value is TRUE since cURL 7.10. The installation is bound by default starting from cURL 7.10.
  28. CURLOPT_RETURNTRANSFER => true, // return the information obtained by curl_exec () in the form of a file stream, instead of directly entering
  29. CURLOPT_CONNECTTIMEOUT => 15,
  30. CURLOPT_TIMEOUT => 30,
  31. // CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_0, // it is better to use this to capture data when using a proxy.
  32. // CURLOPT_AUTOREFERER => false, // when based on Location: redirection, the Referer: Information in the header is automatically set.
  33. // CURLOPT_BINARYTRANSFER => false, // when CURLOPT_RETURNTRANSFER is enabled, the native (Raw) output is returned.
  34. // CURLOPT_COOKIESESSION => true, // When enabled, curl will only pass one session cookie and ignore other cookies. by default, cURL will return all cookies
  35. // CURLOPT_CRLF => false, // When enabled, convert Unix line breaks to carriage return line breaks.
  36. // CURLOPT_DNS_USE_GLOBAL_CACHE => false, // A global DNS cache is enabled when it is enabled. this option is thread-safe and enabled by default.
  37. // CURLOPT_FAILONERROR => false, // The HTTP status code is displayed. the default behavior is to ignore the HTTP information whose number is less than or equal to 400.
  38. // CURLOPT_FILETIME => true, // When enabled, the system tries to modify the information in the remote document. The result is returned through the CURLINFO_FILETIME option of the curl_getinfo () function. Curl_getinfo ().
  39. // CURLOPT_FOLLOWLOCATION => false, // When enabled, the "Location:" returned by the server will be recursively returned to the server in the header. you can use CURLOPT_MAXREDIRS to limit the number of recursive responses.
  40. // CURLOPT_FORBID_REUSE => true, // force disconnect after the interaction is completed and cannot be reused.
  41. // CURLOPT_FRESH_CONNECT => true, // force a new connection to replace the connection in the cache.
  42. // CURLOPT_FTP_USE_EPRT => false, // When FTP download is enabled, use the EPRT (or LPRT) command. If it is set to FALSE, disable EPRT and LPRT and use the PORT command only.
  43. // CURLOPT_FTP_USE_EPSV => false, // When enabled, try the EPSV command before returning to PASV mode during FTP transmission. Disable the EPSV command when set to FALSE.
  44. // CURLOPT_FTPAPPEND => false, // When enabled, append the data to the file instead of overwriting it.
  45. // CURLOPT_FTPASCII => false, // The alias of CURLOPT_TRANSFERTEXT.
  46. // CURLOPT_FTPLISTONLY => false, // only the FTP directory name is listed when enabled.
  47. // CURLOPT_HEADER => true, // When enabled, the header file information is output as a data stream.
  48. // CURLINFO_HEADER_OUT => false, // The request string of the tracking handle when enabled.
  49. // CURLOPT_HTTPGET => true, // When enabled, the HTTP method is set to GET. because GET is the default value, it is used only when it is modified.
  50. // CURLOPT_HTTPPROXYTUNNEL => true, // it will be transmitted through the HTTP proxy when enabled.
  51. // CURLOPT_MUTE => true, // When enabled, all the modified parameters in the cURL function are restored to the default value.
  52. // CURLOPT_NETRC => false, // after the connection is established, access ~ /. The netrc file obtains the user name and password to connect to the remote site.
  53. // CURLOPT_NOBODY => true.
  54. // CURLOPT_NOPROGRESS => false, // disable the curl transmission progress bar when enabled. this option is enabled by default.
  55. // CURLOPT_NOSIGNAL => false, // When enabled, ignore all the signals sent to php by curl. This option is enabled by default during SAPI multi-thread transmission. CURL 7.10 is added.
  56. // CURLOPT_POST => false, // When enabled, a conventional POST request is sent. the type is application/x-www-form-urlencoded, just like form submission.
  57. // CURLOPT_PUT => false, // When enabled, files can be sent over HTTP. both CURLOPT_INFILE and CURLOPT_INFILESIZE must be set.
  58. // CURLOPT_TRANSFERTEXT => false, // use ASCII mode for FTP transmission after enabling. For LDAP, it retrieves plain text information rather than HTML. In Windows, STDOUT is not set to binary mode.
  59. // CURLOPT_UNRESTRICTED_AUTH => true, // The username and password information is continuously appended to multiple locations in the header generated by CURLOPT_FOLLOWLOCATION, even if the domain name has changed.
  60. // CURLOPT_UPLOAD => false, // enable and allow file upload.
  61. // CURLOPT_VERBOSE => true, // When enabled, all information is reported and stored in STDERR or the specified CURLOPT_STDERR.
  62. );
  63. Private $ headers = array ();
  64. Private $ requests = array ();
  65. Private $ requestMap = array ();
  66. /*********************
  67. Construct a callback function
  68. ********************/
  69. Function _ construct ($ callback = null ){
  70. $ This-> callback = $ callback;
  71. }
  73. /*************************************** *****************************
  74. Reload the _ get method
  75. **************************************** ***************************/
  76. Public function _ get ($ name ){
  77. Return (isset ($ this-> {$ name }))? $ This-> {$ name}: null;
  78. }
  80. /*************************************** ******************************
  81. Reload _ set
  82. **************************************** ***************/
  83. Public function _ set ($ name, $ value ){
  84. // Add a setting to headers.
  85. If ($ name = "options" | $ name = "headers "){
  86. $ This-> {$ name }=$ value + $ this-> {$ name };
  87. } Else {
  88. $ This-> {$ name} = $ value;
  89. }
  90. Return true;
  91. }
  92. // Add a request
  93. Public function add ($ request ){
  94. $ This-> requests [] = $ request;
  95. Return true;
  96. }
  99. Public function request ($ url, $ method = "GET", $ post_data = null, $ headers = null, $ options = null ){
  100. $ This-> requests [] = new request_setting ($ url, $ method, $ post_data, $ headers, $ options );
  101. Return true;
  102. }
  104. Public function get ($ url, $ headers = null, $ options = null ){
  105. Return $ this-> request ($ url, "GET", null, $ headers, $ options );
  106. }
  108. Public function post ($ url, $ post_data = null, $ headers = null, $ options = null ){
  109. Return $ this-> request ($ url, "POST", $ post_data, $ headers, $ options );
  110. }
  112. Private function single_curl (){
  113. $ Ch = curl_init (); // Initialization
  114. $ Request = array_shift ($ this-> requests); // removes the first unit and serves as the result.
  115. $ Options = $ this-> get_options ($ request); // Obtain the unit settings
  116. Curl_setopt_array ($ ch, $ options); // batch settings
  117. $ Output = curl_exec ($ ch );
  118. $ Curl_info = curl_getinfo ($ ch );
  120. If ($ this-> callback ){
  121. $ Callback = $ this-> callback;
  122. If (is_callable ($ this-> callback )){
  123. Call_user_func ($ callback, $ output, $ curl_info, $ request );
  124. }
  125. }
  126. Else
  127. Return $ output;
  128. Return true;
  129. }
  132. Private function rolling_curl ($ thread_size = null ){
  133. If ($ thread_size ){
  134. $ This-> thread_size = $ thread_size;
  135. }
  137. If (count ($ this-> requests) <$ this-> thread_size ){
  138. $ This-> thread_size = count ($ this-> requests );
  139. }
  140. If ($ this-> thread_size <2 ){
  141. $ Errorinfo = 'the thread size must be greater than 1 !!!! ';
  142. Throw new Exception ($ errorinfo );
  143. }
  144. $ Queue = curl_multi_init ();
  146. // Add the task queue in the thread
  147. For ($ I = 0; $ I <$ this-> thread_size; $ I ++ ){
  148. $ Ch = curl_init ();
  149. $ Options = $ this-> get_options ($ this-> requests [$ I]);
  150. Curl_setopt_array ($ ch, $ options); // get the settings
  151. Curl_multi_add_handle ($ queue, $ ch); // add
  152. $ Key = (string) $ ch;
  153. $ This-> requestMap [$ key] = $ I;
  154. }
  155. Do {
  156. While ($ statu_run_muti_exec = curl_multi_exec ($ queue, $ active) = CURLM_CALL_MULTI_PERFORM );
  157. If ($ statu_run_muti_exec! = CURLM_ OK) {break ;}
  158. // Process a completed request
  159. While ($ done = curl_multi_info_read ($ queue )){
  160. $ Curl_info = curl_getinfo ($ done ['handle']);
  161. $ Output = curl_multi_getcontent ($ done ['handle']);
  162. $ Callback = $ this-> callback;
  163. If (is_callable ($ callback )){
  164. $ Key = (string) $ done ['handle'];
  165. $ Request = $ this-> requests [$ this-> requestMap [$ key];
  166. Unset ($ this-> requestMap [$ key]); // this destroy variable is very handsome
  167. Call_user_func ($ callback, $ output, $ curl_info, $ request );
  168. }
  169. // Add an unprocessed request to a completed queue
  170. If ($ I <count ($ this-> requests) & isset ($ this-> requests [$ I]) & $ I <count ($ this-> requests )){
  171. $ Ch = curl_init ();
  172. $ Options = $ this-> get_options ($ this-> requests [$ I]);
  173. Curl_setopt_array ($ ch, $ options );
  174. Curl_multi_add_handle ($ queue, $ ch );
  175. $ Key = (string) $ ch;
  176. $ This-> requestMap [$ key] = $ I;
  177. $ I ++;
  178. }
  179. Curl_multi_remove_handle ($ queue, $ done ['handle']);
  180. Echo "done ";
  181. Print_r ($ queue );
  182. Print_r ($ done );
  183. }
  184. // This step is very important. if you need to reset the timeout time after completing one step
  185. // The key point here is to ensure that at least one of the requests in all the threads for the first time is valid. otherwise, none of the requests will be effective for the first time, cause $ active = 0, so do not execute the following
  186. If ($ active> 0 ){
  187. Curl_multi_select ($ queue, $ this-> timeout );
  188. }
  190. } While ($ active );
  191. Curl_multi_close ($ queue );
  192. Return true;
  193. }
  194. Public function execute ($ thread_size = null ){
  195. // Determine the size of thread_size. if there is only one request, the single-thread mode is used.
  196. If (count ($ this-> requests) = 1 ){
  197. Return $ this-> single_curl ();
  198. } Else {
  199. Return $ this-> rolling_curl ($ thread_size );
  200. }
  201. }
  202. Private function get_options ($ request ){
  203. $ Options = $ this->__ get ('options ');
  204. If (ini_get ('safe _ mode') = 'off' |! Ini_get ('safe _ mode ')){
  205. // $ Options [CURLOPT_FOLLOWLOCATION] = 1;
  206. // $ Options [CURLOPT_MAXREDIRS] = 5;
  207. }
  208. $ Headers = $ this->__ get ('headers ');
  210. If ($ request-> options ){
  211. $ Options = $ request-> options + $ options;
  212. }
  213. $ Options [CURLOPT_URL] = $ request-> url;
  214. // Set the post option and header option respectively below
  215. If ($ request-> post_data ){
  216. $ Options [CURLOPT_POST] = 1;
  217. $ Options [CURLOPT_POSTFIELDS] = $ request-> post_data;
  218. }
  219. If ($ headers ){
  220. $ Options [CURLOPT_HEADER] = 0;
  221. $ Options [CURLOPT_HTTPHEADER] = $ headers;
  222. }
  223. Return $ options;
  224. }
  226. Public function _ destruct (){
  227. Unset ($ this-> thread_size, $ this-> callback, $ this-> options, $ this-> headers, $ this-> requests );
  228. }
  229. }
  230. ?>

  1. Header ("content-type: text/html; charset = utf-8 ");
  2. Require ("muti_curl_class.php ");
  3. Set_time_limit (0 );
  4. $ Sucesesnum = 0;
  5. $ Good_proxy = array ();
  6. Function request_callback ($ response, $ info, $ request ){
  7. Global $ sucesesnum, $ good_proxy;
  8. // The following regular expression can display the returned results selectively.
  9. /* If (preg_match ("~(.*?)~ I ", $ response, $ out )){
  10. $ Title = $ out [1];
  11. }*/
  12. // Echo'
    '. $ Response .'
    ';
  13. Echo'
    ';
  14. // Check the response, that is, $ response to determine whether there are set characters in the response. If yes, the agent is used successfully.
  15. If ($ response! = False & substr_count ($ response, 'user-agent: Baiduspider ')> = 1 ){
  16. // $ Result = true;
  17. Echo "true
    ";
  18. // Echo $ request [options] [1, 10004];
  19. // Print_r ($ request-> options );
  20. Echo $ request-> options [CURLOPT_PROXY];
  21. $ Good_proxy [] = $ request-> options [CURLOPT_PROXY];
  22. }
  23. Echo'
    The --> '. $ sucesesnum.' <--- use: '. $ info ['total _ time'];
  24. // Print_r ($ request );
  25. // Echo $ request-> url;
  26. $ Sucesesnum ++;
  27. Echo "";
  28. }
  29. $ Params = array_merge ($ _ GET, $ _ POST); // obtain the address of the passed proxy ip address.
  30. $ Result = $ proxy_ip = trim ($ params ['IP']);
  31. $ Timeout = intval (trim ($ params ['timeout']);
  32. If ($ timeout <3) {$ timeout = 3 ;}
  33. If ($ timeout> 300) {$ timeout = 300 ;}
  34. $ Thread_size = intval (trim ($ params ['thread _ size']);
  35. If ($ thread_size <5) {$ thread_size = 5 ;}
  36. If ($ thread_size> 300) {$ thread_size = 300 ;}
  38. If ($ proxy_ip = ''){
  39. Echo 'Enter the IP address !! ';
  40. Return;
  41. }
  42. $ Replace_arr1 = array ('', 'qq proxy: ', 'dn28. com ', 'qqip', 'qq proxy', 'qq proxy IP', 'proxy ip: ', 'Ip:', 'proxy IP ','"', "'",'\\','/','');
  43. $ Result = str_replace ($ replace_arr1, array (''), $ result );
  44. $ Result = str_replace (",", "\ n", $ result );
  45. $ ResArr = explode ("\ n", $ result );
  46. Foreach ($ resArr as $ k => $ v ){
  47. $ PosProxy = getPos ($ v ,'@');
  48. If ($ posProxy === false ){
  49. If (! Empty ($ v) {$ proxyip_and_port = $ v ;}
  50. } Else {
  51. $ Proxyip_and_port = substr ($ v, 0, $ posProxy );
  52. }
  53. $ NewRes [] = trim ($ proxyip_and_port );
  54. }
  55. Print_r ($ newRes );
  56. // Die ();
  57. $ Option_setting = array (
  58. CURLOPT_SSL_VERIFYPEER => 0,
  59. CURLOPT_RETURNTRANSFER => true,
  60. CURLOPT_CONNECTTIMEOUT => 5,
  61. CURLOPT_TIMEOUT => 30,
  62. CURLOPT_HEADER => false,
  63. CURLOPT_PROXY => '', // Set the proxy location here
  64. );
  65. $ Url = 'http: // www.baidu.com/robots.txt ';
  66. $ Btime = time ();
  67. $ Rc = new muti_curl ("request_callback ");
  68. $ Rc-> timeout = $ timeout;
  69. $ Rc-> thread_size = $ thread_size;
  70. Foreach ($ newRes as $ v ){
  71. $ Option_setting [CURLOPT_PROXY] = $ v;
  72. $ Request = new request_setting ($ url, $ method = "GET", $ post_data = null, $ header = null, $ option_setting );
  73. $ Rc-> add ($ request );
  74. }
  75. $ Rc-> execute ();
  76. $ Etime = time ();
  77. $ Usedtime = $ etime-$ btime;
  78. Echo 'all'. $ sucesesnum. 'use'. $ usedtime;
  79. Echo '';
  80. $ Good_proxy = array_unique ($ good_proxy );
  81. $ Str = '';
  82. Foreach ($ good_proxy as $ v ){
  83. $ Str. = "'". trim ($ v )."',";
  84. }
  85. $ Str = str_replace ('','', $ str );
  86. $ Str = preg_replace ('/\ s +/', '', $ str );
  87. Echo $ str .'
    ';
  88. Var_export ($ good_proxy );
  89. // Var_dump ($ good_proxy );
  103. //************************************** **************************************** ********************
  104. // ********************************* Only uses one function
  106. Function parseProxyInfo ($ proxyStr ){
  107. // $ ProxyStr = '192. 115.207.25: 80 @ HTTP; Chengdu Sichuan Normal University ';
  108. $ PosIp = getPos ($ proxyStr ,':');
  109. $ Ip = substr ($ proxyStr, 0, $ posIp );
  110. $ PosPort = getPos ($ proxyStr ,'@');
  111. $ Port = substr ($ proxyStr, $ posIp + 1, $ posPort-$ posIp-1 );
  112. $ PosType = getPos ($ proxyStr ,';');
  113. $ Type = substr ($ proxyStr, $ posPort + 1, $ posType-$ posPort-1 );
  114. $ Location = substr (strstr ($ proxyStr, ';'), 1 );
  115. Return array (
  116. 'IP' => $ ip,
  117. 'Port' => $ port,
  118. 'Type' => $ type,
  119. 'Location' => $ location
  120. );
  121. }
  123. Function getPos ($ haystack, $ needle ){
  124. Return strpos ($ haystack, $ needle );
  125. }
  127. Function check_proxy_is_useful ($ model, $ proxy_info_arr = array ()){
  128. Global $ params, $ config;
  129. If ($ model = 'Singles '){
  130. $ Proxy_port = intval (trim ($ params ['port']);
  131. $ Check_proxy_url = $ config ['verify _ url'];
  132. $ Proxy_time_out = intval (trim ($ params ['timeout']);
  133. $ Retry = intval (trim ($ params ['retry']);
  134. $ Proxy_ip = trim ($ params ['IP']);
  135. $ Proxy = new proxy ($ proxy_ip, $ proxy_port, $ check_proxy_url, $ proxy_time_out, $ retry );
  136. // String success is returned if the call succeeds. if the call fails, boolean false is returned.
  137. $ Result = $ proxy-> check_proxy ();
  138. // Var_dump ($ result );
  139. $ Proxy_str_success = ''. $ proxy_ip. ':'. $ proxy_port. '@'. 'http proxy verification successful! ';
  140. $ Proxy_str_failed = ''. $ proxy_ip. ':'. $ proxy_port. '@'. 'http proxy verification failed! ';
  141. Return $ result! = False? $ Proxy_str_success: $ proxy_str_failed;
  142. } Elseif ($ model = 'collect '){
  143. $ Proxy_port = intval (trim ($ proxy_info_arr ['port']);
  144. $ Check_proxy_url = $ config ['verify _ url'];
  145. $ Proxy_time_out = intval (trim ($ params ['timeout']);
  146. $ Retry = intval (trim ($ params ['retry']);
  147. $ Proxy_ip = trim ($ proxy_info_arr ['IP']);
  148. /* Echo $ proxy_ip .'
    ';
  149. Echo $ proxy_port .'
    ';
  150. Echo $ check_proxy_url .'
    ';
  151. Echo $ proxy_time_out .'
    ';
  152. Echo $ retry .'
    ';*/
  153. If (! Isset ($ proxy )){
  154. $ Proxy = new proxy ($ proxy_ip, $ proxy_port, $ check_proxy_url, $ proxy_time_out, $ retry );
  155. }
  156. // String success is returned if the call succeeds. if the call fails, boolean false is returned.
  157. $ Result = $ proxy-> check_proxy ();
  158. Return $ result;
  159. }
  160. }
  162. Function get_single (){
  163. Global $ params, $ config;
  164. $ Proxy_ip = trim ($ params ['IP']);
  165. If ($ proxy_ip = ''){
  166. Echo 'Enter the IP address !! ';
  167. Return;
  168. }
  169. Echo check_proxy_is_useful ('Single ');
  170. }
  172. Function get_proxy_by_collect (){
  173. Global $ params, $ config;
  174. $ Params ['URL'] = trim ($ params ['URL']);
  175. If ($ params ['URL'] = ''){
  176. Echo 'Enter the url! ';
  177. Return;
  178. }
  179. // $ Url = 'http: // www.dn28.com/html/75/n-5175.html ';
  180. $ Con = iconv ('gbk', 'utf-8', file_get_contents ($ params ['URL']);
  181. Preg_match ('/<\/TBODY> <\/TABLE> (.*)

    /S', $ con, $ arr );

  182. $ Result = strip_tags ($ arr [1],'
    ');
  183. $ Replace_arr1 = array ('', 'qq proxy: ', 'dn28. com ', 'qqip', 'qq proxy', 'qq proxy IP', 'proxy ip: ', 'Ip:', 'proxy IP ');
  184. $ Result = str_replace ($ replace_arr1, array (''), $ result );
  185. // Print_r ($ arr );
  186. $ ResArr = explode ('
    ', $ Result );
  187. // Print_r ($ resArr );
  188. Echo 'proxy starts batch verification, and the entire process takes several minutes. ';
  189. Unset ($ _ SESSION ['success _ arr']);
  190. Foreach ($ resArr as $ k => $ v ){
  191. $ NewRes [$ k] = parseProxyInfo ($ v );
  192. // Print_r ($ newRes [$ k]);
  193. /* Return ;*/
  194. $ Result = check_proxy_is_useful ('collect ', $ newRes [$ k]);
  195. $ Proxy_str_success = ''. $ newRes [$ k] ['IP']. ':'. $ newRes [$ k] ['port']. '@'. $ newRes [$ k] ['type']. 'Proxy verification successful! IP address: '. $ newRes [$ k] ['location']. '';
  196. $ Proxy_str_failed = ''. $ newRes [$ k] ['IP']. ':'. $ newRes [$ k] ['port']. '@'. $ newRes [$ k] ['type']. 'Proxy verification failed! IP address: '. $ newRes [$ k] ['location']. '';
  197. If ($ result! = False ){
  198. Echo $ proxy_str_success;
  199. $ _ SESSION ['success _ arr'] [] = $ success_arr [] = $ newRes [$ k];
  200. } Else {
  201. Echo $ proxy_str_failed;
  202. }
  203. Echo'
    ';
  204. }
  205. If (isset ($ success_arr) & count ($ success_arr)> 0 ){
  206. Save_success_proxy ($ success_arr );
  207. Echo'

    [Save the verified proxy to your local computer] [I want to see historical data]

    ';
  208. } Else {
  209. Echo'

    [I want to see historical data]

    ';
  210. }
  211. // Print_r ($ success_arr );
  212. }
  214. Function get_proxy_by_rule (){
  215. Global $ params, $ config;
  216. $ Result = $ proxy_ip = trim ($ params ['IP']);
  217. If ($ proxy_ip = ''){
  218. Echo 'Enter the IP address !! ';
  219. Return;
  220. }
  221. $ Replace_arr1 = array ('', 'qq proxy: ', 'dn28. com ', 'qqip', 'qq proxy', 'qq proxy IP', 'proxy ip: ', 'Ip:', 'proxy IP ');
  222. $ Result = str_replace ($ replace_arr1, array (''), $ result );
  223. $ ResArr = explode ("\ n", $ result );
  224. // Print_r ($ resArr );
  225. Echo 'proxy starts batch verification, and the entire process takes several minutes. ';
  226. Unset ($ _ SESSION ['success _ arr']);
  227. Foreach ($ resArr as $ k => $ v ){
  228. $ NewRes [$ k] = parseProxyInfo ($ v );
  229. // Print_r ($ newRes [$ k]);
  230. /* Return ;*/
  231. $ Result = check_proxy_is_useful ('collect ', $ newRes [$ k]);
  232. // Var_dump ($ result );
  233. $ Proxy_str_success = ''. $ newRes [$ k] ['IP']. ':'. $ newRes [$ k] ['port']. '@'. $ newRes [$ k] ['type']. 'Proxy verification successful! IP address: '. $ newRes [$ k] ['location']. '';
  234. $ Proxy_str_failed = ''. $ newRes [$ k] ['IP']. ':'. $ newRes [$ k] ['port']. '@'. $ newRes [$ k] ['type']. 'Proxy verification failed! IP address: '. $ newRes [$ k] ['location']. '';
  235. If ($ result! = False ){
  236. Echo $ proxy_str_success;
  237. $ _ SESSION ['success _ arr'] [] = $ success_arr [] = $ newRes [$ k];
  238. } Else {
  239. Echo $ proxy_str_failed;
  240. }
  241. Echo'
    ';
  242. }
  243. If (isset ($ success_arr) & count ($ success_arr)> 0 ){
  244. Save_success_proxy ($ success_arr );
  245. Echo'

    [Save to a php file] [Save the verified proxy to a local computer] [I want to see historical data]

    ';
  246. } Else {
  247. Echo'

    [I want to see historical data]

    ';
  248. }
  249. }
  251. Function save_success_proxy ($ success_arr ){
  252. Global $ config;
  253. Date_default_timezone_set ('prc ');
  254. $ Str = '';
  255. Foreach ($ success_arr as $ k => $ v ){
  256. $ Str. = $ v ['IP']. ':'. $ v ['port']. '@'. $ v ['type']. ';'. $ v ['location']. "\ n ";
  257. }
  258. $ Fp = fopen ($ config ['root _ path']. '/success_proxy/'. date ('ymdhi'). '. log', 'A + ');
  259. Fwrite ($ fp, $ str );
  260. Fclose ($ fp );
  261. Unset ($ str );
  262. }
  264. ?>

This article is an English version of an article which is originally in the Chinese language on aliyun.com and is provided for information purposes only. This website makes no representation or warranty of any kind, either expressed or implied, as to the accuracy, completeness ownership or reliability of the article or any translations thereof. If you have any concerns or complaints relating to the article, please send an email, providing a detailed description of the concern or complaint, to info-contact@alibabacloud.com. A staff member will contact you within 5 working days. Once verified, infringing content will be removed immediately.

Related Keywords:
php curl multi curl multi handle threaded shackle get threaded apache running threaded mpm curl authentication curl book

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

What's Trending
Top 10 Tags
datastax versions naming convention zookeeper client class definition md5 microsoft sql server 2005 data structures exception handling error handling
Top 10 Keywords
microsoft download center down wordpress address url site address url wordpress address url windows installer 4 0 download 302 not found web address url definition site address url wordpress db2 integer mac os installation step by step pdf abbreviation for return

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

Get Started for Free

  • Sales Support

    1 on 1 presale consultation

    Chat Contact Sales

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

    Open a Ticket

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.

    Learn More