spacepaste

Paste details

reply | raw

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