curlApi.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446
  1. /*
  2. * curlApi.c
  3. *
  4. * Created on: 2021/6/1
  5. * Author: foluswen
  6. */
  7. #include <sys/time.h>
  8. #include <sys/timeb.h>
  9. #include <sys/types.h>
  10. #include <sys/stat.h>
  11. #include <sys/types.h>
  12. #include <sys/ioctl.h>
  13. #include <sys/socket.h>
  14. #include <sys/ipc.h>
  15. #include <sys/shm.h>
  16. #include <sys/shm.h>
  17. #include <sys/mman.h>
  18. #include <linux/wireless.h>
  19. #include <arpa/inet.h>
  20. #include <netinet/in.h>
  21. #include <unistd.h>
  22. #include <stdarg.h>
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <unistd.h>
  26. #include <fcntl.h>
  27. #include <termios.h>
  28. #include <errno.h>
  29. #include <errno.h>
  30. #include <string.h>
  31. #include <time.h>
  32. #include <ctype.h>
  33. #include <ifaddrs.h>
  34. #include <signal.h>
  35. #include <curl/curl.h>
  36. #include <curl/easy.h>
  37. #include "SystemLogMessage.h"
  38. #include "curlApi.h"
  39. struct MemoryStruct
  40. {
  41. uint8_t memory[4096];
  42. size_t size;
  43. uint16_t index;
  44. };
  45. struct MemoryStruct chunk;
  46. /**
  47. * HTTP get/post data response callback
  48. * @param contents
  49. * @param size
  50. * @param nmemb
  51. * @param userp
  52. */
  53. static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp)
  54. {
  55. size_t realsize = size*nmemb;
  56. struct MemoryStruct *mem = (struct MemoryStruct *)userp;
  57. mem->size += realsize;;
  58. memcpy(mem->memory + mem->index, contents, realsize);
  59. mem->index += realsize;
  60. return realsize;
  61. }
  62. /**
  63. * HTTP get request/response
  64. * @param url
  65. * @param responseData
  66. * @return
  67. */
  68. int httpGet(uint8_t *url, uint8_t *responseData)
  69. {
  70. int result = FAIL;
  71. CURL *curl;
  72. CURLcode res;
  73. curl_global_init(CURL_GLOBAL_ALL);
  74. curl = curl_easy_init();
  75. memset(&chunk, 0x00, sizeof(struct MemoryStruct));
  76. if(curl)
  77. {
  78. curl_easy_setopt(curl, CURLOPT_URL, (char*)url);
  79. curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
  80. curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
  81. //curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");
  82. //curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)strlen((char*)postData));
  83. curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, FALSE);
  84. //curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_ANY);
  85. //curl_easy_setopt(curl, CURLOPT_USERPWD, "user:password");
  86. curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, 2500L);
  87. struct curl_slist *headers = NULL;
  88. headers = curl_slist_append(headers, "Accept: application/json");
  89. headers = curl_slist_append(headers, "Content-Type: application/json");
  90. headers = curl_slist_append(headers, "charset: utf-8");
  91. curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
  92. headers = curl_slist_append(headers, "length: 20");
  93. headers = curl_slist_append(headers, "numbers: true");
  94. curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  95. res = curl_easy_perform(curl);
  96. long http_code = 0;
  97. curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &http_code);
  98. if(res != CURLE_OK || http_code != 200)
  99. {
  100. DEBUG_ERROR("curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
  101. }
  102. else
  103. {
  104. if(chunk.size > 0)
  105. {
  106. //DEBUG_INFO("Response content: %s\n", chunk.memory);
  107. memcpy(responseData, chunk.memory, ARRAY_SIZE(chunk.memory));
  108. }
  109. result = PASS;
  110. }
  111. curl_easy_cleanup(curl);
  112. }
  113. curl_global_cleanup();
  114. return result;
  115. }
  116. /**
  117. * HTTP post request/response
  118. * @param url
  119. * @param postData
  120. * @return
  121. */
  122. int httpPost(uint8_t *url, uint8_t *postData, uint8_t *responseData)
  123. {
  124. int result = FAIL;
  125. CURL *curl;
  126. CURLcode res;
  127. curl_global_init(CURL_GLOBAL_ALL);
  128. curl = curl_easy_init();
  129. printf("post url : %s\n", url);
  130. printf("post data : %s\n", postData);
  131. memset(&chunk, 0x00, sizeof(struct MemoryStruct));
  132. if(curl)
  133. {
  134. curl_easy_setopt(curl, CURLOPT_URL, (char*)url);
  135. curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
  136. curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
  137. //curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");
  138. curl_easy_setopt(curl, CURLOPT_POSTFIELDS, (char*)postData);
  139. //curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)strlen((char*)postData));
  140. curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, FALSE);
  141. //curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_ANY);
  142. //curl_easy_setopt(curl, CURLOPT_USERPWD, "user:password");
  143. curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, 2500L);
  144. res = curl_easy_perform(curl);
  145. if(res != CURLE_OK)
  146. {
  147. DEBUG_ERROR("curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
  148. }
  149. else
  150. {
  151. if(chunk.size > 0)
  152. {
  153. //DEBUG_INFO("Response content: %s\n", chunk.memory);
  154. memcpy(responseData, chunk.memory, ARRAY_SIZE(chunk.memory));
  155. }
  156. result = PASS;
  157. }
  158. curl_easy_cleanup(curl);
  159. }
  160. curl_global_cleanup();
  161. return result;
  162. }
  163. /**
  164. * HTTP put request
  165. * @param url
  166. * @param postData
  167. * @return
  168. */
  169. int httpPut(uint8_t *url, uint8_t *postData, uint8_t *responseData)
  170. {
  171. int result = FAIL;
  172. CURL *curl;
  173. CURLcode res;
  174. curl_global_init(CURL_GLOBAL_ALL);
  175. curl = curl_easy_init();
  176. memset(&chunk, 0x00, sizeof(struct MemoryStruct));
  177. if(curl)
  178. { struct curl_slist* headerlist = NULL;
  179. struct curl_httppost* formpost = NULL;
  180. struct curl_httppost* lastptr = NULL;
  181. curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
  182. // 设置表头,表头内容可能不同
  183. //headerlist = curl_slist_append(headerlist, "Content-Type:application/x-www-form-urlencoded");
  184. headerlist = curl_slist_append(headerlist, "Content-Type:application/json");
  185. curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
  186. // 设置URL
  187. curl_easy_setopt(curl, CURLOPT_URL, "http://postit.example.com/moo.cgi");
  188. curl_easy_setopt(curl, CURLOPT_URL, (char*)url);
  189. curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
  190. curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
  191. //curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");
  192. curl_easy_setopt(curl, CURLOPT_POSTFIELDS, (char*)postData);
  193. //curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)strlen((char*)postData));
  194. curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
  195. curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
  196. //curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_ANY);
  197. //curl_easy_setopt(curl, CURLOPT_USERPWD, "user:password");
  198. // curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, 2500L);
  199. curl_easy_setopt(curl, CURLOPT_TIMEOUT, 20L);
  200. res = curl_easy_perform(curl);
  201. if(res != CURLE_OK)
  202. {
  203. DEBUG_ERROR("curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
  204. }
  205. else
  206. {
  207. if(chunk.size > 0)
  208. {
  209. //DEBUG_INFO("Response content: %s\n", chunk.memory);
  210. memcpy(responseData, chunk.memory, ARRAY_SIZE(chunk.memory));
  211. }
  212. result = PASS;
  213. }
  214. curl_easy_cleanup(curl);
  215. }
  216. curl_global_cleanup();
  217. return result;
  218. }
  219. /**
  220. * HTTP download response callback
  221. * @param ptr
  222. * @param size
  223. * @param nmemb
  224. * @param stream
  225. * @return
  226. */
  227. static size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream)
  228. {
  229. size_t written = fwrite(ptr, size, nmemb, (FILE *)stream);
  230. return written;
  231. }
  232. /**
  233. * Curl download request
  234. * @param url
  235. * @return
  236. */
  237. int curlDownload(uint8_t *url, uint8_t *filename)
  238. {
  239. int result = FAIL;
  240. CURL *curl;
  241. CURLcode res;
  242. FILE *downloadFile;
  243. curl_global_init(CURL_GLOBAL_ALL);
  244. curl = curl_easy_init();
  245. if(curl)
  246. {
  247. curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, 30000L);
  248. curl_easy_setopt(curl, CURLOPT_URL, (char*)url);
  249. curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
  250. curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, FALSE);
  251. //curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_ANY);
  252. //curl_easy_setopt(curl, CURLOPT_USERPWD, "user:password");
  253. downloadFile = fopen((char*)filename, "wb");
  254. if(downloadFile)
  255. {
  256. curl_easy_setopt(curl, CURLOPT_WRITEDATA, downloadFile);
  257. res = curl_easy_perform(curl);
  258. if(res != CURLE_OK)
  259. {
  260. DEBUG_ERROR("curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
  261. }
  262. else
  263. {
  264. //DEBUG_INFO("Download %s success.\n", url);
  265. result = PASS;
  266. }
  267. fclose(downloadFile);
  268. }
  269. curl_easy_cleanup(curl);
  270. }
  271. curl_global_cleanup();
  272. return result;
  273. }
  274. /**
  275. * HTTP upload request
  276. * @param url
  277. * @param filename
  278. * @return
  279. */
  280. int httpUpload(uint8_t *url, uint8_t *filename)
  281. {
  282. int result = FAIL;
  283. CURL *curl;
  284. CURLcode res;
  285. FILE *upFile;
  286. struct stat file_info;
  287. curl_off_t speed_upload, total_time;
  288. if((upFile = fopen((char*)filename, "rb")))
  289. {
  290. if(fstat(fileno(upFile), &file_info) == 0)
  291. {
  292. curl = curl_easy_init();
  293. if(curl)
  294. {
  295. curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, 30000L);
  296. curl_easy_setopt(curl, CURLOPT_URL, (char*)url);
  297. curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
  298. curl_easy_setopt(curl, CURLOPT_READDATA, upFile);
  299. curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)file_info.st_size);
  300. curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
  301. //curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, FALSE);
  302. //curl_easy_setopt(curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_ANY);
  303. //curl_easy_setopt(curl, CURLOPT_USERPWD, "user:password");
  304. res = curl_easy_perform(curl);
  305. if(res != CURLE_OK)
  306. {
  307. DEBUG_ERROR("curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
  308. }
  309. else
  310. {
  311. curl_easy_getinfo(curl, CURLINFO_SPEED_UPLOAD, &speed_upload);
  312. curl_easy_getinfo(curl, CURLINFO_TOTAL_TIME, &total_time);
  313. /*DEBUG_INFO("Upload %s to %s success.\n", filename, url);
  314. DEBUG_INFO("Speed: %" CURL_FORMAT_CURL_OFF_T " bytes/sec during %"
  315. CURL_FORMAT_CURL_OFF_T ".%06ld seconds\n",
  316. speed_upload,
  317. (total_time / 1000000), (long)(total_time % 1000000));*/
  318. result = PASS;
  319. }
  320. fclose(upFile);
  321. curl_easy_cleanup(curl);
  322. }
  323. }
  324. }
  325. return result;
  326. }
  327. /**
  328. * File read callback
  329. * @param ptr
  330. * @param size
  331. * @param nmemb
  332. * @param stream
  333. * @return
  334. */
  335. static size_t read_callback(char *ptr, size_t size, size_t nmemb, void *stream)
  336. {
  337. curl_off_t nread;
  338. size_t retcode = fread(ptr, size, nmemb, stream);
  339. nread = (curl_off_t)retcode;
  340. DEBUG_INFO("Read %" CURL_FORMAT_CURL_OFF_T " bytes from file\n", nread);
  341. return retcode;
  342. }
  343. /**
  344. * FTP upload request
  345. * @param url
  346. * @param filename
  347. * @return
  348. */
  349. int ftpUpload(uint8_t *url, uint8_t *filename)
  350. {
  351. int result = FAIL;
  352. CURL *curl;
  353. CURLcode res;
  354. FILE *upFile;
  355. struct stat file_info;
  356. curl_off_t fsize;
  357. curl_global_init(CURL_GLOBAL_ALL);
  358. if(!stat((char*)filename, &file_info))
  359. {
  360. fsize = (curl_off_t)file_info.st_size;
  361. DEBUG_INFO("%s size: %" CURL_FORMAT_CURL_OFF_T " bytes.\n", filename, fsize);
  362. if((upFile = fopen((char*)filename, "rb")))
  363. {
  364. curl = curl_easy_init();
  365. if(curl)
  366. {
  367. curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, 30000L);
  368. curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
  369. curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
  370. curl_easy_setopt(curl, CURLOPT_URL, url);
  371. curl_easy_setopt(curl, CURLOPT_READDATA, upFile);
  372. curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fsize);
  373. res = curl_easy_perform(curl);
  374. if(res != CURLE_OK)
  375. {
  376. DEBUG_ERROR("curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
  377. }
  378. else
  379. {
  380. //DEBUG_INFO("Upload %s success.\n", url);
  381. }
  382. curl_easy_cleanup(curl);
  383. }
  384. fclose(upFile);
  385. }
  386. }
  387. curl_global_cleanup();
  388. return result;
  389. }