spacepaste

Paste details

reply | raw

  1.  
  2. /* Compile with: gcc -o simple_client2 simple_client2.c -std=gnu99 -lssl -lcrypto -ldl */
  4. #include <openssl/ssl.h>
  5. #include <openssl/bio.h>
  6. #include <openssl/err.h>
  8. #include <stdio.h>
  9. #include <string.h>
  11. #include <unistd.h>
  12. #include <fcntl.h>
  13. #include <sys/types.h>
  14. #include <errno.h>
  15. #include <assert.h>
  17. #include <sys/socket.h>
  18. #include <netinet/in.h>
  19. #include <netinet/tcp.h>
  20. #include <arpa/inet.h>
  21. #include <netdb.h>
  22. #include <sys/time.h>
  23. #include <string.h>
  25. #include <stdbool.h>
  27. // #include <iostream.h>
  28. // #include <iomanip.h>
  30. enum {
  31. FATAL = 0,
  32. ERROR,
  33. WARNING,
  34. INFO,
  35. DETAIL,
  36. DEBUG,
  37. TRACE
  38. };
  40. int _logLevel = DETAIL;
  42. #define LOG(level,msg) printf("LOG: %s\n", msg);
  43. #define LOG_ERROR(msg) printf("LOG ERR: %s\n", msg); //do { LOG(ERROR, "-E- " << __func__ << ' ' << msg << std::endl); } while(0)
  44. #define LOG_DEBUG(msg) printf("LOG DBG: %s\n", msg); //do { LOG(DEBUG, "-D- " << __func__ << ' ' << msg << '\n'); } while(0)
  45. #define LOG_INFO(msg) printf("LOG INF: %s\n", msg); //;do { LOG(INFO, "-I- " << __func__ << ' ' << msg << '\n'); } while(0)
  47. #define PERROR_AND_RETURN(rc) do { \
  48. LOG_ERROR(strerror(errno)); \
  49. return rc; \
  50. } while (0)
  53. struct addrinfo* get_addrinfo(const char* node, const char* service, bool tcp) {
  54. struct addrinfo hints;
  55. struct addrinfo* result = NULL;
  57. memset(&hints, 0, sizeof(struct addrinfo));
  58. hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
  59. hints.ai_socktype = tcp ? SOCK_STREAM : SOCK_DGRAM; /* Stream/Datagram socket */
  60. hints.ai_flags = 0;
  61. hints.ai_protocol = 0; /* Any protocol */
  63. int rc = 0;
  64. if (getaddrinfo(node, service, NULL/*&hints*/, &result) != 0) { LOG_ERROR(gai_strerror(rc)); return NULL; }
  66. return result;
  67. }
  69. /**
  70. *
  71. */
  72. int configure_socket(int fd, const struct addrinfo *ai, unsigned sndbuf, unsigned rcvbuf, bool blocking, bool nolinger, bool nodelay) {
  73. if (nolinger) {
  74. /* Set the socket for a non lingering, graceful close.
  75. * This will cause a final close of this socket not to wait until all
  76. * of the data sent on it has been received by the remote host.
  77. * The result is that the socket will be immediately released instead
  78. * of blocking in a TIME_WAIT state */
  79. int linger[] = {1, 0};
  80. if (setsockopt(fd, SOL_SOCKET, SO_LINGER, &linger, sizeof(linger)) == -1) { LOG_ERROR(strerror(errno)); return -1; }
  81. }
  83. // if (nodelay) {
  84. // int flag = 1;
  85. // if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag)) == -1) { LOG_ERROR(strerror(errno)); return -1; }
  86. // }
  88. if (sndbuf > 0 && setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf)) == -1) { LOG_ERROR(strerror(errno)); return -1; }
  89. if (rcvbuf > 0 && setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf)) == -1) { LOG_ERROR(strerror(errno)); return -1; }
  91. // put socket to blocking/non-blocking mode
  92. int flags = -1;
  93. if ((flags = fcntl(fd, F_GETFL, 0)) == -1) { LOG_ERROR(strerror(errno)); return -1; }
  94. if (blocking) flags &= ~O_NONBLOCK;
  95. else flags |= O_NONBLOCK;
  96. if (fcntl(fd, F_SETFL, flags) == -1) { LOG_ERROR(strerror(errno)); return -1; }
  98. return 0;
  99. }
  102. /**
  103. * returns tcp-connected socket
  104. */
  105. int get_tcp_connection(const char* node, const char* service) {
  106. struct addrinfo* ai = get_addrinfo(node, service, true /* tcp */);
  107. if (ai == NULL) return -1;
  109. const unsigned sndbuf = 1024*128;
  110. const unsigned rcvbuf = 1024*128;
  112. int fd = -1;
  113. for (struct addrinfo* rp = ai; rp != NULL; rp = rp->ai_next) {
  114. if ((fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol)) == -1) { LOG_ERROR(strerror(errno)); fd = -1; break; }
  115. if (configure_socket(fd, rp, sndbuf, rcvbuf, true /* blocking */, true /* nolinger */, false /* nodelay */) != 0) { close(fd); fd = -1; break; }
  117. if (connect(fd, rp->ai_addr, rp->ai_addrlen) != -1) break;
  118. close(fd); fd = -1;
  119. }
  121. freeaddrinfo(ai);
  122. return fd;
  123. }
  127. int main()
  128. {
  129. int p;
  131. const char* request;
  132. request = "POST /index HTTP/1.1\r\n"
  133. "Host: foo.com\r\n"
  134. "Content-Length: 5"
  135. "\r\n\r\n" "part3";
  136. char r[1024];
  138. /* Set up the library */
  139. SSL_library_init();
  140. ERR_load_BIO_strings();
  141. SSL_load_error_strings();
  142. OpenSSL_add_all_algorithms();
  144. /* Set up the SSL context */
  146. SSL_CTX* ctx = SSL_CTX_new(SSLv23_method());
  147. if (!ctx) {
  148. ERR_print_errors_fp(stderr);
  149. return 1;
  150. }
  152. SSL_CTX_set_session_id_context(ctx, "foobarbaz", 10);
  154. /* Load the trust store */
  155. #if 0
  156. if(! SSL_CTX_load_verify_locations(ctx, NULL, "/etc/ssl/certs"))
  157. {
  158. fprintf(stderr, "Error loading trust store\n");
  159. ERR_print_errors_fp(stderr);
  160. SSL_CTX_free(ctx);
  161. return 0;
  162. }
  163. #endif
  165. /* Setup the connection */
  167. int fd = get_tcp_connection("127.0.0.1", "5555");
  168. // int fd = my_connect("127.0.0.1", 80);
  169. if (fd == -1) {
  170. LOG_ERROR(strerror(errno));
  171. return 1;
  172. }
  175. SSL* ssl = SSL_new(ctx); assert(ssl);
  176. if (!SSL_set_fd(ssl, fd)) {
  177. LOG_ERROR("SSL_set_fd(ssl, fd)");
  178. return 1;
  179. }
  181. SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);
  183. int rc = SSL_get_error(ssl, SSL_connect(ssl));
  184. if (rc != SSL_ERROR_NONE) {
  185. LOG_ERROR(ERR_error_string(rc, NULL));
  186. while ((rc = ERR_get_error()) != 0) {
  187. LOG_ERROR(ERR_error_string(rc, NULL));
  188. }
  189. return 1;
  190. }
  192. /* Check the certificate */
  193. #if 0
  194. rc = SSL_get_verify_result(ssl);
  195. if(rc != X509_V_OK)
  196. {
  197. if (rc == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT || rc == X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN) {
  198. fprintf(stderr, "self signed certificate\n");
  199. }
  200. else {
  201. fprintf(stderr, "Certificate verification error: %ld\n", SSL_get_verify_result(ssl));
  202. SSL_CTX_free(ctx);
  203. return 0;
  204. }
  205. }
  206. #endif
  208. /* Send the request */
  209. request = "POST /index HTTP/1.1\r\n"
  210. "Host: foo.com\r\n"
  211. "Content-Length: 5"
  212. "\r\n\r\n" "part1";
  213. if (SSL_write(ssl, request, strlen(request)) == -1) {
  214. PERROR_AND_RETURN(1);
  215. }
  216. LOG_INFO("Data sent [");
  217. LOG_INFO(request);
  218. LOG_INFO("]");
  220. /* Read in the response */
  221. // for(;;)
  222. // {
  223. p = SSL_read(ssl, r, 1023);
  224. //if(p <= 0) break;
  225. r[p] = 0;
  226. printf("%s", r);
  227. // }
  229. /* Send the request */
  230. request = "POST /index HTTP/1.1\r\n"
  231. "Host: foo.com\r\n"
  232. "Content-Length: 5"
  233. "\r\n\r\n" "part2";
  234. if (SSL_write(ssl, request, strlen(request)) == -1) {
  235. PERROR_AND_RETURN(1);
  236. }
  237. LOG_INFO("Data sent [");
  238. LOG_INFO(request);
  239. LOG_INFO("]");
  241. /* Read in the response */
  242. // for(;;)
  243. // {
  244. p = SSL_read(ssl, r, 1023);
  245. //if(p <= 0) break;
  246. r[p] = 0;
  247. printf("%s", r);
  248. // }
  249. SSL_renegotiate_abbreviated(ssl);
  250. while(!SSL_do_handshake(ssl));
  251. SSL_heartbeat(ssl);
  253. /* Send the request */
  254. request = "POST /index HTTP/1.1\r\n"
  255. "Host: foo.com\r\n"
  256. "Content-Length: 5"
  257. "\r\n\r\n" "part3";
  258. if (SSL_write(ssl, request, strlen(request)) == -1) {
  259. PERROR_AND_RETURN(1);
  260. }
  261. LOG_INFO("Data sent [");
  262. LOG_INFO(request);
  263. LOG_INFO("]");
  265. /* Read in the response */
  266. // for(;;)
  267. // {
  268. p = -1;
  269. while (p < 0) {
  270. p = SSL_read(ssl, r, 1023);
  271. //if(p <= 0) break;
  272. printf("Received %d bytes\n", p);
  273. if (p >= 0) {
  274. r[p] = 0;
  275. printf("%s", r);
  276. }
  277. }
  278. // }
  280. exit(0);
  282. #if 0
  284. rc = SSL_shutdown(ssl);
  285. if(!rc){
  286. /* If we called SSL_shutdown() first then
  287. we always get return value of '0'. In
  288. this case, try again, but first send a
  289. TCP FIN to trigger the other side's
  290. close_notify*/
  291. shutdown(fd,1);
  292. rc = SSL_shutdown(ssl);
  293. }
  294. switch(rc){
  295. case 1:
  296. break; /* Success */
  297. case 0:
  298. case -1:
  299. default:
  300. LOG_ERROR("Shutdown failed");
  301. }
  303. /* Close the connection and free the context */
  305. SSL_CTX_free(ctx);
  306. // if (write(fd, request, strlen(request)) == -1) {
  307. // PERROR_AND_RETURN("write(fd, request, strlen(request))", 1);
  308. // }
  309. //
  310. // /* Read in the response */
  311. //
  312. // for(;;)
  313. // {
  314. // p = read(fd, r, 1023);
  315. // if(p <= 0) break;
  316. // r[p] = 0;
  317. // printf("%s", r);
  318. // }
  319. return 0;
  320. #endif
  321. }
  322.  
Powered by spacepaste. Paste removal.