一、类文档说明
复制代码 代码如下:
class FetchUrl{
function __construct();
//返回网页内容 常用于fetch()方法返回false时
function body();
//将对象的数据重新初始化,用于多次重用一个FetchUrl对象
function clean();
//返回错误信息
function errmsg();
//返回错误码,>0表示有错误
function errcode();
/**
* 发起请求
* $url string 请求地址
* $callback function 匿名函数
*/
function fetch(string $url, function $callback);
//请求返回HTTP Code
function httpCode();
//请求返回Cookies数组
function responseCookies();
//请求返回头部信息数组
function responseHeaders();
//是否允许截断，默认为不允许
function setAllowRedirect(bool $allow=false);
//设置连接超时时间
function setConnectTimeout(int $seconds=5);
//在发起的请求中,添加cookie数据
function setCookie(string $name, string $value);
//在发起的请求中,批量添加cookie数据
function setCookies(array $cookies);
//设置请求的方法(POST/GET)
function setMethod(string $method="get");
//设置POST方法的数据
function setPostData(array $data);
//设置读取超时时间
function setReadTimeout(int $seconds=60);
function __destroy();
}
二、使用案例
复制代码 代码如下:
<?php
/*GET抓取http://www.baidu.com*/
/*
$fetch_url = new FetchUrl();
$fetch_url->setAllowRedirect(true);
$fetch_url->fetch('http://www.baidu.com');
*/
$cookies = array(
'wei_xin_wb_session'=>'value',
'wei_xin_wxblog_authcoder'=>'value');
/*POST提交数据*/
/*
$fetch_url = new FetchUrl();
$fetch_url->setMethod('post');
$data = array(
'step'=>2,
'pays[1]'=>0,
'pays[2]'=>0,
'pays[3]'=>0
);
$fetch_url->setCookies($cookies);
$fetch_url->setPostData($data);
$fetch_url->fetch('http://test.wx.pp.cc/wb_advs/manage?inajax=1');
*/
//POST上传数据和文件
$fetch_url = new FetchUrl();
$fetch_url->setAllowRedirect(true);
$fetch_url->setMethod('post');
$data = array(
'nickname'=>'挺好a',
'wxnickname'=>'good',
'wxusername'=>'good',
'intro'=>'good'
);
$fetch_url->setCookies($cookies);
$fetch_url->setPostData($data);
$binary = file_get_contents("http://www.baidu.com/img/shouye_b5486898c692066bd2cbaeda86d74448.gif");
$fetch_url->setBinary("picfile", "demo.jpg", $binary);//上传二进制文件
// $fetch_url->setFile("picfile", "C:/Users/Administrator/Desktop/123.jpg");//上传指定文件
if($fetch_url->errcode() == 0){
$fetch_url->fetch('http://wx.pp.cc/wb_ajax/addwxuser/0');
if($fetch_url->httpCode() == 200){
$html = $fetch_url->body();
echo $html;
}
}else{
echo "errmsg:".$fetch_url->errmsg().", errcode:".$fetch_url->errcode();
}
//返回请求头部信息
print_r($fetch_url->responseHeaders());
//清空之前的请求设置，复用$fetch_url。
$fetch_url->clean();
$fetch_url->fetch("http://www.baidu.com");
print_r($fetch_url->responseHeaders());
三、扩展实现
1.php_fetch_url.h
复制代码 代码如下:
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2012 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: |
+----------------------------------------------------------------------+
*/
/* $Id$ */
#ifndef PHP_FETCH_URL_H
#define PHP_FETCH_URL_H
extern zend_module_entry fetch_url_module_entry;
#define phpext_fetch_url_ptr &fetch_url_module_entry
#ifdef PHP_WIN32
#define PHP_FETCH_URL_API __declspec(dllexport)
#elif defined(__GNUC__) && __GNUC__ >= 4
#define PHP_FETCH_URL_API __attribute__ ((visibility("default")))
#else
#define PHP_FETCH_URL_API
#endif
#ifdef PHP_WIN32
#define FETCH_CURL_MODE CURL_GLOBAL_WIN32
#else
#define FETCH_CURL_MODE CURL_GLOBAL_ALL
#endif
#ifdef ZTS
#include "TSRM.h"
#endif
#define FETCH_CLASS_NAME "FetchUrl"
#define FETCH_CLASS_CE g_fetch_ce
#define FETCH_THIS Z_OBJCE_P(getThis()), getThis()
#define FETCH_ERROR(errmsg, errno) zend_update_property_stringl(FETCH_THIS, ZEND_STRL("errmsg"), errmsg, sizeof(errmsg)-1 TSRMLS_CC);
zend_update_property_long(FETCH_THIS, ZEND_STRL("errno"), errno TSRMLS_CC)
PHP_MINIT_FUNCTION(fetch_url);
PHP_MSHUTDOWN_FUNCTION(fetch_url);
PHP_RINIT_FUNCTION(fetch_url);
PHP_RSHUTDOWN_FUNCTION(fetch_url);
PHP_MINFO_FUNCTION(fetch_url);
#ifdef ZTS
#define FETCH_URL_G(v) TSRMG(fetch_url_globals_id, zend_fetch_url_globals *, v)
#else
#define FETCH_URL_G(v) (fetch_url_globals.v)
#endif
#endif/* PHP_FETCH_URL_H */
2.fetch_url.c
复制代码 代码如下:
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2012 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: |
+----------------------------------------------------------------------+
*/
/* $Id$ */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "php_ini.h"
#include "main/SAPI.h"
#include "Zend/zend_interfaces.h"
#include "ext/standard/info.h"
#include "ext/standard/php_var.h"
#include "ext/standard/php_string.h"
#include "ext/standard/php_smart_str.h"
#include "ext/standard/url.h"
#include "ext/pcre/php_pcre.h"
#include "php_fetch_url.h"
#include <curl/curl.h>
zend_class_entry *g_fetch_ce;
ZEND_BEGIN_ARG_INFO_EX(void_arginfo, 0, 0, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(fetch_arginfo, 0, 0, 1)
ZEND_ARG_INFO(0, url)
ZEND_ARG_INFO(0, callback)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(responseCookies_arginfo, 0, 0, 0)
ZEND_ARG_INFO(0, all)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(responseHeaders_arginfo, 0, 0, 0)
ZEND_ARG_INFO(0, parse)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(setAllowRedirect_arginfo, 0, 0, 0)
ZEND_ARG_INFO(0, allow)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(setConnectTimeout_arginfo, 0, 0, 0)
ZEND_ARG_INFO(0, ms)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(setCookie_arginfo, 0, 0, 2)
ZEND_ARG_INFO(0, name)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(setCookies_arginfo, 0, 0, 1)
ZEND_ARG_INFO(0, cookies)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(setHeader_arginfo, 0, 0, 2)
ZEND_ARG_INFO(0, name)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(setMethod_arginfo, 0, 0, 1)
ZEND_ARG_INFO(0, method)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(setPostData, 0, 0, 1)
ZEND_ARG_INFO(0, post_data)
ZEND_ARG_INFO(0, multil)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(setReadTimeout_arginfo, 0, 0, 0)
ZEND_ARG_INFO(0, ms)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(setBinary_arginfo, 0, 0, 3)
ZEND_ARG_INFO(0, post_filed)
ZEND_ARG_INFO(0, uploadfile_name)
ZEND_ARG_INFO(0, url)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(setFile_arginfo, 0, 0, 2)
ZEND_ARG_INFO(0, post_filed)
ZEND_ARG_INFO(0, path)
ZEND_END_ARG_INFO()
ZEND_METHOD(fetch_url, __construct){
}
ZEND_METHOD(fetch_url, setBinary){
zval *input_filed_name, *binary_data, *uploadfile_name;
zval *g_binary_data, *item_data;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &input_filed_name, &uploadfile_name, &binary_data) == FAILURE){
RETURN_FALSE;
}
if(Z_TYPE_P(input_filed_name) != IS_STRING || Z_TYPE_P(uploadfile_name) != IS_STRING || Z_TYPE_P(binary_data) != IS_STRING){
RETURN_FALSE;
}
g_binary_data = zend_read_property(FETCH_THIS, ZEND_STRL("binary_data"), 0 TSRMLS_CC);
if(Z_TYPE_P(g_binary_data) == IS_NULL){
MAKE_STD_ZVAL(g_binary_data);
array_init(g_binary_data);
}
MAKE_STD_ZVAL(item_data);
array_init(item_data);
add_index_stringl(item_data, 0, Z_STRVAL_P(uploadfile_name), Z_STRLEN_P(uploadfile_name), 1);
add_index_stringl(item_data, 1, Z_STRVAL_P(binary_data), Z_STRLEN_P(binary_data), 1);
add_assoc_zval(g_binary_data, Z_STRVAL_P(input_filed_name), item_data);
zend_update_property(FETCH_THIS, ZEND_STRL("binary_data"), g_binary_data TSRMLS_CC);
}
ZEND_METHOD(fetch_url, setFile){
zval *file_path, *input_filed_name;
zval *upload_filepaths;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &input_filed_name, &file_path) == FAILURE){
RETURN_FALSE;
}
if(Z_TYPE_P(file_path) != IS_STRING || Z_TYPE_P(input_filed_name) != IS_STRING){
RETURN_FALSE;
}
upload_filepaths = zend_read_property(FETCH_THIS, ZEND_STRL("upload_filepaths"), 0 TSRMLS_CC);
if(Z_TYPE_P(upload_filepaths) == IS_NULL){
MAKE_STD_ZVAL(upload_filepaths);
array_init(upload_filepaths);
}
add_assoc_stringl(upload_filepaths, Z_STRVAL_P(input_filed_name), Z_STRVAL_P(file_path), Z_STRLEN_P(file_path), 1);
zend_update_property(FETCH_THIS, ZEND_STRL("upload_filepaths"), upload_filepaths TSRMLS_CC);
}
ZEND_METHOD(fetch_url, body){
zval *zval_body;
zval_body = zend_read_property(FETCH_THIS, ZEND_STRL("body"), 0 TSRMLS_CC);
RETURN_STRINGL(Z_STRVAL_P(zval_body), Z_STRLEN_P(zval_body), 1);
}
ZEND_METHOD(fetch_url, clean){
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("body"), ZEND_STRL("") TSRMLS_CC);
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("errmsg"), ZEND_STRL("") TSRMLS_CC);
zend_update_property_long(FETCH_THIS, ZEND_STRL("errno"), 0 TSRMLS_CC);
zend_update_property_null(FETCH_THIS, ZEND_STRL("httpCode") TSRMLS_CC);
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("cookies"), ZEND_STRL("") TSRMLS_CC);
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("headers"), ZEND_STRL("") TSRMLS_CC);
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("send_headers"), ZEND_STRL("") TSRMLS_CC);
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("data"), ZEND_STRL("") TSRMLS_CC);
zend_update_property_null(FETCH_THIS, ZEND_STRL("binary_data") TSRMLS_CC);
zend_update_property_null(FETCH_THIS, ZEND_STRL("upload_filepaths") TSRMLS_CC);
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("method"), ZEND_STRL("get") TSRMLS_CC);
}
ZEND_METHOD(fetch_url, errmsg){
zval *errmsg = zend_read_property(FETCH_THIS, ZEND_STRL("errmsg"), 0 TSRMLS_CC);
RETURN_STRINGL(Z_STRVAL_P(errmsg), Z_STRLEN_P(errmsg), 1);
}
ZEND_METHOD(fetch_url, errcode){
zval *err_no = zend_read_property(FETCH_THIS, ZEND_STRL("errno"), 0 TSRMLS_CC);
RETURN_LONG(Z_LVAL_P(err_no));
}
static size_t read_data(void *buffer, size_t size, size_t nmemb, void *data){
smart_str *content = (smart_str*)data;
smart_str_appendl(content, buffer, size*nmemb);
return size*nmemb;
}
ZEND_METHOD(fetch_url, fetch){
CURLcode return_code;
CURL *curl_handler;
struct curl_slist *http_headers = NULL;
zval *url, *callback, *cookies, *connect_timeout, *allow_redirect, *method, *post_data, *read_timeout,
*send_headers, *err_no, *errmsg, *binary_data, *upload_filepaths;
smart_str body_str = {0}, header_str = {0};
struct curl_httppost *post = NULL;
struct curl_httppost *last = NULL;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &url, &callback) == FAILURE){
RETURN_FALSE;
}
err_no = zend_read_property(FETCH_THIS, ZEND_STRL("errno"), 0 TSRMLS_CC);
errmsg = zend_read_property(FETCH_THIS, ZEND_STRL("errmsg"), 0 TSRMLS_CC);
if(Z_LVAL_P(err_no) > 0){
php_printf("errno:%d, errmsg:%s", Z_LVAL_P(err_no), Z_STRVAL_P(errmsg));
RETURN_FALSE;
}
if(Z_TYPE_P(url) != IS_STRING){
FETCH_ERROR("fetch url must be string.", 500);
RETURN_FALSE;
}
return_code = curl_global_init(FETCH_CURL_MODE);
if(return_code != CURLE_OK){
curl_global_cleanup();
FETCH_ERROR("curl init failed.", 500);
RETURN_FALSE;
}
curl_handler = curl_easy_init();
if(NULL == curl_handler){
curl_easy_cleanup(curl_handler);
curl_global_cleanup();
FETCH_ERROR("get curl handler failed.", 500);
RETURN_FALSE;
}
cookies = zend_read_property(FETCH_THIS, ZEND_STRL("cookies"), 0 TSRMLS_CC);
connect_timeout = zend_read_property(FETCH_THIS, ZEND_STRL("connect_timeout"), 0 TSRMLS_CC);
read_timeout = zend_read_property(FETCH_THIS, ZEND_STRL("read_timeout"), 0 TSRMLS_CC);
allow_redirect = zend_read_property(FETCH_THIS, ZEND_STRL("allow_redirect"), 0 TSRMLS_CC);
method = zend_read_property(FETCH_THIS, ZEND_STRL("method"), 0 TSRMLS_CC);
post_data = zend_read_property(FETCH_THIS, ZEND_STRL("data"), 0 TSRMLS_CC);
send_headers = zend_read_property(FETCH_THIS, ZEND_STRL("send_headers"), 0 TSRMLS_CC);
binary_data = zend_read_property(FETCH_THIS, ZEND_STRL("binary_data"), 0 TSRMLS_CC);
upload_filepaths = zend_read_property(FETCH_THIS, ZEND_STRL("upload_filepaths"), 0 TSRMLS_CC);
curl_easy_setopt(curl_handler, CURLOPT_URL, Z_STRVAL_P(url));
curl_easy_setopt(curl_handler, CURLOPT_COOKIE, Z_STRVAL_P(cookies));
curl_easy_setopt(curl_handler, CURLOPT_WRITEFUNCTION, &read_data);
curl_easy_setopt(curl_handler, CURLOPT_WRITEDATA, &body_str);
curl_easy_setopt(curl_handler, CURLOPT_HEADERDATA, &header_str);
curl_easy_setopt(curl_handler, CURLOPT_HEADERFUNCTION, &read_data);
curl_easy_setopt(curl_handler, CURLOPT_TIMEOUT, Z_LVAL_P(read_timeout));
curl_easy_setopt(curl_handler, CURLOPT_CONNECTTIMEOUT, Z_LVAL_P(connect_timeout));
curl_easy_setopt(curl_handler, CURLOPT_AUTOREFERER, Z_LVAL_P(allow_redirect));
curl_easy_setopt(curl_handler, CURLOPT_MAXREDIRS, 5);
if(strcmp(Z_STRVAL_P(method), "get") == 0){
curl_easy_setopt(curl_handler, CURLOPT_HTTPGET, 1);
}else{
if(Z_TYPE_P(binary_data) != IS_NULL || Z_TYPE_P(upload_filepaths) != IS_NULL){
zval *delim, *post_arr, *delim_equal;
MAKE_STD_ZVAL(delim_equal);
MAKE_STD_ZVAL(delim);
MAKE_STD_ZVAL(post_arr);
ZVAL_STRING(delim, "&", 1);
ZVAL_STRING(delim_equal, "=", 1);
array_init(post_arr);
php_explode(delim, post_data, post_arr, LONG_MAX);
for(zend_hash_internal_pointer_reset(Z_ARRVAL_P(post_arr));
zend_hash_has_more_elements(Z_ARRVAL_P(post_arr)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(post_arr))){
zval **data_str;
zval *temp_data, **post_data_name, **post_data_value, *temp_zval;
if(zend_hash_get_current_data(Z_ARRVAL_P(post_arr), (void**)&data_str) == FAILURE){
continue;
}
if(Z_STRLEN_PP(data_str) > 0){
MAKE_STD_ZVAL(temp_data);
array_init(temp_data);
temp_zval = *data_str;
php_explode(delim_equal, temp_zval, temp_data, LONG_MAX);
zend_hash_index_find(Z_ARRVAL_P(temp_data), 0, (void**)&post_data_name);
zend_hash_index_find(Z_ARRVAL_P(temp_data), 1, (void**)&post_data_value);
curl_formadd(&post, &last, CURLFORM_COPYNAME, Z_STRVAL_PP(post_data_name), CURLFORM_COPYCONTENTS, Z_STRVAL_PP(post_data_value), CURLFORM_END);
zval_dtor(temp_data);
}
}
zval_dtor(post_arr);
zval_dtor(delim);
zval_dtor(delim_equal);
if(Z_TYPE_P(binary_data) != IS_NULL)
for(zend_hash_internal_pointer_reset(Z_ARRVAL_P(binary_data));
zend_hash_has_more_elements(Z_ARRVAL_P(binary_data)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(binary_data))){
char *input_file_name;
uint input_file_name_len;
ulong idx;
zval **item_data;
zval **upload_binary_data;
zval **uploadfile_name;
if(zend_hash_get_current_key_ex(Z_ARRVAL_P(binary_data), &input_file_name, &input_file_name_len, &idx, 0, NULL) != HASH_KEY_IS_STRING){
continue;
}
if(zend_hash_get_current_data(Z_ARRVAL_P(binary_data), (void**)&item_data) == FAILURE){
continue;
}
zend_hash_index_find(Z_ARRVAL_PP(item_data), 0, (void**)&uploadfile_name);
zend_hash_index_find(Z_ARRVAL_PP(item_data), 1, (void**)&upload_binary_data);
curl_formadd(&post,
&last,
CURLFORM_COPYNAME,
input_file_name,
CURLFORM_BUFFER,
Z_STRVAL_PP(uploadfile_name), //todo:setBinary需要传递文件名参数
CURLFORM_BUFFERPTR,
Z_STRVAL_PP(upload_binary_data),
CURLFORM_BUFFERLENGTH,
Z_STRLEN_PP(upload_binary_data),
CURLFORM_END
);
}
if(Z_TYPE_P(upload_filepaths) != IS_NULL)
for(zend_hash_internal_pointer_reset(Z_ARRVAL_P(upload_filepaths));
zend_hash_has_more_elements(Z_ARRVAL_P(upload_filepaths)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(upload_filepaths))){
char *input_filed_name;
uint input_file_name_len;
ulong idx;
zval **file_path;
if(zend_hash_get_current_key_ex(Z_ARRVAL_P(upload_filepaths), &input_filed_name, &input_file_name_len, &idx, 0, NULL) != HASH_KEY_IS_STRING){
continue;
}
if(zend_hash_get_current_data(Z_ARRVAL_P(upload_filepaths), (void**)&file_path) == FAILURE){
continue;
}
curl_formadd(&post, &last, CURLFORM_COPYNAME, input_filed_name, CURLFORM_FILE, Z_STRVAL_PP(file_path), CURLFORM_END);
}
curl_easy_setopt(curl_handler, CURLOPT_HTTPPOST, post);
http_headers = curl_slist_append(http_headers, estrdup("Expect:"));//防止出现HTTP 100跳转
}else{
curl_easy_setopt(curl_handler, CURLOPT_POSTFIELDS, Z_STRVAL_P(post_data));
curl_easy_setopt(curl_handler, CURLOPT_POST, 1);
}
}
if(Z_TYPE_P(send_headers) == IS_ARRAY && zend_hash_num_elements(Z_ARRVAL_P(send_headers)) > 0){
for(zend_hash_internal_pointer_reset(Z_ARRVAL_P(send_headers));
zend_hash_has_more_elements(Z_ARRVAL_P(send_headers)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(send_headers))){
char *header_key;
uint header_keylen;
ulong idx;
zval **header_val;
smart_str impl_headers = {0};
if(zend_hash_get_current_key_ex(Z_ARRVAL_P(send_headers), &header_key, &header_keylen, &idx, 0, NULL) != HASH_KEY_IS_STRING){
continue;
}
if(zend_hash_get_current_data(Z_ARRVAL_P(send_headers), (void**)&header_val) == FAILURE){
continue;
}
smart_str_appendl(&impl_headers, header_key, header_keylen);
smart_str_appendl(&impl_headers, ": ", 2);
smart_str_appendl(&impl_headers, Z_STRVAL_PP(header_val), Z_STRLEN_PP(header_val));
http_headers = curl_slist_append(http_headers, impl_headers.c);
}
}
curl_easy_setopt(curl_handler, CURLOPT_HTTPHEADER, http_headers);
curl_easy_perform(curl_handler);
curl_slist_free_all(http_headers);
curl_formfree(post);
curl_easy_cleanup(curl_handler);
curl_global_cleanup();
smart_str_0(&body_str);
smart_str_0(&header_str);
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("headers"), header_str.c, header_str.len TSRMLS_CC);
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("body"), body_str.c, body_str.len TSRMLS_CC);
}
ZEND_METHOD(fetch_url, httpCode){
pcre_cache_entry *pce;
zval *headers;
zval *result_match, *match_long, **http_code;
char *regex = estrdup("/^HTTP/1.1s(.*)sOK/");
if((pce = pcre_get_compiled_regex_cache(regex, strlen(regex) TSRMLS_CC)) == NULL){
RETURN_FALSE;
}
MAKE_STD_ZVAL(result_match);
MAKE_STD_ZVAL(match_long);
headers = zend_read_property(FETCH_THIS, ZEND_STRL("headers"), 0 TSRMLS_CC);
php_pcre_match_impl(pce, Z_STRVAL_P(headers), Z_STRLEN_P(headers), match_long, result_match, 0, 0, 0, 0 TSRMLS_CC);
if(Z_LVAL_P(match_long) > 0){
if(zend_hash_index_find(Z_ARRVAL_P(result_match), 1, (void**)&http_code) == FAILURE){
RETURN_FALSE;
}else{
RETURN_STRINGL(Z_STRVAL_PP(http_code), Z_STRLEN_PP(http_code), 0);
}
}else{
RETURN_FALSE;
}
}
ZEND_METHOD(fetch_url, responseCookies){
pcre_cache_entry *pce;
zval *headers, *result_match, *match_long;
char *regex = estrdup("/Set-Cookie:s(.*?);/");
headers = zend_read_property(FETCH_THIS, ZEND_STRL("headers"), 0 TSRMLS_CC);
array_init(return_value);
if(Z_STRLEN_P(headers) > 0){
if((pce = pcre_get_compiled_regex_cache(regex, strlen(regex) TSRMLS_CC)) == NULL){
RETURN_NULL();
}
MAKE_STD_ZVAL(result_match);
MAKE_STD_ZVAL(match_long);
//void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *return_value, zval *subpats, int global, int use_flags, long flags, long start_offset TSRMLS_DC)
php_pcre_match_impl(pce, Z_STRVAL_P(headers), Z_STRLEN_P(headers), match_long, result_match, 1, 0, 0, 0 TSRMLS_CC);
if(Z_LVAL_P(match_long) > 0){
zval **result;
HashTable *result_ht;
char *found = NULL;
long found_offset;
char *cookie_name;
char *cookie_value;
if(zend_hash_index_find(Z_ARRVAL_P(result_match), 1, (void**)&result) != FAILURE){
result_ht = Z_ARRVAL_PP(result);
for(zend_hash_internal_pointer_reset(result_ht);
zend_hash_has_more_elements(result_ht) == SUCCESS;
zend_hash_move_forward(result_ht)){
zval **tmpzval;
if(zend_hash_get_current_data(result_ht, (void**)&tmpzval) == FAILURE){
continue;
}
found = php_memnstr(Z_STRVAL_PP(tmpzval), "=", 1, Z_STRVAL_PP(tmpzval) + Z_STRLEN_PP(tmpzval));
found_offset = found - Z_STRVAL_PP(tmpzval);
cookie_name = estrndup(Z_STRVAL_PP(tmpzval), found_offset);
cookie_value= estrndup(found+1, strlen(found)-1);
add_assoc_stringl(return_value, cookie_name, cookie_value, strlen(cookie_value), 1);
efree(cookie_name);
efree(cookie_value);
}
}
}
}else{
RETURN_NULL();
}
}
ZEND_METHOD(fetch_url, responseHeaders){
zval *headers, *delim;
uint idx;
headers = zend_read_property(FETCH_THIS, ZEND_STRL("headers"), 0 TSRMLS_CC);
MAKE_STD_ZVAL(delim);
array_init(return_value);
ZVAL_STRING(delim, "rn", 1);
php_explode(delim, headers, return_value, LONG_MAX);
idx = zend_hash_num_elements(Z_ARRVAL_P(return_value));
zend_hash_index_del(Z_ARRVAL_P(return_value), idx-1);
zend_hash_index_del(Z_ARRVAL_P(return_value), idx-2);
zval_dtor(delim);
}
ZEND_METHOD(fetch_url, setAllowRedirect){
zval *allow;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &allow) == FAILURE){
RETURN_FALSE;
}
convert_to_long(allow);
zend_update_property_long(FETCH_THIS, ZEND_STRL("allow_redirect"), Z_LVAL_P(allow) TSRMLS_CC);
}
ZEND_METHOD(fetch_url, setConnectTimeout){
zval *connect_timeout;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &connect_timeout) == FAILURE){
RETURN_FALSE;
}
convert_to_long(connect_timeout);
zend_update_property_long(FETCH_THIS, ZEND_STRL("connect_timeout"), Z_LVAL_P(connect_timeout) TSRMLS_CC);
}
ZEND_METHOD(fetch_url, setCookie){
zval *zval_cookies;
zval *cookie_name, *cookie_value;
smart_str impl_cookies = {0};
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &cookie_name, &cookie_value) == FAILURE){
RETURN_FALSE;
}
if(Z_TYPE_P(cookie_name) != IS_STRING || Z_TYPE_P(cookie_value) != IS_STRING){
RETURN_FALSE;
}
zval_cookies = zend_read_property(FETCH_THIS, ZEND_STRL("cookies"), 0 TSRMLS_CC);
smart_str_appendl(&impl_cookies, Z_STRVAL_P(zval_cookies), Z_STRLEN_P(zval_cookies));
smart_str_appendl(&impl_cookies, Z_STRVAL_P(cookie_name), Z_STRLEN_P(cookie_name));
smart_str_appendc(&impl_cookies, '=');
smart_str_appendl(&impl_cookies, Z_STRVAL_P(cookie_value), Z_STRLEN_P(cookie_value));
smart_str_appendc(&impl_cookies, ';');
smart_str_0(&impl_cookies);
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("cookies"), impl_cookies.c, impl_cookies.len TSRMLS_CC);
}
ZEND_METHOD(fetch_url, setCookies){
zval *zval_cookies;
zval *cookie_array;
smart_str impl_cookies = {0};
HashTable *cookies_ht;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &cookie_array) == FAILURE){
RETURN_FALSE;
}
if(Z_TYPE_P(cookie_array) != IS_ARRAY){
RETURN_FALSE;
}
zval_cookies = zend_read_property(FETCH_THIS, ZEND_STRL("cookies"), 0 TSRMLS_CC);
cookies_ht = Z_ARRVAL_P(cookie_array);
smart_str_appendl(&impl_cookies, Z_STRVAL_P(zval_cookies), Z_STRLEN_P(zval_cookies));
for(zend_hash_internal_pointer_reset(cookies_ht);
zend_hash_has_more_elements(cookies_ht) == SUCCESS;
zend_hash_move_forward(cookies_ht))
{
zval **value;
char *key;
uint key_len;
ulong idx;
if(zend_hash_get_current_key_ex(cookies_ht, &key, &key_len, &idx, 0, NULL) != HASH_KEY_IS_STRING){
continue;
}
if(zend_hash_get_current_data(cookies_ht, (void**)&value) == FAILURE){
continue;
}
convert_to_string(*value);
if(Z_TYPE_PP(value) != IS_STRING){
continue;
}
smart_str_appendl(&impl_cookies, key, key_len-1);
smart_str_appendl(&impl_cookies, "=", 1);
smart_str_appendl(&impl_cookies, Z_STRVAL_PP(value), Z_STRLEN_PP(value));
smart_str_appendl(&impl_cookies, ";", 1);
}
php_url_decode(impl_cookies.c, impl_cookies.len);
smart_str_0(&impl_cookies);
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("cookies"), impl_cookies.c, impl_cookies.len TSRMLS_CC);
}
ZEND_METHOD(fetch_url, setHeader){
zval *headers, *value=NULL, *send_headers;
HashTable *headers_ht;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &headers) == FAILURE){
RETURN_FALSE;
}
send_headers = zend_read_property(FETCH_THIS, ZEND_STRL("send_headers"), 0 TSRMLS_CC);
if(Z_TYPE_P(send_headers) == IS_NULL){
MAKE_STD_ZVAL(send_headers);
array_init(send_headers);
}
headers_ht = Z_ARRVAL_P(send_headers);
if(Z_TYPE_P(headers) == IS_ARRAY){
for(zend_hash_internal_pointer_reset(Z_ARRVAL_P(headers));
zend_hash_has_more_elements(Z_ARRVAL_P(headers)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(headers))){
char* key;
uint key_len;
ulong idx;
zval **tmpzval;
if(zend_hash_get_current_key_ex(Z_ARRVAL_P(headers), &key, &key_len, &idx, 0, NULL) != HASH_KEY_IS_STRING){
continue;
}
if(zend_hash_get_current_data(Z_ARRVAL_P(headers), (void**)&tmpzval) == FAILURE){
continue;
}
add_assoc_stringl(send_headers, key, Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval), 1);
}
}else if(Z_TYPE_P(headers) == IS_STRING && Z_TYPE_P(value) == IS_STRING){
add_assoc_stringl(send_headers, Z_STRVAL_P(headers), Z_STRVAL_P(value), Z_STRLEN_P(value), 1);
}else{
zend_error(E_WARNING, "param error.");
}
zend_update_property(FETCH_THIS, ZEND_STRL("send_headers"), send_headers);
}
ZEND_METHOD(fetch_url, setMethod){
zval *zval_method;
char *method;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zval_method) == FAILURE){
RETURN_FALSE;
}
if(Z_TYPE_P(zval_method) != IS_STRING){
RETURN_FALSE;
}
method = php_strtolower(Z_STRVAL_P(zval_method), Z_STRLEN_P(zval_method));
if(strcmp(method, "get") == 0){
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("method"), ZEND_STRL("get") TSRMLS_CC);
}else if(strcmp(method, "post") == 0){
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("method"), ZEND_STRL("post") TSRMLS_CC);
}else{
FETCH_ERROR("Not support method.", 404);
RETURN_FALSE;
}
RETURN_TRUE;
}
ZEND_METHOD(fetch_url, setPostData){
zval *data, *post_data;
HashTable *post_data_ht;
smart_str temp = {0};
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &post_data) == FAILURE){
RETURN_FALSE;
}
data = zend_read_property(FETCH_THIS, ZEND_STRL("data"), 0 TSRMLS_CC);
if(Z_TYPE_P(post_data) != IS_ARRAY){
zend_error(E_WARNING, "post data must be array.");
RETURN_FALSE;
}
post_data_ht = Z_ARRVAL_P(post_data);
smart_str_appendl(&temp, Z_STRVAL_P(data), Z_STRLEN_P(data));
for(zend_hash_internal_pointer_reset(post_data_ht);
zend_hash_has_more_elements(post_data_ht) == SUCCESS;
zend_hash_move_forward(post_data_ht)){
zval **current_data;
char *key;
uint key_len;
ulong idx;
if(zend_hash_get_current_key_ex(post_data_ht, &key, &key_len, &idx, 0, NULL) != HASH_KEY_IS_STRING){
continue;
}
if(zend_hash_get_current_data(post_data_ht, (void**)¤t_data) == FAILURE){
continue;
}
convert_to_string(*current_data);
smart_str_appendl(&temp, key, key_len-1);
smart_str_appendc(&temp, '=');
smart_str_appendl(&temp, Z_STRVAL_PP(current_data), Z_STRLEN_PP(current_data));
smart_str_appendc(&temp, '&');
}
smart_str_0(&temp);
zend_update_property_stringl(FETCH_THIS, ZEND_STRL("data"), temp.c, temp.len TSRMLS_CC);
}
ZEND_METHOD(fetch_url, setReadTimeout){
zval *read_timeout;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &read_timeout) == FAILURE){
RETURN_FALSE;
}
if(Z_TYPE_P(read_timeout) != IS_LONG){
zend_error(E_WARNING, "readtimeout must be integer.");
RETURN_FALSE;
}
zend_update_property_long(FETCH_THIS, ZEND_STRL("read_timeout"), Z_LVAL_P(read_timeout) TSRMLS_CC);
}
ZEND_METHOD(fetch_url, __destruct){}
static zend_function_entry fetch_url_method[] = {
ZEND_ME(fetch_url, __construct, void_arginfo, ZEND_ACC_CTOR|ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, setBinary, setBinary_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, setFile, setFile_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, body, void_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, clean, void_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, errmsg, void_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, errcode, void_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, fetch, fetch_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, httpCode, void_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, responseCookies, responseCookies_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, responseHeaders, responseHeaders_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, setAllowRedirect, setAllowRedirect_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, setConnectTimeout, setConnectTimeout_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, setCookie, setCookie_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, setCookies, setCookies_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, setHeader, setHeader_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, setMethod, setMethod_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, setPostData, setPostData, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, setReadTimeout, setReadTimeout_arginfo, ZEND_ACC_PUBLIC)
ZEND_ME(fetch_url, __destruct, void_arginfo, ZEND_ACC_DTOR|ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
/* If you declare any globals in php_fetch_url.h uncomment this:
ZEND_DECLARE_MODULE_GLOBALS(fetch_url)
*/
/* True global resources - no need for thread safety here */
static int le_fetch_url;
/* {{{ fetch_url_functions[]
*
* Every user visible function must have an entry in fetch_url_functions[].
*/
const zend_function_entry fetch_url_functions[] = {
PHP_FE_END/* Must be the last line in fetch_url_functions[] */
};
/* }}} */
/* {{{ fetch_url_module_entry
*/
zend_module_entry fetch_url_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
STANDARD_MODULE_HEADER,
#endif
"fetch_url",
fetch_url_functions,
PHP_MINIT(fetch_url),
PHP_MSHUTDOWN(fetch_url),
PHP_RINIT(fetch_url),/* Replace with NULL if there's nothing to do at request start */
PHP_RSHUTDOWN(fetch_url),/* Replace with NULL if there's nothing to do at request end */
PHP_MINFO(fetch_url),
#if ZEND_MODULE_API_NO >= 20010901
"0.1", /* Replace with version number for your extension */
#endif
STANDARD_MODULE_PROPERTIES
};
/* }}} */
#ifdef COMPILE_DL_FETCH_URL
ZEND_GET_MODULE(fetch_url)
#endif
/* {{{ PHP_INI
*/
/* Remove comments and fill if you need to have entries in php.ini
PHP_INI_BEGIN()
STD_PHP_INI_ENTRY("fetch_url.global_value", "42", PHP_INI_ALL, OnUpdateLong, global_value, zend_fetch_url_globals, fetch_url_globals)
STD_PHP_INI_ENTRY("fetch_url.global_string", "foobar", PHP_INI_ALL, OnUpdateString, global_string, zend_fetch_url_globals, fetch_url_globals)
PHP_INI_END()
*/
/* }}} */
/* {{{ php_fetch_url_init_globals
*/
/* Uncomment this function if you have INI entries
static void php_fetch_url_init_globals(zend_fetch_url_globals *fetch_url_globals)
{
fetch_url_globals->global_value = 0;
fetch_url_globals->global_string = NULL;
}
*/
/* }}} */
/* {{{ PHP_MINIT_FUNCTION
*/
PHP_MINIT_FUNCTION(fetch_url)
{
/* If you have INI entries, uncomment these lines
REGISTER_INI_ENTRIES();
*/
zend_class_entry fetch_ce;
INIT_CLASS_ENTRY(fetch_ce, FETCH_CLASS_NAME, fetch_url_method);
g_fetch_ce = zend_register_internal_class(&fetch_ce TSRMLS_CC);
zend_declare_property_stringl(g_fetch_ce, ZEND_STRL("body"), ZEND_STRL(""), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(g_fetch_ce, ZEND_STRL("errmsg"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_long(g_fetch_ce, ZEND_STRL("errno"), 0, ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(g_fetch_ce, ZEND_STRL("httpCode"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_stringl(g_fetch_ce, ZEND_STRL("cookies"), ZEND_STRL(""), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_stringl(g_fetch_ce, ZEND_STRL("headers"), ZEND_STRL(""), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(g_fetch_ce, ZEND_STRL("send_headers"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_long(g_fetch_ce, ZEND_STRL("allow_redirect"), 1, ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_long(g_fetch_ce, ZEND_STRL("connect_timeout"), 5, ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_stringl(g_fetch_ce, ZEND_STRL("method"), ZEND_STRL("get"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_long(g_fetch_ce, ZEND_STRL("multilpart"), 0, ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_stringl(g_fetch_ce, ZEND_STRL("data"), ZEND_STRL(""), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_long(g_fetch_ce, ZEND_STRL("read_timeout"), 60, ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(g_fetch_ce, ZEND_STRL("binary_data"), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(g_fetch_ce, ZEND_STRL("upload_filepaths"), ZEND_ACC_PROTECTED TSRMLS_CC);
return SUCCESS;
}
/* }}} */
/* {{{ PHP_MSHUTDOWN_FUNCTION
*/
PHP_MSHUTDOWN_FUNCTION(fetch_url)
{
/* uncomment this line if you have INI entries
UNREGISTER_INI_ENTRIES();
*/
return SUCCESS;
}
/* }}} */
/* Remove if there's nothing to do at request start */
/* {{{ PHP_RINIT_FUNCTION
*/
PHP_RINIT_FUNCTION(fetch_url)
{
return SUCCESS;
}
/* }}} */
/* Remove if there's nothing to do at request end */
/* {{{ PHP_RSHUTDOWN_FUNCTION
*/
PHP_RSHUTDOWN_FUNCTION(fetch_url)
{
return SUCCESS;
}
/* }}} */
/* {{{ PHP_MINFO_FUNCTION
*/
PHP_MINFO_FUNCTION(fetch_url)
{
php_info_print_table_start();
php_info_print_table_header(2, "fetch_url support", "enabled");
php_info_print_table_end();
/* Remove comments if you have entries in php.ini
DISPLAY_INI_ENTRIES();
*/
}
/* }}} */
【用C实现PHP扩展 Fetch_Url 类数据抓取的方法】相关文章：
★ 基于Linux系统调用--getrlimit()与setrlimit()函数的方法