db_sockets.c 43 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488
  1. /* -*- mode:c; c-file-style:"k&r"; c-basic-offset: 4; tab-width:4; indent-tabs-mode:nil; mode:auto-fill; fill-column:78; -*- */
  2. /* vim: set ts=4 sw=4 et tw=78 fo=cqt wm=0: */
  3. /* Copyright (C) 2014 Stony Brook University
  4. This file is part of Graphene Library OS.
  5. Graphene Library OS is free software: you can redistribute it and/or
  6. modify it under the terms of the GNU Lesser General Public License
  7. as published by the Free Software Foundation, either version 3 of the
  8. License, or (at your option) any later version.
  9. Graphene Library OS is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. GNU Lesser General Public License for more details.
  13. You should have received a copy of the GNU Lesser General Public License
  14. along with this program. If not, see <http://www.gnu.org/licenses/>. */
  15. /*
  16. * db_socket.c
  17. *
  18. * This file contains operands for streams with URIs that start with
  19. * "tcp:", "tcp.srv:", "udp:", "udp.srv:".
  20. */
  21. #include "pal_defs.h"
  22. #include "pal_linux_defs.h"
  23. #include "pal.h"
  24. #include "pal_internal.h"
  25. #include "pal_linux.h"
  26. #include "pal_debug.h"
  27. #include "pal_security.h"
  28. #include "pal_error.h"
  29. #include "api.h"
  30. #include "graphene.h"
  31. #include <linux/types.h>
  32. #include <linux/poll.h>
  33. typedef __kernel_pid_t pid_t;
  34. #include <asm/fcntl.h>
  35. #include <sys/socket.h>
  36. #include <linux/in.h>
  37. #include <linux/in6.h>
  38. #include <netinet/tcp.h>
  39. #include <asm/errno.h>
  40. #ifndef SOL_TCP
  41. # define SOL_TCP 6
  42. #endif
  43. #ifndef TCP_NODELAY
  44. # define TCP_NODELAY 1
  45. #endif
  46. #ifndef TCP_CORK
  47. # define TCP_CORK 3
  48. #endif
  49. #ifndef SOL_IPV6
  50. # define SOL_IPV6 41
  51. #endif
  52. /* 96 bytes is the minimal size of buffer to store a IPv4/IPv6
  53. address */
  54. #define PAL_SOCKADDR_SIZE 96
  55. static inline int addr_size (struct sockaddr * addr)
  56. {
  57. switch (addr->sa_family) {
  58. case AF_INET:
  59. return sizeof(struct sockaddr_in);
  60. case AF_INET6:
  61. return sizeof(struct sockaddr_in6);
  62. default:
  63. return 0;
  64. }
  65. }
  66. /* parsing the string of uri, and fill in the socket address structure.
  67. the latest pointer of uri, length of socket address are returned. */
  68. static int inet_parse_uri (char ** uri, struct sockaddr * addr, int * addrlen)
  69. {
  70. char * tmp = *uri, * end;
  71. char * addr_str = NULL, * port_str;
  72. int af;
  73. void * addr_buf;
  74. int addr_len;
  75. __be16 * port_buf;
  76. int slen;
  77. if (tmp[0] == '[') {
  78. /* for IPv6, the address will be in the form of
  79. "[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx]:port". */
  80. struct sockaddr_in6 * addr_in6 = (struct sockaddr_in6 *) addr;
  81. slen = sizeof(struct sockaddr_in6);
  82. memset(addr, 0, slen);
  83. end = strchr(tmp + 1, ']');
  84. if (!end || *(end + 1) != ':')
  85. goto inval;
  86. addr_str = tmp + 1;
  87. addr_len = end - tmp - 1;
  88. port_str = end + 2;
  89. for (end = port_str ; *end >= '0' && *end <= '9' ; end++);
  90. addr_in6->sin6_family = af = AF_INET6;
  91. addr_buf = &addr_in6->sin6_addr.s6_addr;
  92. port_buf = &addr_in6->sin6_port;
  93. } else {
  94. /* for IP, the address will be in the form of "x.x.x.x:port". */
  95. struct sockaddr_in * addr_in = (struct sockaddr_in *) addr;
  96. slen = sizeof(struct sockaddr_in);
  97. memset(addr, 0, slen);
  98. end = strchr(tmp, ':');
  99. if (!end)
  100. goto inval;
  101. addr_str = tmp;
  102. addr_len = end - tmp;
  103. port_str = end + 1;
  104. for (end = port_str ; *end >= '0' && *end <= '9' ; end++);
  105. addr_in->sin_family = af = AF_INET;
  106. addr_buf = &addr_in->sin_addr.s_addr;
  107. port_buf = &addr_in->sin_port;
  108. }
  109. if (af == AF_INET) {
  110. if (!inet_pton4(addr_str, addr_len, addr_buf))
  111. goto inval;
  112. } else {
  113. if (!inet_pton6(addr_str, addr_len, addr_buf))
  114. goto inval;
  115. }
  116. *port_buf = __htons(atoi(port_str));
  117. *uri = *end ? end + 1 : NULL;
  118. if (addrlen)
  119. *addrlen = slen;
  120. return 0;
  121. inval:
  122. return -PAL_ERROR_INVAL;
  123. }
  124. /* create the string of uri from the given socket address */
  125. static int inet_create_uri (char * uri, int count, struct sockaddr * addr,
  126. int addrlen)
  127. {
  128. int len = 0;
  129. if (addr->sa_family == AF_INET) {
  130. if (addrlen != sizeof(struct sockaddr_in))
  131. return PAL_ERROR_INVAL;
  132. struct sockaddr_in * addr_in = (struct sockaddr_in *) addr;
  133. char * addr = (char *) &addr_in->sin_addr.s_addr;
  134. /* for IP, the address will be in the form of "x.x.x.x:port". */
  135. len = snprintf(uri, count, "%u.%u.%u.%u:%u",
  136. (unsigned char) addr[0],
  137. (unsigned char) addr[1],
  138. (unsigned char) addr[2],
  139. (unsigned char) addr[3],
  140. __ntohs(addr_in->sin_port));
  141. } else if (addr->sa_family == AF_INET6) {
  142. if (addrlen != sizeof(struct sockaddr_in6))
  143. return PAL_ERROR_INVAL;
  144. struct sockaddr_in6 * addr_in6 = (struct sockaddr_in6 *) addr;
  145. unsigned short * addr = (unsigned short *) &addr_in6->sin6_addr.s6_addr;
  146. /* for IPv6, the address will be in the form of
  147. "[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx]:port". */
  148. len = snprintf(uri, count, "[%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x]:%u",
  149. addr[0], addr[1], addr[2], addr[3],
  150. addr[4], addr[5], addr[6], addr[7],
  151. __ntohs(addr_in6->sin6_port));
  152. } else {
  153. return -PAL_ERROR_INVAL;
  154. }
  155. if (len >= count)
  156. return -PAL_ERROR_TOOLONG;
  157. return len;
  158. }
  159. /* parse the uri for a socket stream. The uri might have both binding
  160. address and connecting address, or connecting address only. The form
  161. of uri will be either "bind-addr:bind-port:connect-addr:connect-port"
  162. or "addr:port". */
  163. static int socket_parse_uri (char * uri,
  164. struct sockaddr ** bind_addr, int * bind_addrlen,
  165. struct sockaddr ** dest_addr, int * dest_addrlen)
  166. {
  167. int ret;
  168. if (!bind_addr && !dest_addr)
  169. return 0;
  170. if (!uri || !(*uri)) {
  171. if (bind_addr)
  172. *bind_addr = NULL;
  173. if (dest_addr)
  174. *dest_addr = NULL;
  175. return 0;
  176. }
  177. /* at least parse uri once */
  178. if ((ret = inet_parse_uri(&uri, bind_addr ? *bind_addr : *dest_addr,
  179. bind_addr ? bind_addrlen : dest_addrlen)) < 0)
  180. return ret;
  181. if (!(bind_addr && dest_addr))
  182. return 0;
  183. /* if you reach here, it can only be connection address */
  184. if (!uri || (ret = inet_parse_uri(&uri, *dest_addr, dest_addrlen)) < 0) {
  185. *dest_addr = *bind_addr;
  186. *dest_addrlen = *bind_addrlen;
  187. *bind_addr = NULL;
  188. *bind_addrlen = 0;
  189. }
  190. return 0;
  191. }
  192. /* fill in the PAL handle based on the file descriptors and address given. */
  193. static inline
  194. PAL_HANDLE socket_create_handle (int type, int fd, int options,
  195. struct sockaddr * bind_addr, int bind_addrlen,
  196. struct sockaddr * dest_addr, int dest_addrlen)
  197. {
  198. PAL_HANDLE hdl = malloc(HANDLE_SIZE(sock) + (bind_addr ? bind_addrlen : 0) +
  199. (dest_addr ? dest_addrlen : 0));
  200. if (!hdl)
  201. return NULL;
  202. memset(hdl, 0, sizeof(struct pal_handle));
  203. init_handle_hdr(HANDLE_HDR(hdl), type);
  204. HANDLE_HDR(hdl)->flags |= RFD(0)|(type != pal_type_tcpsrv ? WFD(0) : 0);
  205. hdl->sock.fd = fd;
  206. void * addr = (void *) hdl + HANDLE_SIZE(sock);
  207. if (bind_addr) {
  208. hdl->sock.bind = (PAL_PTR) addr;
  209. memcpy(addr, bind_addr, bind_addrlen);
  210. addr += bind_addrlen;
  211. } else {
  212. hdl->sock.bind = (PAL_PTR) NULL;
  213. }
  214. if (dest_addr) {
  215. hdl->sock.conn = (PAL_PTR) addr;
  216. memcpy(addr, dest_addr, dest_addrlen);
  217. addr += dest_addrlen;
  218. } else {
  219. hdl->sock.conn = (PAL_PTR) NULL;
  220. }
  221. hdl->sock.nonblocking = (options & PAL_OPTION_NONBLOCK) ?
  222. PAL_TRUE : PAL_FALSE;
  223. hdl->sock.linger = 0;
  224. if (type == pal_type_tcpsrv) {
  225. hdl->sock.receivebuf = 0;
  226. hdl->sock.sendbuf = 0;
  227. } else {
  228. int ret, val, len = sizeof(int);
  229. ret = INLINE_SYSCALL(getsockopt, 5, fd, SOL_SOCKET, SO_RCVBUF,
  230. &val, &len);
  231. hdl->sock.receivebuf = IS_ERR(ret) ? 0 : val;
  232. ret = INLINE_SYSCALL(getsockopt, 5, fd, SOL_SOCKET, SO_SNDBUF,
  233. &val, &len);
  234. hdl->sock.sendbuf = IS_ERR(ret) ? 0 : val;
  235. }
  236. hdl->sock.receivetimeout = 0;
  237. hdl->sock.sendtimeout = 0;
  238. hdl->sock.tcp_cork = PAL_FALSE;
  239. hdl->sock.tcp_keepalive = PAL_FALSE;
  240. hdl->sock.tcp_nodelay = PAL_FALSE;
  241. return hdl;
  242. }
  243. #if ALLOW_BIND_ANY == 0
  244. static bool check_zero (void * mem, size_t size)
  245. {
  246. void * p = mem, * q = mem + size;
  247. while (p < q) {
  248. if (p <= q - sizeof(long)) {
  249. if (*(long *) p)
  250. return false;
  251. p += sizeof(long);
  252. } else if (p <= q - sizeof(int)) {
  253. if (*(int *) p)
  254. return false;
  255. p += sizeof(int);
  256. } else if (p <= q - sizeof(short)) {
  257. if (*(short *) p)
  258. return false;
  259. p += sizeof(short);
  260. } else {
  261. if (*(char *) p)
  262. return false;
  263. p++;
  264. }
  265. }
  266. return true;
  267. }
  268. /* check if an address is "Any" */
  269. static bool check_any_addr (struct sockaddr * addr)
  270. {
  271. if (addr->sa_family == AF_INET) {
  272. struct sockaddr_in * addr_in =
  273. (struct sockaddr_in *) addr;
  274. return addr_in->sin_port == 0 &&
  275. check_zero(&addr_in->sin_addr,
  276. sizeof(addr_in->sin_addr));
  277. } else if (addr->sa_family == AF_INET6) {
  278. struct sockaddr_in6 * addr_in6 =
  279. (struct sockaddr_in6 *) addr;
  280. return addr_in6->sin6_port == 0 &&
  281. check_zero(&addr_in6->sin6_addr,
  282. sizeof(addr_in6->sin6_addr));
  283. }
  284. return false;
  285. }
  286. #endif
  287. /* listen on a tcp socket */
  288. static int tcp_listen (PAL_HANDLE * handle, char * uri, int options)
  289. {
  290. struct sockaddr buffer, * bind_addr = &buffer;
  291. int bind_addrlen;
  292. int ret, fd = -1;
  293. if ((ret = socket_parse_uri(uri, &bind_addr, &bind_addrlen,
  294. NULL, NULL)) < 0)
  295. return ret;
  296. assert(bind_addr);
  297. assert(bind_addrlen == addr_size(bind_addr));
  298. #if ALLOW_BIND_ANY == 0
  299. /* the socket need to have a binding address, a null address or an
  300. any address is not allowed */
  301. if (addr_check_any(bind_addr))
  302. return -PAL_ERROR_INVAL;
  303. #endif
  304. fd = INLINE_SYSCALL(socket, 3, bind_addr->sa_family,
  305. SOCK_STREAM|SOCK_CLOEXEC|options, 0);
  306. if (IS_ERR(fd))
  307. return -PAL_ERROR_DENIED;
  308. if (bind_addr->sa_family == AF_INET6) {
  309. int ipv6only = 1;
  310. INLINE_SYSCALL(setsockopt, 5, fd, SOL_IPV6, IPV6_V6ONLY, &ipv6only,
  311. sizeof(int));
  312. }
  313. /* must set the socket to be reuseable */
  314. int reuseaddr = 1;
  315. INLINE_SYSCALL(setsockopt, 5, fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
  316. sizeof(int));
  317. ret = INLINE_SYSCALL(bind, 3, fd, bind_addr, bind_addrlen);
  318. if (IS_ERR(ret)) {
  319. switch(ERRNO(ret)) {
  320. case EINVAL:
  321. ret = -PAL_ERROR_INVAL;
  322. goto failed;
  323. case EADDRINUSE:
  324. ret = -PAL_ERROR_STREAMEXIST;
  325. goto failed;
  326. default:
  327. ret = -PAL_ERROR_DENIED;
  328. goto failed;
  329. }
  330. }
  331. ret = INLINE_SYSCALL(listen, 2, fd, DEFAULT_BACKLOG);
  332. if (IS_ERR(ret))
  333. return -PAL_ERROR_DENIED;
  334. *handle = socket_create_handle(pal_type_tcpsrv, fd, options,
  335. bind_addr, bind_addrlen, NULL, 0);
  336. if (!(*handle)) {
  337. ret = -PAL_ERROR_NOMEM;
  338. goto failed;
  339. }
  340. return 0;
  341. failed:
  342. INLINE_SYSCALL(close, 1, fd);
  343. return ret;
  344. }
  345. /* accept a tcp connection */
  346. static int tcp_accept (PAL_HANDLE handle, PAL_HANDLE * client)
  347. {
  348. if (!IS_HANDLE_TYPE(handle, tcpsrv) ||
  349. !handle->sock.bind || handle->sock.conn)
  350. return -PAL_ERROR_NOTSERVER;
  351. if (handle->sock.fd == PAL_IDX_POISON)
  352. return -PAL_ERROR_BADHANDLE;
  353. struct sockaddr * bind_addr = (struct sockaddr *) handle->sock.bind;
  354. int bind_addrlen = addr_size(bind_addr);
  355. struct sockaddr buffer;
  356. socklen_t addrlen = sizeof(struct sockaddr);
  357. int ret = 0;
  358. int newfd = INLINE_SYSCALL(accept4, 4, handle->sock.fd, &buffer,
  359. &addrlen, O_CLOEXEC);
  360. if (IS_ERR(newfd))
  361. switch(ERRNO(newfd)) {
  362. case EWOULDBLOCK:
  363. return -PAL_ERROR_TRYAGAIN;
  364. case ECONNABORTED:
  365. return -PAL_ERROR_STREAMNOTEXIST;
  366. default:
  367. return unix_to_pal_error(ERRNO(newfd));
  368. }
  369. struct sockaddr * dest_addr = &buffer;
  370. int dest_addrlen = addrlen;
  371. *client = socket_create_handle(pal_type_tcp, newfd, 0,
  372. bind_addr, bind_addrlen,
  373. dest_addr, dest_addrlen);
  374. if (!(*client)) {
  375. ret = -PAL_ERROR_NOMEM;
  376. goto failed;
  377. }
  378. return 0;
  379. failed:
  380. INLINE_SYSCALL(close, 1, newfd);
  381. return ret;
  382. }
  383. /* connect on a tcp socket */
  384. static int tcp_connect (PAL_HANDLE * handle, char * uri, int options)
  385. {
  386. struct sockaddr buffer[3];
  387. struct sockaddr * bind_addr = buffer, * dest_addr = buffer + 1;
  388. int bind_addrlen, dest_addrlen;
  389. int ret, fd = -1;
  390. /* accepting two kind of different uri:
  391. dest-ip:dest-port or bind-ip:bind-port:dest-ip:dest-port */
  392. if ((ret = socket_parse_uri(uri, &bind_addr, &bind_addrlen,
  393. &dest_addr, &dest_addrlen)) < 0)
  394. return ret;
  395. if (!dest_addr)
  396. return -PAL_ERROR_INVAL;
  397. if (bind_addr && bind_addr->sa_family != dest_addr->sa_family)
  398. return -PAL_ERROR_INVAL;
  399. fd = INLINE_SYSCALL(socket, 3, dest_addr->sa_family,
  400. SOCK_STREAM|SOCK_CLOEXEC|options, 0);
  401. if (IS_ERR(fd))
  402. return -PAL_ERROR_DENIED;
  403. if (bind_addr) {
  404. if (IS_ERR(ret)) {
  405. INLINE_SYSCALL(close, 1, fd);
  406. switch (ERRNO(ret)) {
  407. case EADDRINUSE:
  408. ret = -PAL_ERROR_STREAMEXIST;
  409. goto failed;
  410. case EADDRNOTAVAIL:
  411. ret = -PAL_ERROR_ADDRNOTEXIST;
  412. goto failed;
  413. default:
  414. ret = unix_to_pal_error(ERRNO(ret));
  415. goto failed;
  416. }
  417. }
  418. }
  419. if (dest_addr->sa_family == AF_INET6) {
  420. int ipv6only = 1;
  421. INLINE_SYSCALL(setsockopt, 5, fd, SOL_IPV6, IPV6_V6ONLY, &ipv6only,
  422. sizeof(int));
  423. }
  424. ret = INLINE_SYSCALL(connect, 3, fd, dest_addr, dest_addrlen);
  425. if (IS_ERR(ret) && ERRNO(ret) == EINPROGRESS) {
  426. struct pollfd pfd = { .fd = fd, .events = POLLOUT, .revents = 0 };
  427. ret = INLINE_SYSCALL(ppoll, 5, &pfd, 1, NULL, NULL, 0);
  428. }
  429. if (IS_ERR(ret)) {
  430. ret = unix_to_pal_error(ERRNO(ret));
  431. goto failed;
  432. }
  433. if (!bind_addr) {
  434. /* save some space to get socket address */
  435. bind_addr = buffer + 2;
  436. bind_addrlen = sizeof(struct sockaddr);
  437. /* call getsockname to get socket address */
  438. if ((ret = INLINE_SYSCALL(getsockname, 3, fd,
  439. bind_addr, &bind_addrlen)) < 0)
  440. bind_addr = NULL;
  441. }
  442. *handle = socket_create_handle(pal_type_tcp, fd, options,
  443. bind_addr, bind_addrlen,
  444. dest_addr, dest_addrlen);
  445. if (!(*handle)) {
  446. ret = -PAL_ERROR_NOMEM;
  447. goto failed;
  448. }
  449. return 0;
  450. failed:
  451. INLINE_SYSCALL(close, 1, fd);
  452. return ret;
  453. }
  454. /* 'open' operation of tcp stream */
  455. static int tcp_open (PAL_HANDLE *handle, const char * type, const char * uri,
  456. int access, int share, int create, int options)
  457. {
  458. int uri_len = strlen(uri) + 1;
  459. if (uri_len > PAL_SOCKADDR_SIZE)
  460. return -PAL_ERROR_TOOLONG;
  461. char uri_buf[PAL_SOCKADDR_SIZE];
  462. memcpy(uri_buf, uri, uri_len);
  463. if (strpartcmp_static(type, "tcp.srv:"))
  464. return tcp_listen(handle, uri_buf, options);
  465. if (strpartcmp_static(type, "tcp:"))
  466. return tcp_connect(handle, uri_buf, options);
  467. return -PAL_ERROR_NOTSUPPORT;
  468. }
  469. /* 'read' operation of tcp stream */
  470. static int tcp_read (PAL_HANDLE handle, int offset, int len, void * buf)
  471. {
  472. if (!IS_HANDLE_TYPE(handle, tcp) || !handle->sock.conn)
  473. return -PAL_ERROR_NOTCONNECTION;
  474. if (handle->sock.fd == PAL_IDX_POISON)
  475. return -PAL_ERROR_ENDOFSTREAM;
  476. struct msghdr hdr;
  477. struct iovec iov;
  478. iov.iov_base = buf;
  479. iov.iov_len = len;
  480. hdr.msg_name = NULL;
  481. hdr.msg_namelen = 0;
  482. hdr.msg_iov = &iov;
  483. hdr.msg_iovlen = 1;
  484. hdr.msg_control = NULL;
  485. hdr.msg_controllen = 0;
  486. hdr.msg_flags = 0;
  487. int bytes = INLINE_SYSCALL(recvmsg, 3, handle->sock.fd, &hdr, 0);
  488. if (IS_ERR(bytes))
  489. switch (ERRNO(bytes)) {
  490. case EWOULDBLOCK:
  491. return -PAL_ERROR_TRYAGAIN;
  492. default:
  493. return unix_to_pal_error(ERRNO(bytes));
  494. }
  495. if (!bytes)
  496. return -PAL_ERROR_ENDOFSTREAM;
  497. return bytes;
  498. }
  499. /* write' operation of tcp stream */
  500. static int tcp_write (PAL_HANDLE handle, int offset, int len, const void * buf)
  501. {
  502. if (!IS_HANDLE_TYPE(handle, tcp) || !handle->sock.conn)
  503. return -PAL_ERROR_NOTCONNECTION;
  504. if (handle->sock.fd == PAL_IDX_POISON)
  505. return -PAL_ERROR_CONNFAILED;
  506. struct msghdr hdr;
  507. struct iovec iov;
  508. iov.iov_base = (void *) buf;
  509. iov.iov_len = len;
  510. hdr.msg_name = NULL;
  511. hdr.msg_namelen = 0;
  512. hdr.msg_iov = &iov;
  513. hdr.msg_iovlen = 1;
  514. hdr.msg_control = NULL;
  515. hdr.msg_controllen = 0;
  516. hdr.msg_flags = 0;
  517. int bytes = INLINE_SYSCALL(sendmsg, 3, handle->sock.fd, &hdr, MSG_NOSIGNAL);
  518. if (IS_ERR(bytes))
  519. switch(ERRNO(bytes)) {
  520. case ECONNRESET:
  521. case EPIPE:
  522. return -PAL_ERROR_CONNFAILED;
  523. case EWOULDBLOCK:
  524. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  525. return -PAL_ERROR_TRYAGAIN;
  526. default:
  527. return unix_to_pal_error(ERRNO(bytes));
  528. }
  529. if (bytes == len)
  530. HANDLE_HDR(handle)->flags |= WRITEABLE(0);
  531. else
  532. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  533. return bytes;
  534. }
  535. /* used by 'open' operation of tcp stream for bound socket */
  536. static int udp_bind (PAL_HANDLE * handle, char * uri, int options)
  537. {
  538. struct sockaddr buffer, * bind_addr = &buffer;
  539. int bind_addrlen;
  540. int ret = 0, fd = -1;
  541. if ((ret = socket_parse_uri(uri, &bind_addr, &bind_addrlen,
  542. NULL, NULL)) < 0)
  543. return ret;
  544. assert(bind_addr);
  545. assert(bind_addrlen == addr_size(bind_addr));
  546. #if ALLOW_BIND_ANY == 0
  547. /* the socket need to have a binding address, a null address or an
  548. any address is not allowed */
  549. if (addr_check_any(bind_addr))
  550. return -PAL_ERROR_INVAL;
  551. #endif
  552. fd = INLINE_SYSCALL(socket, 3, bind_addr->sa_family,
  553. SOCK_DGRAM|SOCK_CLOEXEC|options, 0);
  554. if (IS_ERR(fd))
  555. return -PAL_ERROR_DENIED;
  556. if (bind_addr->sa_family == AF_INET6) {
  557. int ipv6only = 1;
  558. INLINE_SYSCALL(setsockopt, 5, fd, SOL_IPV6, IPV6_V6ONLY, &ipv6only,
  559. sizeof(int));
  560. }
  561. ret = INLINE_SYSCALL(bind, 3, fd, bind_addr, bind_addrlen);
  562. if (IS_ERR(ret)) {
  563. switch (ERRNO(ret)) {
  564. case EADDRINUSE:
  565. ret = -PAL_ERROR_STREAMEXIST;
  566. goto failed;
  567. case EADDRNOTAVAIL:
  568. ret = -PAL_ERROR_ADDRNOTEXIST;
  569. goto failed;
  570. default:
  571. ret = unix_to_pal_error(ERRNO(ret));
  572. goto failed;
  573. }
  574. }
  575. *handle = socket_create_handle(pal_type_udpsrv, fd, options,
  576. bind_addr, bind_addrlen, NULL, 0);
  577. if (!(*handle)) {
  578. ret = -ENOMEM;
  579. goto failed;
  580. }
  581. return 0;
  582. failed:
  583. INLINE_SYSCALL(close, 1, fd);
  584. return ret;
  585. }
  586. /* used by 'open' operation of tcp stream for connected socket */
  587. static int udp_connect (PAL_HANDLE * handle, char * uri, int options)
  588. {
  589. struct sockaddr buffer[2];
  590. struct sockaddr * bind_addr = buffer, * dest_addr = buffer + 1;
  591. int bind_addrlen, dest_addrlen;
  592. int ret, fd = -1;
  593. if ((ret = socket_parse_uri(uri, &bind_addr, &bind_addrlen,
  594. &dest_addr, &dest_addrlen)) < 0)
  595. return ret;
  596. #if ALLOW_BIND_ANY == 0
  597. /* the socket need to have a binding address, a null address or an
  598. any address is not allowed */
  599. if (bind_addr && addr_check_any(bind_addr))
  600. return -PAL_ERROR_INVAL;
  601. #endif
  602. fd = INLINE_SYSCALL(socket, 3, dest_addr ? dest_addr->sa_family : AF_INET,
  603. SOCK_DGRAM|SOCK_CLOEXEC|options, 0);
  604. if (IS_ERR(fd))
  605. return -PAL_ERROR_DENIED;
  606. if (dest_addr->sa_family == AF_INET6) {
  607. int ipv6only = 1;
  608. INLINE_SYSCALL(setsockopt, 5, fd, SOL_IPV6, IPV6_V6ONLY, &ipv6only,
  609. sizeof(int));
  610. }
  611. if (bind_addr) {
  612. ret = INLINE_SYSCALL(bind, 3, fd, bind_addr, bind_addrlen);
  613. if (IS_ERR(ret)) {
  614. switch (ERRNO(ret)) {
  615. case EADDRINUSE:
  616. ret = -PAL_ERROR_STREAMEXIST;
  617. goto failed;
  618. case EADDRNOTAVAIL:
  619. ret = -PAL_ERROR_ADDRNOTEXIST;
  620. goto failed;
  621. default:
  622. ret = unix_to_pal_error(ERRNO(ret));
  623. goto failed;
  624. }
  625. }
  626. }
  627. *handle = socket_create_handle(dest_addr ? pal_type_udp : pal_type_udpsrv,
  628. fd, options,
  629. bind_addr, bind_addrlen,
  630. dest_addr, dest_addrlen);
  631. if (!(*handle)) {
  632. ret = -ENOMEM;
  633. goto failed;
  634. }
  635. return 0;
  636. failed:
  637. INLINE_SYSCALL(close, 1, fd);
  638. return ret;
  639. }
  640. static int udp_open (PAL_HANDLE *hdl, const char * type, const char * uri,
  641. int access, int share, int create, int options)
  642. {
  643. char buf[PAL_SOCKADDR_SIZE];
  644. int len = strlen(uri);
  645. if (len >= PAL_SOCKADDR_SIZE)
  646. return -PAL_ERROR_TOOLONG;
  647. memcpy(buf, uri, len + 1);
  648. options &= PAL_OPTION_MASK;
  649. if (strpartcmp_static(type, "udp.srv:"))
  650. return udp_bind(hdl, buf, options);
  651. if (strpartcmp_static(type, "udp:"))
  652. return udp_connect(hdl, buf, options);
  653. return -PAL_ERROR_NOTSUPPORT;
  654. }
  655. static int udp_receive (PAL_HANDLE handle, int offset, int len, void * buf)
  656. {
  657. if (!IS_HANDLE_TYPE(handle, udp))
  658. return -PAL_ERROR_NOTCONNECTION;
  659. if (handle->sock.fd == PAL_IDX_POISON)
  660. return -PAL_ERROR_BADHANDLE;
  661. struct msghdr hdr;
  662. struct iovec iov;
  663. iov.iov_base = buf;
  664. iov.iov_len = len;
  665. hdr.msg_name = NULL;
  666. hdr.msg_namelen = 0;
  667. hdr.msg_iov = &iov;
  668. hdr.msg_iovlen = 1;
  669. hdr.msg_control = NULL;
  670. hdr.msg_controllen = 0;
  671. hdr.msg_flags = 0;
  672. int bytes = INLINE_SYSCALL(recvmsg, 3, handle->sock.fd, &hdr, 0);
  673. if (IS_ERR(bytes))
  674. switch(ERRNO(bytes)) {
  675. case EWOULDBLOCK:
  676. return -PAL_ERROR_TRYAGAIN;
  677. case EINTR:
  678. return -PAL_ERROR_INTERRUPTED;
  679. default:
  680. return unix_to_pal_error(ERRNO(bytes));
  681. }
  682. return bytes;
  683. }
  684. static int udp_receivebyaddr (PAL_HANDLE handle, int offset, int len,
  685. void * buf, char * addr, int addrlen)
  686. {
  687. if (!IS_HANDLE_TYPE(handle, udpsrv))
  688. return -PAL_ERROR_NOTCONNECTION;
  689. if (handle->sock.fd == PAL_IDX_POISON)
  690. return -PAL_ERROR_BADHANDLE;
  691. struct sockaddr conn_addr;
  692. socklen_t conn_addrlen = sizeof(struct sockaddr);
  693. struct msghdr hdr;
  694. struct iovec iov;
  695. iov.iov_base = buf;
  696. iov.iov_len = len;
  697. hdr.msg_name = &conn_addr;
  698. hdr.msg_namelen = conn_addrlen;
  699. hdr.msg_iov = &iov;
  700. hdr.msg_iovlen = 1;
  701. hdr.msg_control = NULL;
  702. hdr.msg_controllen = 0;
  703. hdr.msg_flags = 0;
  704. int bytes = INLINE_SYSCALL(recvmsg, 3, handle->sock.fd, &hdr, 0);
  705. if (IS_ERR(bytes))
  706. switch(ERRNO(bytes)) {
  707. case EWOULDBLOCK:
  708. return -PAL_ERROR_TRYAGAIN;
  709. case EINTR:
  710. return -PAL_ERROR_INTERRUPTED;
  711. case ECONNREFUSED:
  712. return -PAL_ERROR_STREAMNOTEXIST;
  713. default:
  714. return unix_to_pal_error(ERRNO(bytes));
  715. }
  716. char * addr_uri = strcpy_static(addr, "udp:", addrlen);
  717. if (!addr_uri)
  718. return -PAL_ERROR_OVERFLOW;
  719. int ret = inet_create_uri(addr_uri, addr + addrlen - addr_uri, &conn_addr,
  720. hdr.msg_namelen);
  721. if (ret < 0)
  722. return ret;
  723. return bytes;
  724. }
  725. static int udp_send (PAL_HANDLE handle, int offset, int len, const void * buf)
  726. {
  727. if (!IS_HANDLE_TYPE(handle, udp))
  728. return -PAL_ERROR_NOTCONNECTION;
  729. if (handle->sock.fd == PAL_IDX_POISON)
  730. return -PAL_ERROR_BADHANDLE;
  731. struct msghdr hdr;
  732. struct iovec iov;
  733. iov.iov_base = (void *) buf;
  734. iov.iov_len = len;
  735. hdr.msg_name = (void *) handle->sock.conn;
  736. hdr.msg_namelen = addr_size((struct sockaddr *) handle->sock.conn);
  737. hdr.msg_iov = &iov;
  738. hdr.msg_iovlen = 1;
  739. hdr.msg_control = NULL;
  740. hdr.msg_controllen = 0;
  741. hdr.msg_flags = 0;
  742. int bytes = INLINE_SYSCALL(sendmsg, 3, handle->sock.fd, &hdr, MSG_NOSIGNAL);
  743. if (IS_ERR(bytes))
  744. switch(ERRNO(bytes)) {
  745. case EAGAIN:
  746. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  747. return -PAL_ERROR_TRYAGAIN;
  748. case ECONNRESET:
  749. case EPIPE:
  750. return -PAL_ERROR_CONNFAILED;
  751. default:
  752. return unix_to_pal_error(ERRNO(bytes));
  753. }
  754. if (bytes == len)
  755. HANDLE_HDR(handle)->flags |= WRITEABLE(0);
  756. else
  757. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  758. return bytes;
  759. }
  760. static int udp_sendbyaddr (PAL_HANDLE handle, int offset, int len,
  761. const void * buf, const char * addr, int addrlen)
  762. {
  763. if (!IS_HANDLE_TYPE(handle, udpsrv))
  764. return -PAL_ERROR_NOTCONNECTION;
  765. if (handle->sock.fd == PAL_IDX_POISON)
  766. return -PAL_ERROR_BADHANDLE;
  767. if (!strpartcmp_static(addr, "udp:"))
  768. return -PAL_ERROR_INVAL;
  769. addr += static_strlen("udp:");
  770. addrlen -= static_strlen("udp:");
  771. char * addrbuf = __alloca(addrlen);
  772. memcpy(addrbuf, addr, addrlen);
  773. struct sockaddr conn_addr;
  774. int conn_addrlen;
  775. int ret = inet_parse_uri(&addrbuf, &conn_addr, &conn_addrlen);
  776. if (ret < 0)
  777. return ret;
  778. struct msghdr hdr;
  779. struct iovec iov;
  780. iov.iov_base = (void *) buf;
  781. iov.iov_len = len;
  782. hdr.msg_name = &conn_addr;
  783. hdr.msg_namelen = conn_addrlen;
  784. hdr.msg_iov = &iov;
  785. hdr.msg_iovlen = 1;
  786. hdr.msg_control = NULL;
  787. hdr.msg_controllen = 0;
  788. hdr.msg_flags = 0;
  789. int bytes = INLINE_SYSCALL(sendmsg, 3, handle->sock.fd, &hdr, MSG_NOSIGNAL);
  790. if (IS_ERR(bytes))
  791. switch(ERRNO(bytes)) {
  792. case ECONNRESET:
  793. case EPIPE:
  794. return -PAL_ERROR_CONNFAILED;
  795. case EAGAIN:
  796. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  797. default:
  798. return unix_to_pal_error(ERRNO(bytes));
  799. }
  800. if (bytes == len)
  801. HANDLE_HDR(handle)->flags |= WRITEABLE(0);
  802. else
  803. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  804. return bytes;
  805. }
  806. static int socket_delete (PAL_HANDLE handle, int access)
  807. {
  808. if (handle->sock.fd == PAL_IDX_POISON)
  809. return 0;
  810. if (!IS_HANDLE_TYPE(handle, tcp) && access)
  811. return -PAL_ERROR_INVAL;
  812. if (IS_HANDLE_TYPE(handle, tcp) || IS_HANDLE_TYPE(handle, tcpsrv)) {
  813. int shutdown;
  814. switch (access) {
  815. case 0:
  816. shutdown = SHUT_RDWR;
  817. break;
  818. case PAL_DELETE_RD:
  819. shutdown = SHUT_RD;
  820. break;
  821. case PAL_DELETE_WR:
  822. shutdown = SHUT_WR;
  823. break;
  824. default:
  825. return -PAL_ERROR_INVAL;
  826. }
  827. INLINE_SYSCALL(shutdown, 2, handle->sock.fd, shutdown);
  828. }
  829. return 0;
  830. }
  831. struct __kernel_linger {
  832. int l_onoff;
  833. int l_linger;
  834. };
  835. static int socket_close (PAL_HANDLE handle)
  836. {
  837. if (handle->sock.fd != PAL_IDX_POISON) {
  838. struct __kernel_linger l;
  839. l.l_onoff = 1;
  840. l.l_linger = 0;
  841. INLINE_SYSCALL(setsockopt, 5, handle->sock.fd, SOL_SOCKET, SO_LINGER,
  842. &l, sizeof(struct __kernel_linger));
  843. INLINE_SYSCALL(close, 1, handle->sock.fd);
  844. handle->sock.fd = PAL_IDX_POISON;
  845. }
  846. if (handle->sock.bind)
  847. handle->sock.bind = (PAL_PTR) NULL;
  848. if (handle->sock.conn)
  849. handle->sock.conn = (PAL_PTR) NULL;
  850. return 0;
  851. }
  852. #ifndef FIONREAD
  853. # define FIONREAD 0x541B
  854. #endif
  855. static int socket_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
  856. {
  857. if (handle->sock.fd == PAL_IDX_POISON)
  858. return -PAL_ERROR_BADHANDLE;
  859. attr->handle_type = HANDLE_HDR(handle)->type;
  860. attr->disconnected = HANDLE_HDR(handle)->flags & ERROR(0);
  861. attr->nonblocking = handle->sock.nonblocking;
  862. attr->writeable = HANDLE_HDR(handle)->flags & WRITEABLE(0);
  863. attr->pending_size = 0; /* fill in later */
  864. attr->socket.linger = handle->sock.linger;
  865. attr->socket.receivebuf = handle->sock.receivebuf;
  866. attr->socket.sendbuf = handle->sock.sendbuf;
  867. attr->socket.receivetimeout = handle->sock.receivetimeout;
  868. attr->socket.sendtimeout = handle->sock.sendtimeout;
  869. attr->socket.tcp_cork = handle->sock.tcp_cork;
  870. attr->socket.tcp_keepalive = handle->sock.tcp_keepalive;
  871. attr->socket.tcp_nodelay = handle->sock.tcp_nodelay;
  872. int fd = handle->sock.fd, ret, val;
  873. if (!IS_HANDLE_TYPE(handle, tcpsrv)) {
  874. /* try use ioctl FIONEAD to get the size of socket */
  875. ret = INLINE_SYSCALL(ioctl, 3, fd, FIONREAD, &val);
  876. if (IS_ERR(ret))
  877. return unix_to_pal_error(ERRNO(ret));
  878. attr->pending_size = val;
  879. }
  880. struct pollfd pfd = { .fd = fd, .events = POLLIN, .revents = 0 };
  881. struct timespec tp = { 0, 0 };
  882. ret = INLINE_SYSCALL(ppoll, 5, &pfd, 1, &tp, NULL, 0);
  883. attr->readable = (ret == 1 && pfd.revents == POLLIN);
  884. return 0;
  885. }
  886. static int socket_attrsetbyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
  887. {
  888. if (handle->sock.fd == PAL_IDX_POISON)
  889. return -PAL_ERROR_BADHANDLE;
  890. int fd = handle->sock.fd, ret, val;
  891. if (attr->nonblocking != handle->sock.nonblocking) {
  892. ret = INLINE_SYSCALL(fcntl, 3, fd, F_SETFL,
  893. attr->nonblocking ? O_NONBLOCK : 0);
  894. if (IS_ERR(ret))
  895. return unix_to_pal_error(ERRNO(ret));
  896. handle->sock.nonblocking = attr->nonblocking;
  897. }
  898. if (IS_HANDLE_TYPE(handle, tcpsrv)) {
  899. if (attr->socket.linger != handle->sock.linger) {
  900. struct __kernel_linger l;
  901. l.l_onoff = attr->socket.linger ? 1 : 0;
  902. l.l_linger = attr->socket.linger;
  903. ret = INLINE_SYSCALL(setsockopt, 5, fd, SOL_SOCKET, SO_LINGER,
  904. &l, sizeof(struct __kernel_linger));
  905. if (IS_ERR(ret))
  906. return unix_to_pal_error(ERRNO(ret));
  907. handle->sock.linger = attr->socket.linger;
  908. }
  909. if (attr->socket.receivebuf != handle->sock.receivebuf) {
  910. int val = attr->socket.receivebuf;
  911. ret = INLINE_SYSCALL(setsockopt, 5, fd, SOL_SOCKET, SO_RCVBUF,
  912. &val, sizeof(int));
  913. if (IS_ERR(ret))
  914. return unix_to_pal_error(ERRNO(ret));
  915. handle->sock.receivebuf = attr->socket.receivebuf;
  916. }
  917. if (attr->socket.sendbuf != handle->sock.sendbuf) {
  918. int val = attr->socket.sendbuf;
  919. ret = INLINE_SYSCALL(setsockopt, 5, fd, SOL_SOCKET, SO_SNDBUF,
  920. &val, sizeof(int));
  921. if (IS_ERR(ret))
  922. return unix_to_pal_error(ERRNO(ret));
  923. handle->sock.sendbuf = attr->socket.sendbuf;
  924. }
  925. if (attr->socket.receivetimeout != handle->sock.receivetimeout) {
  926. int val = attr->socket.receivetimeout;
  927. ret = INLINE_SYSCALL(setsockopt, 5, fd, SOL_SOCKET, SO_RCVTIMEO,
  928. &val, sizeof(int));
  929. if (IS_ERR(ret))
  930. return unix_to_pal_error(ERRNO(ret));
  931. handle->sock.receivetimeout = attr->socket.receivetimeout;
  932. }
  933. if (attr->socket.sendtimeout != handle->sock.sendtimeout) {
  934. int val = attr->socket.sendtimeout;
  935. ret = INLINE_SYSCALL(setsockopt, 5, fd, SOL_SOCKET, SO_SNDTIMEO,
  936. &val, sizeof(int));
  937. if (IS_ERR(ret))
  938. return unix_to_pal_error(ERRNO(ret));
  939. handle->sock.sendtimeout = attr->socket.sendtimeout;
  940. }
  941. }
  942. if (IS_HANDLE_TYPE(handle, tcp) || IS_HANDLE_TYPE(handle, tcpsrv)) {
  943. if (attr->socket.tcp_cork != handle->sock.tcp_cork) {
  944. val = attr->socket.tcp_cork ? 1 : 0;
  945. ret = INLINE_SYSCALL(setsockopt, 5, fd, SOL_TCP, TCP_CORK,
  946. &val, sizeof(int));
  947. if (IS_ERR(ret))
  948. return unix_to_pal_error(ERRNO(ret));
  949. handle->sock.tcp_cork = attr->socket.tcp_cork;
  950. }
  951. if (attr->socket.tcp_keepalive != handle->sock.tcp_keepalive) {
  952. val = attr->socket.tcp_keepalive ? 1 : 0;
  953. ret = INLINE_SYSCALL(setsockopt, 5, fd, SOL_SOCKET, SO_KEEPALIVE,
  954. &val, sizeof(int));
  955. if (IS_ERR(ret))
  956. return unix_to_pal_error(ERRNO(ret));
  957. handle->sock.tcp_keepalive = attr->socket.tcp_keepalive;
  958. }
  959. if (attr->socket.tcp_nodelay != handle->sock.tcp_nodelay) {
  960. val = attr->socket.tcp_nodelay ? 1 : 0;
  961. ret = INLINE_SYSCALL(setsockopt, 5, fd, SOL_TCP, TCP_NODELAY,
  962. &val, sizeof(int));
  963. if (IS_ERR(ret))
  964. return unix_to_pal_error(ERRNO(ret));
  965. handle->sock.tcp_nodelay = attr->socket.tcp_nodelay;
  966. }
  967. }
  968. return 0;
  969. }
  970. static int socket_getname (PAL_HANDLE handle, char * buffer, int count)
  971. {
  972. int old_count = count;
  973. int ret;
  974. const char * prefix = NULL;
  975. int prefix_len = 0;
  976. struct sockaddr * bind_addr = NULL, * dest_addr = NULL;
  977. switch (PAL_GET_TYPE(handle)) {
  978. case pal_type_tcpsrv:
  979. prefix_len = static_strlen("tcp.srv");
  980. prefix = "tcp.srv";
  981. bind_addr = (struct sockaddr *) handle->sock.bind;
  982. break;
  983. case pal_type_tcp:
  984. prefix_len = static_strlen("tcp");
  985. prefix = "tcp";
  986. bind_addr = (struct sockaddr *) handle->sock.bind;
  987. dest_addr = (struct sockaddr *) handle->sock.conn;
  988. break;
  989. case pal_type_udpsrv:
  990. prefix_len = static_strlen("udp.srv");
  991. prefix = "udp.srv";
  992. bind_addr = (struct sockaddr *) handle->sock.bind;
  993. break;
  994. case pal_type_udp:
  995. prefix_len = static_strlen("udp");
  996. prefix = "udp";
  997. bind_addr = (struct sockaddr *) handle->sock.bind;
  998. dest_addr = (struct sockaddr *) handle->sock.conn;
  999. break;
  1000. default:
  1001. return -PAL_ERROR_INVAL;
  1002. }
  1003. if (prefix_len >= count)
  1004. return -PAL_ERROR_OVERFLOW;
  1005. memcpy(buffer, prefix, prefix_len + 1);
  1006. buffer += prefix_len;
  1007. count -= prefix_len;
  1008. for (int i = 0 ; i < 2 ; i++) {
  1009. struct sockaddr * addr = i ? dest_addr : bind_addr;
  1010. if (addr) {
  1011. if (count <= 1)
  1012. return -PAL_ERROR_OVERFLOW;
  1013. buffer[0] = ':';
  1014. buffer[1] = 0;
  1015. buffer++;
  1016. count--;
  1017. if ((ret = inet_create_uri(buffer, count, addr,
  1018. addr_size(addr))) < 0)
  1019. return ret;
  1020. buffer += ret;
  1021. count -= ret;
  1022. }
  1023. }
  1024. return old_count - count;
  1025. }
  1026. struct handle_ops tcp_ops = {
  1027. .getname = &socket_getname,
  1028. .open = &tcp_open,
  1029. .waitforclient = &tcp_accept,
  1030. .read = &tcp_read,
  1031. .write = &tcp_write,
  1032. .delete = &socket_delete,
  1033. .close = &socket_close,
  1034. .attrquerybyhdl = &socket_attrquerybyhdl,
  1035. .attrsetbyhdl = &socket_attrsetbyhdl,
  1036. };
  1037. struct handle_ops udp_ops = {
  1038. .getname = &socket_getname,
  1039. .open = &udp_open,
  1040. .read = &udp_receive,
  1041. .write = &udp_send,
  1042. .delete = &socket_delete,
  1043. .close = &socket_close,
  1044. .attrquerybyhdl = &socket_attrquerybyhdl,
  1045. .attrsetbyhdl = &socket_attrsetbyhdl,
  1046. };
  1047. struct handle_ops udpsrv_ops = {
  1048. .getname = &socket_getname,
  1049. .open = &udp_open,
  1050. .readbyaddr = &udp_receivebyaddr,
  1051. .writebyaddr = &udp_sendbyaddr,
  1052. .delete = &socket_delete,
  1053. .close = &socket_close,
  1054. .attrquerybyhdl = &socket_attrquerybyhdl,
  1055. .attrsetbyhdl = &socket_attrsetbyhdl,
  1056. };
  1057. PAL_HANDLE _DkBroadcastStreamOpen (void)
  1058. {
  1059. if (!pal_sec.mcast_port) {
  1060. unsigned short mcast_port;
  1061. _DkFastRandomBitsRead(&mcast_port, sizeof(unsigned short));
  1062. pal_sec.mcast_port = mcast_port > 1024 ? mcast_port : mcast_port + 1024;
  1063. }
  1064. struct sockaddr_in addr;
  1065. int ret = 0;
  1066. addr.sin_family = AF_INET;
  1067. addr.sin_addr.s_addr = INADDR_ANY;
  1068. addr.sin_port = __htons(pal_sec.mcast_port);
  1069. /* set up server (sender) side */
  1070. int srv = INLINE_SYSCALL(socket, 3, AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, 0);
  1071. if (IS_ERR(srv))
  1072. goto err;
  1073. ret = INLINE_SYSCALL(setsockopt, 5, srv, IPPROTO_IP, IP_MULTICAST_IF,
  1074. &addr.sin_addr.s_addr, sizeof(addr.sin_addr.s_addr));
  1075. if (IS_ERR(ret))
  1076. goto err_srv;
  1077. /* set up client (receiver) side */
  1078. int cli = INLINE_SYSCALL(socket, 3, AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, 0);
  1079. if (IS_ERR(cli))
  1080. goto err_srv;
  1081. int reuse = 1;
  1082. INLINE_SYSCALL(setsockopt, 5, cli, SOL_SOCKET, SO_REUSEADDR,
  1083. &reuse, sizeof(reuse));
  1084. ret = INLINE_SYSCALL(bind, 3, cli, &addr, sizeof(addr));
  1085. if (IS_ERR(ret))
  1086. goto err_cli;
  1087. ret = INLINE_SYSCALL(setsockopt, 5, cli, IPPROTO_IP, IP_MULTICAST_IF,
  1088. &addr.sin_addr.s_addr, sizeof(addr.sin_addr.s_addr));
  1089. if (IS_ERR(ret))
  1090. goto err_cli;
  1091. inet_pton4(GRAPHENE_MCAST_GROUP, sizeof(GRAPHENE_MCAST_GROUP) - 1,
  1092. &addr.sin_addr.s_addr);
  1093. struct ip_mreq group;
  1094. group.imr_multiaddr.s_addr = addr.sin_addr.s_addr;
  1095. group.imr_interface.s_addr = INADDR_ANY;
  1096. ret = INLINE_SYSCALL(setsockopt, 5, cli, IPPROTO_IP, IP_ADD_MEMBERSHIP,
  1097. &group, sizeof(group));
  1098. if (IS_ERR(ret))
  1099. goto err_cli;
  1100. PAL_HANDLE hdl = malloc(HANDLE_SIZE(mcast));
  1101. SET_HANDLE_TYPE(hdl, mcast);
  1102. HANDLE_HDR(hdl)->flags |= WFD(1)|WRITEABLE(1);
  1103. hdl->mcast.srv = srv;
  1104. hdl->mcast.cli = cli;
  1105. hdl->mcast.port = (PAL_NUM) pal_sec.mcast_port;
  1106. hdl->mcast.nonblocking = PAL_FALSE;
  1107. hdl->mcast.addr = (PAL_PTR) remalloc(&addr, sizeof(addr));
  1108. return hdl;
  1109. err_cli:
  1110. INLINE_SYSCALL(close, 1, cli);
  1111. err_srv:
  1112. INLINE_SYSCALL(close, 1, srv);
  1113. err:
  1114. return NULL;
  1115. }
  1116. static int mcast_send (PAL_HANDLE handle, int offset, int size,
  1117. const void * buf)
  1118. {
  1119. if (handle->mcast.srv == PAL_IDX_POISON)
  1120. return -PAL_ERROR_BADHANDLE;
  1121. struct msghdr hdr;
  1122. struct iovec iov;
  1123. iov.iov_base = (void *) buf;
  1124. iov.iov_len = size;
  1125. hdr.msg_name = (char *) handle->mcast.addr;
  1126. hdr.msg_namelen = sizeof(struct sockaddr_in);
  1127. hdr.msg_iov = &iov;
  1128. hdr.msg_iovlen = 1;
  1129. hdr.msg_control = NULL;
  1130. hdr.msg_controllen = 0;
  1131. hdr.msg_flags = 0;
  1132. int bytes = INLINE_SYSCALL(sendmsg, 3, handle->mcast.srv, &hdr,
  1133. MSG_NOSIGNAL);
  1134. if (IS_ERR(bytes))
  1135. switch(ERRNO(bytes)) {
  1136. case ECONNRESET:
  1137. case EPIPE:
  1138. return -PAL_ERROR_CONNFAILED;
  1139. case EAGAIN:
  1140. HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
  1141. default:
  1142. return unix_to_pal_error(ERRNO(bytes));
  1143. }
  1144. if (bytes == size)
  1145. HANDLE_HDR(handle)->flags |= WRITEABLE(1);
  1146. else
  1147. HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
  1148. return bytes;
  1149. }
  1150. static int mcast_receive (PAL_HANDLE handle, int offset, int size, void * buf)
  1151. {
  1152. if (handle->mcast.cli == PAL_IDX_POISON)
  1153. return -PAL_ERROR_BADHANDLE;
  1154. struct msghdr hdr;
  1155. struct iovec iov;
  1156. iov.iov_base = buf;
  1157. iov.iov_len = size;
  1158. hdr.msg_name = NULL;
  1159. hdr.msg_namelen = 0;
  1160. hdr.msg_iov = &iov;
  1161. hdr.msg_iovlen = 1;
  1162. hdr.msg_control = NULL;
  1163. hdr.msg_controllen = 0;
  1164. hdr.msg_flags = 0;
  1165. int bytes = INLINE_SYSCALL(recvmsg, 3, handle->mcast.cli, &hdr, 0);
  1166. if (IS_ERR(bytes))
  1167. return -PAL_ERROR_DENIED;
  1168. return bytes;
  1169. }
  1170. static int mcast_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
  1171. {
  1172. int ret, val;
  1173. if (handle->mcast.cli == PAL_IDX_POISON)
  1174. return -PAL_ERROR_BADHANDLE;
  1175. ret = INLINE_SYSCALL(ioctl, 3, handle->mcast.cli, FIONREAD, &val);
  1176. if (IS_ERR(ret))
  1177. return unix_to_pal_error(ERRNO(ret));
  1178. attr->handle_type = pal_type_mcast;
  1179. attr->disconnected = HANDLE_HDR(handle)->flags & (ERROR(0)|ERROR(1));
  1180. attr->nonblocking = handle->mcast.nonblocking;
  1181. attr->readable = !!val;
  1182. attr->writeable = HANDLE_HDR(handle)->flags & WRITEABLE(1);
  1183. attr->runnable = PAL_FALSE;
  1184. attr->pending_size = val;
  1185. return 0;
  1186. }
  1187. static int mcast_attrsetbyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
  1188. {
  1189. if (handle->mcast.cli == PAL_IDX_POISON)
  1190. return -PAL_ERROR_BADHANDLE;
  1191. int ret;
  1192. PAL_BOL * nonblocking = &handle->mcast.nonblocking;
  1193. if (attr->nonblocking != *nonblocking) {
  1194. ret = INLINE_SYSCALL(fcntl, 3, handle->mcast.cli, F_SETFL,
  1195. *nonblocking ? O_NONBLOCK : 0);
  1196. if (IS_ERR(ret))
  1197. return unix_to_pal_error(ERRNO(ret));
  1198. *nonblocking = attr->nonblocking;
  1199. }
  1200. return 0;
  1201. }
  1202. struct handle_ops mcast_ops = {
  1203. .write = &mcast_send,
  1204. .read = &mcast_receive,
  1205. .attrquerybyhdl = &mcast_attrquerybyhdl,
  1206. .attrsetbyhdl = &mcast_attrsetbyhdl,
  1207. };