net.c 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237
  1. /* Host BSD-socket backend for the shared uhttp/TLS client. */
  2. #include <errno.h>
  3. #include <fcntl.h>
  4. #include <netdb.h>
  5. #include <netinet/in.h>
  6. #include <netinet/tcp.h>
  7. #include <poll.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include <sys/socket.h>
  11. #include <time.h>
  12. #include <unistd.h>
  13. #include "net.h"
  14. static int tcp_fd = -1;
  15. static int ms_left(unsigned long long deadline)
  16. {
  17. unsigned long long now = 0;
  18. struct timespec ts;
  19. clock_gettime(CLOCK_MONOTONIC, &ts);
  20. now = (unsigned long long)ts.tv_sec * 1000ull +
  21. (unsigned long long)ts.tv_nsec / 1000000ull;
  22. if (now >= deadline)
  23. return 0;
  24. return (int)(deadline - now);
  25. }
  26. static unsigned long long deadline_ms(unsigned int timeout_ms)
  27. {
  28. struct timespec ts;
  29. unsigned long long now;
  30. clock_gettime(CLOCK_MONOTONIC, &ts);
  31. now = (unsigned long long)ts.tv_sec * 1000ull +
  32. (unsigned long long)ts.tv_nsec / 1000000ull;
  33. return now + timeout_ms;
  34. }
  35. int host_net_dns(const char *name, unsigned char ip[4])
  36. {
  37. struct addrinfo hints;
  38. struct addrinfo *res = 0;
  39. int rv;
  40. if (!name || !name[0])
  41. return -1;
  42. memset(&hints, 0, sizeof(hints));
  43. hints.ai_family = AF_INET;
  44. hints.ai_socktype = SOCK_STREAM;
  45. rv = getaddrinfo(name, 0, &hints, &res);
  46. if (rv != 0 || !res)
  47. return -1;
  48. memcpy(ip, &((struct sockaddr_in *)res->ai_addr)->sin_addr, 4);
  49. freeaddrinfo(res);
  50. return 0;
  51. }
  52. int host_net_connect(const unsigned char mac[6], const unsigned char ip[4],
  53. unsigned int port)
  54. {
  55. struct sockaddr_in sa;
  56. int fd;
  57. int flags;
  58. int rv;
  59. int err = 0;
  60. socklen_t elen = sizeof(err);
  61. (void)mac;
  62. host_net_close();
  63. fd = socket(AF_INET, SOCK_STREAM, 0);
  64. if (fd < 0)
  65. return -3;
  66. memset(&sa, 0, sizeof(sa));
  67. sa.sin_family = AF_INET;
  68. memcpy(&sa.sin_addr, ip, 4);
  69. sa.sin_port = htons((unsigned short)port);
  70. flags = fcntl(fd, F_GETFL, 0);
  71. if (flags >= 0)
  72. fcntl(fd, F_SETFL, flags | O_NONBLOCK);
  73. rv = connect(fd, (struct sockaddr *)&sa, sizeof(sa));
  74. if (rv != 0 && errno != EINPROGRESS) {
  75. int e = errno;
  76. close(fd);
  77. return e == ECONNREFUSED ? -2 : -3;
  78. }
  79. if (rv != 0) {
  80. struct pollfd pfd;
  81. pfd.fd = fd;
  82. pfd.events = POLLOUT;
  83. pfd.revents = 0;
  84. do {
  85. rv = poll(&pfd, 1, 5000);
  86. } while (rv < 0 && errno == EINTR);
  87. if (rv == 0) {
  88. close(fd);
  89. return -1;
  90. }
  91. if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &elen) != 0)
  92. err = errno;
  93. if (err != 0) {
  94. close(fd);
  95. if (err == ECONNREFUSED)
  96. return -2;
  97. if (err == ETIMEDOUT)
  98. return -1;
  99. return -3;
  100. }
  101. }
  102. {
  103. int one = 1;
  104. setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
  105. }
  106. tcp_fd = fd;
  107. return 0;
  108. }
  109. int host_net_send(const void *buf, unsigned int len)
  110. {
  111. const unsigned char *p = (const unsigned char *)buf;
  112. unsigned int done = 0;
  113. if (tcp_fd < 0)
  114. return -3;
  115. while (done < len) {
  116. ssize_t n = send(tcp_fd, p + done, len - done, MSG_NOSIGNAL);
  117. if (n < 0) {
  118. if (errno == EINTR)
  119. continue;
  120. if (errno == EAGAIN || errno == EWOULDBLOCK) {
  121. struct pollfd pfd;
  122. int rv;
  123. pfd.fd = tcp_fd;
  124. pfd.events = POLLOUT;
  125. pfd.revents = 0;
  126. do {
  127. rv = poll(&pfd, 1, 5000);
  128. } while (rv < 0 && errno == EINTR);
  129. if (rv <= 0)
  130. return -1;
  131. continue;
  132. }
  133. return (errno == EPIPE || errno == ECONNRESET) ? -2 : -3;
  134. }
  135. if (n == 0)
  136. return -3;
  137. done += (unsigned int)n;
  138. }
  139. return 0;
  140. }
  141. int host_net_recv(void *buf, unsigned int max, unsigned int timeout_ms)
  142. {
  143. unsigned long long deadline = deadline_ms(timeout_ms);
  144. if (tcp_fd < 0)
  145. return -2;
  146. if (max == 0)
  147. return 0;
  148. for (;;) {
  149. struct pollfd pfd;
  150. int left = ms_left(deadline);
  151. int rv;
  152. pfd.fd = tcp_fd;
  153. pfd.events = POLLIN;
  154. pfd.revents = 0;
  155. rv = poll(&pfd, 1, left);
  156. if (rv < 0) {
  157. if (errno == EINTR)
  158. continue;
  159. return -2;
  160. }
  161. if (rv == 0)
  162. return -1;
  163. {
  164. ssize_t n = recv(tcp_fd, buf, max, 0);
  165. if (n > 0)
  166. return (int)n;
  167. if (n == 0)
  168. return 0;
  169. if (errno == EINTR)
  170. continue;
  171. if (errno == EAGAIN || errno == EWOULDBLOCK)
  172. continue;
  173. return -2;
  174. }
  175. }
  176. }
  177. void host_net_close(void)
  178. {
  179. if (tcp_fd >= 0) {
  180. close(tcp_fd);
  181. tcp_fd = -1;
  182. }
  183. }
  184. int host_net_peer_mss(void)
  185. {
  186. int mss = 0;
  187. socklen_t len = sizeof(mss);
  188. if (tcp_fd >= 0 &&
  189. getsockopt(tcp_fd, IPPROTO_TCP, TCP_MAXSEG, &mss, &len) == 0 &&
  190. mss > 0)
  191. return mss;
  192. return 1460;
  193. }
  194. void host_net_info(struct sys_netinfo *out)
  195. {
  196. memset(out, 0, sizeof(*out));
  197. out->present = 1;
  198. out->link = 1;
  199. out->mac[0] = 0x02;
  200. out->mac[5] = 0x01;
  201. out->ip[0] = 127;
  202. out->ip[3] = 1;
  203. out->mask[0] = 255;
  204. out->mask[1] = 255;
  205. out->mask[2] = 255;
  206. out->mask[3] = 255;
  207. out->dns[0] = 127;
  208. out->dns[3] = 1;
  209. snprintf(out->name, sizeof(out->name), "host");
  210. snprintf(out->chip, sizeof(out->chip), "linux");
  211. }