devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

HTTP客户端(libcurl) & HTTP服务端(libevent)_libcurl http服务端

作者：繁依Fanyi0 | 2024-06-07 12:51:23

赞

踩

libcurl http服务端
  1. #include <ctype.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <errno.h>
  5. #include <string.h>
  6. #include <stdint.h>
  7. #include <stdbool.h>
  8. #include <libgen.h>
  9. #include <sys/types.h>
  10. #include <sys/time.h>
  11. #include <signal.h>
  12. #include <unistd.h>
  13. #include <fcntl.h>
  14. #include <jansson.h>
  15. #include <curl/curl.h>
  16. #include "log.h"
  17.  
  18. #ifndef likely
  19. #define likely(x) __builtin_expect(!!(x), 1)
  20. #endif
  21.  
  22. #ifndef unlikely
  23. #define unlikely(x) __builtin_expect(!!(x), 0)
  24. #endif
  25.  
  26. typedef struct data_t
  27. {
  28.     unsigned char *value;
  29.     unsigned int length;
  30. }data_t;
  31.  
  32. static volatile sig_atomic_t isterm = 0;   // 结束信号
  33. static volatile sig_atomic_t isalarm = 0;  // 时钟信号
  34.  
  35. // 中断后的信号处理函数
  36. static void signals_handler(int sig, siginfo_t *si, void *context)
  37. {
  38. 	static siginfo_t empty_siginfo;
  39. 	if(!si) si = &empty_siginfo;
  40. 	switch(sig)
  41. 	{
  42. 		case SIGINT: case SIGTERM:
  43. 			isterm = sig;
  44. 			break;
  45. 		case SIGPIPE:
  46. 			break;
  47. 		case SIGALRM: 
  48. 			isalarm = sig;
  49. 			break;
  50. 		default:
  51. 			break;
  52. 	}
  53. }
  54.  
  55. // 注册信号中断
  56. static void signals_register()
  57. {
  58. 	struct sigaction act;
  59. 	struct itimerval interval;
  60.  
  61. 	sigfillset(&act.sa_mask);
  62. 	sigdelset(&act.sa_mask, SIGINT);
  63. 	sigdelset(&act.sa_mask, SIGTERM);
  64. 	sigdelset(&act.sa_mask, SIGPIPE);
  65. 	sigdelset(&act.sa_mask, SIGALRM);
  66. 	sigprocmask(SIG_SETMASK, &act.sa_mask, NULL);
  67.  
  68. 	act.sa_flags = SA_SIGINFO;
  69. 	act.sa_sigaction = signals_handler;
  70.  
  71. 	interval.it_interval.tv_sec = 1;
  72. 	interval.it_interval.tv_usec = 0;
  73. 	interval.it_value.tv_sec = 1;
  74. 	interval.it_value.tv_usec = 0;
  75.  
  76. 	sigaction(SIGINT, &act, NULL);
  77. 	sigaction(SIGTERM, &act, NULL);
  78. 	sigaction(SIGPIPE, &act, NULL);
  79. 	sigaction(SIGALRM, &act, NULL);
  80. 	setitimer(ITIMER_REAL, &interval, NULL);
  81. }
  82.  
  83. static size_t recv_head_callback(char *ptr, size_t size, size_t nmemb, void *userdata)
  84. {
  85.     data_t *recv_head = (data_t*)userdata;
  86.     unsigned int append = size*nmemb;
  87.  
  88.     recv_head->value = (unsigned char*)realloc(recv_head->value, recv_head->length+append+1);
  89.     if(!recv_head->value)
  90.         return -1;
  91.  
  92.     memcpy(recv_head->value+recv_head->length, ptr, append);
  93.     recv_head->length += append;
  94.     recv_head->value[recv_head->length] = 0;
  95.  
  96.     log_debug("recv http response head: %s", recv_head->value);
  97.     return size*nmemb;
  98. }
  99.  
  100. static size_t recv_body_callback(char *ptr, size_t size, size_t nmemb, void *userdata)
  101. {
  102.     data_t *recv_body = (data_t*)userdata;
  103. 	unsigned int append = size*nmemb;
  104.  
  105.     recv_body->value = (unsigned char*)realloc(recv_body->value, recv_body->length+append+1);
  106.     if(!recv_body->value)
  107.         return -1;
  108.  
  109.     memcpy(recv_body->value+recv_body->length, ptr, append);
  110.     recv_body->length += append;
  111. 	recv_body->value[recv_body->length] = 0;
  112.  
  113.     log_debug("recv http response body: %s", recv_body->value);
  114.     return size*nmemb;
  115. }
  116.  
  117. static int jsonrpc_request_url(char *url)
  118. {
  119.     CURL *curl = NULL;
  120.     CURLcode rcode;
  121.     struct curl_slist *headers = NULL;
  122.  
  123.     json_t *json_req = NULL;
  124.     json_t *json_res = NULL;
  125.     data_t send_body, recv_head, recv_body;
  126.     memset(&send_body, 0, sizeof(data_t));
  127.     memset(&recv_head, 0, sizeof(data_t));
  128.     memset(&recv_body, 0, sizeof(data_t));
  129.  
  130.     rcode = curl_global_init(CURL_GLOBAL_ALL);
  131.     if(rcode != CURLE_OK)
  132.     {
  133.         log_error("curl global init failed: %s", curl_easy_strerror(rcode));
  134.         return -1;
  135.     }
  136.  
  137.     curl = curl_easy_init();
  138.     if(!curl)
  139.     {
  140.         log_error("curl easy init failed: %s", curl_easy_strerror(rcode));
  141.         goto ErrP;
  142.     }
  143.  
  144.     json_req = json_pack("{ s:s, s:s, s:s }", "jsonrpc", "2.0", "method", "jsonrpc", "id", "1");
  145.     if(json_req == NULL)
  146.     {
  147.         log_error("json pack http request body failed");
  148.         goto ErrP;
  149.     }
  150.  
  151.     send_body.value = (unsigned char *)json_dumps(json_req, 0);
  152.     send_body.length = strlen((const char *)send_body.value);
  153.  
  154.     curl_easy_setopt(curl, CURLOPT_URL, url);
  155.     curl_easy_setopt(curl, CURLOPT_POST, 1L);
  156.  
  157.     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, send_body.value);
  158.     curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, send_body.length);
  159.  
  160.     curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST|CURLAUTH_BASIC);
  161.     curl_easy_setopt(curl, CURLOPT_USERPWD, "admin:111111");
  162.  
  163.     curl_easy_setopt(curl, CURLOPT_COOKIE, "tool=curl; fun=yes;");
  164.     curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
  165.  
  166.     curl_easy_setopt(curl, CURLOPT_TIMEOUT, 3L);
  167.     curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
  168.     curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
  169.  
  170.     headers = curl_slist_append(headers, "Accept: text/json");
  171.     headers = curl_slist_append(headers, "Content-Type: text/json; charset=UTF-8");
  172.     headers = curl_slist_append(headers, "Connection: keep-alive");
  173.     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  174.  
  175.     curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, recv_head_callback);
  176.     curl_easy_setopt(curl, CURLOPT_HEADERDATA, &recv_head);
  177.  
  178.     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, recv_body_callback);
  179.     curl_easy_setopt(curl, CURLOPT_WRITEDATA, &recv_body);
  180.  
  181.     rcode = curl_easy_perform(curl);
  182.     if(rcode != CURLE_OK)
  183.     {
  184.         log_error("curl easy perform failed: %s", curl_easy_strerror(rcode));
  185.         goto ErrP;
  186.     }
  187.  
  188.     unsigned int code = 200;
  189.     rcode = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
  190.     if(rcode != CURLE_OK || code != 200)
  191.     {
  192.         log_error("Response-Code: %d", code);
  193.         goto ErrP;
  194.     }
  195.  
  196.     unsigned char *ct;
  197.     rcode = curl_easy_getinfo(curl, CURLINFO_CONTENT_TYPE, &ct);
  198.     if(rcode == CURLE_OK)
  199.     {
  200.         log_debug("Content-Type: %s", ct);
  201.     }
  202.  
  203.     json_res = json_loadb((const char *)(recv_body.value), recv_body.length, 0, NULL);
  204.     if(json_res == NULL)
  205.     {
  206.         log_error("json unpack http response body failed");
  207.         goto ErrP;
  208.     }
  209.  
  210.     json_t *json_result = json_object_get(json_res, "result");
  211.     char *buf_result = (char*)json_string_value(json_result);
  212.     if(!json_result || !buf_result || strncasecmp(buf_result, "succeed", 7))
  213.     {
  214.         log_error("jsonrpc request url result failed");
  215.         goto ErrP;
  216.     }
  217.     log_info("jsonrpc request url result succeed");
  218.     
  219.     if(send_body.value) free(send_body.value);
  220.     if(json_req) json_decref(json_req);
  221.  
  222.     if(recv_head.value) free(recv_head.value);
  223.     if(recv_body.value) free(recv_body.value);
  224.     if(json_res) json_decref(json_res);
  225.  
  226.     if(headers) curl_slist_free_all(headers);
  227.     if(curl) curl_easy_cleanup(curl);
  228.     curl_global_cleanup();
  229.     return 0;
  230. ErrP:
  231.     if(send_body.value) free(send_body.value);
  232.     if(json_req) json_decref(json_req);
  233.  
  234.     if(recv_head.value) free(recv_head.value);
  235.     if(recv_body.value) free(recv_body.value);
  236.     if(json_res) json_decref(json_res);
  237.  
  238.     if(headers) curl_slist_free_all(headers);
  239.     if(curl) curl_easy_cleanup(curl);
  240.     curl_global_cleanup();
  241.     return -1;
  242. }
  243.  
  244. int main(int argc, char *argv[])
  245. {
  246. 	int ret = 0;
  247.  
  248.     log_open(basename(argv[0]), 1);
  249.  
  250. #if 0
  251. 	if(argc != 2)
  252. 	{
  253. 		log_error("Usage: %s URL", argv[0]);
  254. 		return -1;
  255. 	}
  256. #endif
  257.  
  258. 	signals_register();
  259. 	while(!isterm)
  260. 	{
  261. 		if(unlikely(isterm))
  262. 		{
  263. 			log_info("term signal: %d", isterm);
  264. 			isterm = 0;
  265. 		}
  266.  
  267. 		if(likely(isalarm))
  268. 		{
  269. 			log_info("alarm signal: %d", isalarm);
  270. 			isalarm = 0;
  271.  
  272. 	        ret = jsonrpc_request_url(argv[1] ? argv[1] : "http://127.0.0.1:1990/jsonrpc.php");
  273. 	        if(ret != 0)
  274. 	        {
  275. 	        	log_error("jsonrpc request url failed: %d", ret);
  276. 	        	break;
  277. 	        }
  278. 	            
  279. 		}
  280.  
  281. 		sleep(-1);
  282. 	}
  283.  
  284. 	log_close();
  285. 	return ret;
  286. }

  1. #include <sys/wait.h>
  2. #include <sys/types.h>
  3. #include <unistd.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <errno.h>
  7. #include <string.h>
  8. #include <stdint.h>
  9. #include <stdbool.h>
  10. #include <libgen.h>
  11. #include <signal.h>
  12. #include <event.h>
  13. #include <evhttp.h>
  14. #include <event2/event.h>
  15. #include <event2/thread.h>
  16. #include <event2/buffer.h>
  17. #include <event2/bufferevent.h>
  18. #include <event2/util.h>
  19. #include <event2/dns.h>
  20. #include <event2/http.h>
  21. #include <event2/rpc.h>
  22. #include <jansson.h>
  23. #include "log.h"
  24.  
  25. static void jsonrpc_request_cb(struct evhttp_request *req, void *arg)
  26. {
  27. 	struct evkeyvalq *headers = NULL;
  28. 	struct evkeyval *header = NULL;
  29.  
  30. 	struct evbuffer *req_evb = NULL;
  31. 	struct evbuffer *res_evb = NULL;
  32.  
  33. 	int ret = 0;
  34. 	int req_len = 0;
  35. 	char *req_buf = NULL;
  36. 	char *res_buf = NULL;
  37. 	json_t *req_json = NULL;
  38. 	json_t *res_json = NULL;
  39.  
  40. 	if(evhttp_request_get_command(req) != EVHTTP_REQ_POST)
  41. 	{
  42. 		log_error("jsonrpc_request_cb EVHTTP_REQ_POST failed");
  43. 		goto EndP;
  44. 	}
  45.  
  46. 	headers = evhttp_request_get_input_headers(req);
  47. 	for (header = headers->tqh_first; header; header = header->next.tqe_next)
  48. 		log_debug("%s: %s", header->key, header->value);
  49.  
  50. 	req_evb = evhttp_request_get_input_buffer(req);
  51. 	req_len = evbuffer_get_length(req_evb);
  52.  
  53. 	req_buf = (char*)malloc(req_len+1);
  54. 	if(!req_buf)
  55. 	{
  56. 		log_error("malloc failed");
  57. 		goto EndP;
  58. 	}
  59. 	memset(req_buf, 0, req_len+1);
  60.  
  61. 	ret = evbuffer_remove(req_evb, req_buf, req_len);
  62. 	if(ret != req_len)
  63. 	{
  64. 		log_error("evbuffer_copyout failed");
  65. 		goto EndP;
  66. 	}
  67. 	req_buf[req_len] = 0;
  68. 	log_info("Request: %s", req_buf);
  69.  
  70. 	req_json = json_loadb((const char *)req_buf, req_len, 0, NULL);
  71.     if(!req_json)
  72.     {
  73.         log_error("jsonrpc_request_cb json_loadb failed: %s", strerror(errno));
  74.         goto EndP;
  75.     }
  76.  
  77.     json_t *method_json = json_object_get(req_json, "method");
  78.     char *method_buf = (char*)json_string_value(method_json);
  79.     if(!method_json || !method_buf || strncasecmp(method_buf, "jsonrpc", 7))
  80.     {
  81.     	log_error("jsonrpc_request_cb method failed");
  82.         goto EndP;
  83.     }
  84.  
  85. 	evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "text/json; charset=UTF-8");
  86. 	evhttp_add_header(evhttp_request_get_output_headers(req), "Connection", "keep-alive");
  87.  
  88. 	res_json = json_pack("{ s:s, s:s, s:s }", "jsonrpc", "2.0", "result", "succeed", "id", "1");
  89. 	if(!res_json)
  90. 	{
  91. 		log_error("jsonrpc_request_cb json_pack failed: %s", strerror(errno));
  92. 		goto EndP;
  93. 	}
  94.  
  95. 	res_buf = json_dumps(res_json, 0);
  96. 	if(!res_buf)
  97. 	{
  98. 		log_error("jsonrpc_request_cb json_dunmps failed: %s", strerror(errno));
  99. 		goto EndP;
  100. 	}
  101.  
  102. 	res_evb = evbuffer_new();
  103. 	if(!res_evb)
  104. 	{
  105. 		log_error("jsonrpc_request_cb evbuffer_new failed: %s", strerror(errno));
  106. 		goto EndP;
  107. 	}
  108. 	evbuffer_add_printf(res_evb, "%s", res_buf);
  109. 	log_info("Response: %s", res_buf);
  110.  
  111. 	evhttp_send_reply(req, HTTP_OK, "OK", res_evb);
  112. 	if(res_evb) evbuffer_free(res_evb);
  113. 	if(res_buf) free(res_buf);
  114. 	if(res_json) json_decref(res_json);
  115. 	if(req_json) json_decref(req_json);
  116. 	if(req_buf) free(req_buf);
  117. 	return;
  118. EndP:
  119. 	evhttp_send_error(req, HTTP_BADMETHOD, "BAD METHOD");
  120. 	if(res_evb) evbuffer_free(res_evb);
  121. 	if(res_buf) free(res_buf);
  122. 	if(res_json) json_decref(res_json);
  123. 	if(req_json) json_decref(req_json);
  124. 	if(req_buf) free(req_buf);
  125. 	return;
  126. }
  127.  
  128. static void default_request_cb(struct evhttp_request *req, void *arg)
  129. {
  130. 	evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "text/plain; charset=UTF-8");
  131. 	evhttp_add_header(evhttp_request_get_output_headers(req), "Connection", "close");
  132. 	evhttp_send_error(req, HTTP_NOTFOUND, "NOT FOUND");
  133. }
  134.  
  135. static void term_evsignal_cb(evutil_socket_t fd, short event, void *arg)
  136. {
  137. 	struct event_base *base = arg;
  138. 	struct timeval tv = { 1, 0 };
  139.  
  140. 	log_info("term signal: %d", SIGINT);
  141. 	event_base_loopexit(base, &tv);
  142. }
  143.  
  144. static void alrm_evsignal_cb(evutil_socket_t fd, short event, void *arg)
  145. {
  146. 	//struct event *signal_alrm = arg;
  147.  
  148. 	log_info("alrm signal: %d", SIGALRM);
  149. 	//event_del(signal_alrm);
  150. }
  151.  
  152. static void cycle_timout_cb(evutil_socket_t fd, short event, void *arg)
  153. {
  154. 	struct timeval tv = {1, 0};
  155. 	log_info("cycle timeout callback");
  156. 	event_add(*(struct event**)arg, &tv);
  157. }
  158.  
  159. int main(int argc, char *argv[])
  160. {
  161. 	int ret = 0;
  162. 	char *server_ip = "0.0.0.0";
  163. 	unsigned short server_port = 1990;
  164.  
  165. 	struct event_base *base = NULL;
  166. 	struct evhttp *http = NULL;
  167. 	struct evhttp_bound_socket *handle = NULL;
  168. 	evutil_socket_t server_fd = -1;
  169. 	struct event *timeout = NULL;
  170. 	struct event *signal_int = NULL;
  171. 	struct event signal_alrm;
  172.  
  173. 	log_open(basename(argv[0]), 1);
  174.  
  175. 	base = event_base_new();
  176. 	if(!base)
  177. 	{
  178. 		log_error("event_base_new failed: %s", strerror(errno));
  179. 		goto ErrP;
  180. 	}
  181.  
  182. 	struct timeval tv = {1, 0};
  183. 	timeout = event_new(base, -1, 0, cycle_timout_cb, (void*)&timeout);
  184. 	if(!timeout)
  185. 	{
  186. 		log_error("evtimer_new failed: %s", strerror(errno));
  187. 		goto ErrP;
  188. 	}
  189. 	event_add(timeout, &tv);
  190.  
  191. 	signal_int = event_new(base, SIGINT, EV_SIGNAL|EV_PERSIST, term_evsignal_cb, (void *)base);
  192. 	if(!signal_int)
  193. 	{
  194. 		log_error("evsignal_new failed: %s", strerror(errno));
  195. 		goto ErrP;
  196. 	}
  197. 	event_add(signal_int, NULL);
  198.  
  199. 	ret = event_assign(&signal_alrm, base, SIGALRM, EV_SIGNAL|EV_PERSIST, alrm_evsignal_cb, (void *)&signal_alrm);
  200. 	if(ret != 0)
  201. 	{
  202. 		log_error("evsignal_assign failed: %s", strerror(errno));
  203. 		goto ErrP;
  204. 	}
  205. 	event_add(&signal_alrm, NULL);
  206.  
  207. 	http = evhttp_new(base);
  208. 	if(!http)
  209. 	{
  210. 		log_error("evhttp_new failed: %s", strerror(errno));
  211. 		goto ErrP;
  212. 	}
  213.  
  214. 	handle = evhttp_bind_socket_with_handle(http, server_ip, server_port);
  215. 	if(!handle)
  216. 	{
  217. 		log_error("evhttp_bind_socket_with_handle failed: %s", strerror(errno));
  218. 		goto ErrP;
  219. 	}
  220. 	server_fd = evhttp_bound_socket_get_fd(handle);
  221. 	log_info("evhttp_bind_socket_with_handle succeed: %d", server_fd);
  222.  
  223. 	evhttp_set_timeout(http, 120);
  224. 	evhttp_set_cb(http, "/jsonrpc.php", jsonrpc_request_cb, &base);
  225. 	evhttp_set_gencb(http, default_request_cb, &base);
  226.  
  227. 	event_base_dispatch(base);
  228.  
  229. 	if(http) evhttp_free(http);
  230. 	if(signal_int) event_free(signal_int);
  231. 	if(timeout) event_free(timeout);
  232. 	if(base) event_base_free(base);
  233. 	log_close();
  234. 	return 0;
  235. ErrP:
  236. 	if(http) evhttp_free(http);
  237. 	if(signal_int) event_free(signal_int);
  238. 	if(timeout) event_free(timeout);
  239. 	if(base) event_base_free(base);
  240. 	log_close();
  241. 	return -1;
  242. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/685460
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号