开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 外挂编程 > 查看源码
http-reader.cpp.svn-base
资源名称：openkore-2.0.7.zip　[点击查看]
上传用户：market2
上传日期：2018-11-18
资源大小：18786k
文件大小：8k
源码类别：

外挂编程

开发平台：

Windows_Unix

http-reader.cpp.svn-base：源码内容
  1. /*  Asynchronous HTTP client
  2.  *  Copyright (C) 2006   Written by VCL
  3.  *
  4.  *  This program is free software; you can redistribute it and/or modify
  5.  *  it under the terms of the GNU General Public License as published by
  6.  *  the Free Software Foundation; either version 2 of the License, or
  7.  *  (at your option) any later version.
  8.  *
  9.  *  This program is distributed in the hope that it will be useful,
  10.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *  GNU General Public License for more details.
  13.  *
  14.  *  You should have received a copy of the GNU General Public License
  15.  *  along with this program; if not, write to the Free Software
  16.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17.  */
  19. using namespace std;
  21. /**
  22.  * A private class used by UnixHttpReader. Most of the logic are
  23.  * contained in this class.
  24.  *
  25.  * The main reason this class exists is because it has reference counting
  26.  * support. That is necessary because it is not safe to use Curl handles
  27.  * in multiple threads, which complicates cancellation. Reference counting
  28.  * support makes it possible to do the cancellation in the Curl thread,
  29.  * while making UnixHttpReader's destructor non-blocking.
  30.  */
  31. class Private: public HttpReader {
  32. private:
  33. unsigned int refCount;
  34. HttpReaderStatus status;
  35. char *error;
  36. char errorBuffer[CURL_ERROR_SIZE];
  37. int size;
  39. /** @invariant url != NULL */
  40. char *url;
  41. char *postData;
  42. int postDataSize;
  43. /** @invariant userAgent != NULL */
  44. char *userAgent;
  45. bool mutexInitialized;
  46. pthread_mutex_t mutex;
  47. pthread_t thread;
  49. CURL *handle;
  50. string downloadBuffer;
  52. static size_t
  53. writeCallback(void *ptr, size_t size, size_t nmemb, void *user_data) {
  54. Private *self = (Private *) user_data;
  56. self->lock();
  58. self->status = HTTP_READER_DOWNLOADING;
  59. self->downloadBuffer.append(static_cast<const char *>(ptr), size * nmemb);
  61. if (self->size == -1) {
  62. double length;
  64. curl_easy_getinfo(self->handle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &length);
  65. if (length != 0) {
  66. self->size = (unsigned int) length;
  67. }
  68. }
  70. self->unlock();
  71. return size * nmemb;
  72. }
  74. /**
  75.  * @require this->size == -1 && this->status == HTTP_READER_CONNECTING
  76.  */
  77. static void *
  78. threadEntry(void *user_data) {
  79. Private *self = (Private *) user_data;
  81. self->handle = curl_easy_init();
  82. if (self->handle != NULL) {
  83. curl_easy_setopt(self->handle, CURLOPT_URL, self->url);
  84. curl_easy_setopt(self->handle, CURLOPT_FOLLOWLOCATION, 1);
  85. curl_easy_setopt(self->handle, CURLOPT_USERAGENT, self->userAgent);
  86. curl_easy_setopt(self->handle, CURLOPT_WRITEFUNCTION, writeCallback);
  87. curl_easy_setopt(self->handle, CURLOPT_WRITEDATA, self);
  88. curl_easy_setopt(self->handle, CURLOPT_FAILONERROR, 1);
  89. curl_easy_setopt(self->handle, CURLOPT_ERRORBUFFER, self->errorBuffer);
  90. if (self->postData != NULL) {
  91. curl_easy_setopt(self->handle, CURLOPT_POST, 1);
  92. curl_easy_setopt(self->handle, CURLOPT_POSTFIELDS, self->postData);
  93. curl_easy_setopt(self->handle, CURLOPT_POSTFIELDSIZE, self->postDataSize);
  94. }
  96. if (curl_easy_perform(self->handle) == 0) {
  97. self->lock();
  98. self->status = HTTP_READER_DONE;
  99. self->unlock();
  100. } else {
  101. self->lock();
  102. self->status = HTTP_READER_ERROR;
  103. self->error = self->errorBuffer;
  104. self->size = -2;
  105. self->unlock();
  106. }
  107. } else {
  108. self->lock();
  109. self->status = HTTP_READER_ERROR;
  110. self->error = "Cannot initialize libcurl.";
  111. self->size = -2;
  112. self->unlock();
  113. }
  115. self->unref();
  116. return NULL;
  117. }
  119. void
  120. lock() const {
  121. if (mutexInitialized) {
  122. pthread_mutex_lock((pthread_mutex_t *) &mutex);
  123. }
  124. }
  126. void
  127. unlock() const {
  128. if (mutexInitialized) {
  129. pthread_mutex_unlock((pthread_mutex_t *) &mutex);
  130. }
  131. }
  133. public:
  134. Private(const char *url, const char *postData, int postDataSize, const char *userAgent) {
  135. refCount = 1;
  136. this->url = NULL;
  137. this->postData = NULL;
  138. this->userAgent = NULL;
  139. handle = NULL;
  140. status = HTTP_READER_ERROR;
  141. size = -2;
  143. if (pthread_mutex_init(&mutex, NULL) != 0) {
  144. error = "Cannot initialize mutex.";
  145. mutexInitialized = false;
  146. return;
  147. } else {
  148. mutexInitialized = true;
  149. }
  151. pthread_attr_t attr;
  152. if (pthread_attr_init(&attr) != 0) {
  153. error = "Cannot create thread attribute object.";
  154. return;
  155. }
  156. if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0) {
  157. pthread_attr_destroy(&attr);
  158. error = "Cannot set thread attribute to detached.";
  159. return;
  160. }
  162. this->url = strdup(url);
  163. if (postData != NULL) {
  164. if (postDataSize == -1) {
  165. postDataSize = strlen(postData);
  166. }
  167. this->postData = (char *) malloc(postDataSize);
  168. if (this->postData != NULL) {
  169. memcpy(this->postData, postData, postDataSize);
  170. this->postDataSize = postDataSize;
  171. } else {
  172. error = "Cannot allocate memory for POST data.";
  173. return;
  174. }
  175. }
  176. this->userAgent = strdup(userAgent);
  178. status = HTTP_READER_CONNECTING;
  179. error = NULL;
  180. size = -1;
  181. ref();
  182. if (pthread_create(&thread, &attr, threadEntry, this) != 0) {
  183. unref();
  184. pthread_attr_destroy(&attr);
  185. status = HTTP_READER_ERROR;
  186. error = "Cannot create a thread.";
  187. size = -2;
  188. }
  189. }
  191. ~Private() {
  192. if (url != NULL)
  193. free(url);
  194. if (postData != NULL)
  195. free(postData);
  196. if (userAgent != NULL)
  197. free(userAgent);
  198. if (handle != NULL)
  199. curl_easy_cleanup(handle);
  200. if (mutexInitialized)
  201. pthread_mutex_destroy(&mutex);
  202. }
  204. /**
  205.  * Increase the reference count by 1.
  206.  */
  207. void
  208. ref() {
  209. lock();
  210. refCount++;
  211. unlock();
  212. }
  214. /**
  215.  * Decrease the reference count by 1. The object will
  216.  * be destroyed when the reference count drops to 0.
  217.  */
  218. void
  219. unref() {
  220. bool mustDelete;
  222. lock();
  223. refCount--;
  224. mustDelete = refCount == 0;
  225. unlock();
  226. if (mustDelete) {
  227. delete this;
  228. }
  229. }
  231. virtual HttpReaderStatus
  232. getStatus() const {
  233. HttpReaderStatus result;
  235. lock();
  236. result = status;
  237. unlock();
  238. return result;
  239. }
  241. virtual const char *
  242. getError() const {
  243. const char *result;
  245. lock();
  246. result = error;
  247. unlock();
  248. return result;
  249. }
  251. virtual int
  252. pullData(void *buf, unsigned int size) {
  253. int result;
  255. lock();
  257. switch (status) {
  258. case HTTP_READER_ERROR:
  259. result = -2;
  260. break;
  261. case HTTP_READER_DONE:
  262. if (downloadBuffer.empty()) {
  263. result = 0;
  264. } else {
  265. result = (downloadBuffer.size() > size) ?
  266. size :
  267. downloadBuffer.size();
  268. downloadBuffer.copy(reinterpret_cast<char *>(buf), result);
  269. downloadBuffer.erase(0, result);
  270. }
  271. break;
  272. case HTTP_READER_DOWNLOADING:
  273. if (downloadBuffer.empty()) {
  274. result = -1;
  275. } else {
  276. result = (downloadBuffer.size() > size) ?
  277. size :
  278. downloadBuffer.size();
  279. downloadBuffer.copy(reinterpret_cast<char *>(buf), result);
  280. downloadBuffer.erase(0, result);
  281. }
  282. break;
  283. default:
  284. result = -2;
  285. fprintf(stderr, "StdHttpReader: invalid status %dn", status);
  286. abort();
  287. break;
  288. };
  290. unlock();
  292. return result;
  293. }
  295. virtual const char *
  296. getData(unsigned int &len) const {
  297. len = downloadBuffer.size();
  298. return downloadBuffer.data();
  299. }
  301. virtual int
  302. getSize() const {
  303. int result;
  305. lock();
  306. result = size;
  307. unlock();
  308. return result;
  309. }
  310. };
  313. class UnixHttpReader: public StdHttpReader {
  314. private:
  315. Private *priv;
  316. public:
  317. UnixHttpReader(const char *url,
  318.        const char *postData,
  319.        int postDataSize,
  320.        const char *userAgent) {
  321. priv = new Private(url, postData, postDataSize, userAgent);
  322. }
  324. ~UnixHttpReader() {
  325. priv->unref();
  326. }
  328. virtual HttpReaderStatus
  329. getStatus() const {
  330. return priv->getStatus();
  331. }
  333. virtual const char *
  334. getError() const {
  335. assert(getStatus() == HTTP_READER_ERROR);
  336. return priv->getError();
  337. }
  339. virtual int
  340. pullData(void *buf, unsigned int size) {
  341. assert(getStatus() != HTTP_READER_CONNECTING);
  342. assert(buf != NULL);
  343. assert(size > 0);
  344. return priv->pullData(buf, size);
  345. }
  347. virtual const char *
  348. getData(unsigned int &len) const {
  349. assert(getStatus() == HTTP_READER_DONE);
  350. return priv->getData(len);
  351. }
  353. virtual int
  354. getSize() const {
  355. assert(getStatus() != HTTP_READER_CONNECTING);
  356. return priv->getSize();
  357. }
  359. static void
  360. init() {
  361. curl_global_init(CURL_GLOBAL_ALL);
  362. }
  363. };