db_sockets.c 33 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132
  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 <linux/types.h>
  31. #include <linux/poll.h>
  32. #include <linux/in.h>
  33. #include <linux/in6.h>
  34. typedef __kernel_pid_t pid_t;
  35. #include <asm/fcntl.h>
  36. #include <asm-generic/socket.h>
  37. #ifndef SOL_TCP
  38. # define SOL_TCP 6
  39. #endif
  40. #ifndef TCP_NODELAY
  41. # define TCP_NODELAY 1
  42. #endif
  43. #ifndef TCP_CORK
  44. # define TCP_CORK 3
  45. #endif
  46. /* 96 bytes is the minimal size of buffer to store a IPv4/IPv6
  47. address */
  48. #define PAL_SOCKADDR_SIZE 96
  49. static inline int addr_size (struct sockaddr * addr)
  50. {
  51. switch (addr->sa_family) {
  52. case AF_INET:
  53. return sizeof(struct sockaddr_in);
  54. case AF_INET6:
  55. return sizeof(struct sockaddr_in6);
  56. default:
  57. return 0;
  58. }
  59. }
  60. /* parsing the string of uri, and fill in the socket address structure.
  61. the latest pointer of uri, length of socket address are returned. */
  62. static int inet_parse_uri (char ** uri, struct sockaddr * addr, unsigned int * addrlen)
  63. {
  64. char * tmp = *uri, * end;
  65. char * addr_str = NULL, * port_str;
  66. int af;
  67. void * addr_buf;
  68. int addr_len;
  69. __be16 * port_buf;
  70. int slen;
  71. if (tmp[0] == '[') {
  72. /* for IPv6, the address will be in the form of
  73. "[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx]:port". */
  74. struct sockaddr_in6 * addr_in6 = (struct sockaddr_in6 *) addr;
  75. slen = sizeof(struct sockaddr_in6);
  76. memset(addr, 0, slen);
  77. end = strchr(tmp + 1, ']');
  78. if (!end || *(end + 1) != ':')
  79. goto inval;
  80. addr_str = tmp + 1;
  81. addr_len = end - tmp - 1;
  82. port_str = end + 2;
  83. for (end = port_str ; *end >= '0' && *end <= '9' ; end++);
  84. addr_in6->sin6_family = af = AF_INET6;
  85. addr_buf = &addr_in6->sin6_addr.s6_addr;
  86. port_buf = &addr_in6->sin6_port;
  87. } else {
  88. /* for IP, the address will be in the form of "x.x.x.x:port". */
  89. struct sockaddr_in * addr_in = (struct sockaddr_in *) addr;
  90. slen = sizeof(struct sockaddr_in);
  91. memset(addr, 0, slen);
  92. end = strchr(tmp, ':');
  93. if (!end)
  94. goto inval;
  95. addr_str = tmp;
  96. addr_len = end - tmp;
  97. port_str = end + 1;
  98. for (end = port_str ; *end >= '0' && *end <= '9' ; end++);
  99. addr_in->sin_family = af = AF_INET;
  100. addr_buf = &addr_in->sin_addr.s_addr;
  101. port_buf = &addr_in->sin_port;
  102. }
  103. if (af == AF_INET) {
  104. if (!inet_pton4(addr_str, addr_len, addr_buf))
  105. goto inval;
  106. } else {
  107. if (!inet_pton6(addr_str, addr_len, addr_buf))
  108. goto inval;
  109. }
  110. *port_buf = __htons(atoi(port_str));
  111. *uri = *end ? end + 1 : NULL;
  112. if (addrlen)
  113. *addrlen = slen;
  114. return 0;
  115. inval:
  116. return -PAL_ERROR_INVAL;
  117. }
  118. /* create the string of uri from the given socket address */
  119. static int inet_create_uri (char * uri, int count, struct sockaddr * addr,
  120. int addrlen)
  121. {
  122. int len = 0;
  123. if (addr->sa_family == AF_INET) {
  124. if (addrlen != sizeof(struct sockaddr_in))
  125. return PAL_ERROR_INVAL;
  126. struct sockaddr_in * addr_in = (struct sockaddr_in *) addr;
  127. char * addr = (char *) &addr_in->sin_addr.s_addr;
  128. /* for IP, the address will be in the form of "x.x.x.x:port". */
  129. len = snprintf(uri, count, "%u.%u.%u.%u:%u",
  130. (unsigned char) addr[0],
  131. (unsigned char) addr[1],
  132. (unsigned char) addr[2],
  133. (unsigned char) addr[3],
  134. __ntohs(addr_in->sin_port));
  135. } else if (addr->sa_family == AF_INET6) {
  136. if (addrlen != sizeof(struct sockaddr_in6))
  137. return PAL_ERROR_INVAL;
  138. struct sockaddr_in6 * addr_in6 = (struct sockaddr_in6 *) addr;
  139. unsigned short * addr = (unsigned short *) &addr_in6->sin6_addr.s6_addr;
  140. /* for IPv6, the address will be in the form of
  141. "[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx]:port". */
  142. len = snprintf(uri, count, "[%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x]:%u",
  143. addr[0], addr[1], addr[2], addr[3],
  144. addr[4], addr[5], addr[6], addr[7],
  145. __ntohs(addr_in6->sin6_port));
  146. } else {
  147. return -PAL_ERROR_INVAL;
  148. }
  149. if (len >= count)
  150. return -PAL_ERROR_TOOLONG;
  151. return len;
  152. }
  153. /* parse the uri for a socket stream. The uri might have both binding
  154. address and connecting address, or connecting address only. The form
  155. of uri will be either "bind-addr:bind-port:connect-addr:connect-port"
  156. or "addr:port". */
  157. static int socket_parse_uri (char * uri,
  158. struct sockaddr ** bind_addr, unsigned int * bind_addrlen,
  159. struct sockaddr ** dest_addr, unsigned int * dest_addrlen)
  160. {
  161. int ret;
  162. if (!bind_addr && !dest_addr)
  163. return 0;
  164. if (!uri || !(*uri)) {
  165. if (bind_addr)
  166. *bind_addr = NULL;
  167. if (dest_addr)
  168. *dest_addr = NULL;
  169. return 0;
  170. }
  171. /* at least parse uri once */
  172. if ((ret = inet_parse_uri(&uri, bind_addr ? *bind_addr : *dest_addr,
  173. bind_addr ? bind_addrlen : dest_addrlen)) < 0)
  174. return ret;
  175. if (!(bind_addr && dest_addr))
  176. return 0;
  177. /* if you reach here, it can only be connection address */
  178. if (!uri || (ret = inet_parse_uri(&uri, *dest_addr, dest_addrlen)) < 0) {
  179. *dest_addr = *bind_addr;
  180. *dest_addrlen = *bind_addrlen;
  181. *bind_addr = NULL;
  182. *bind_addrlen = 0;
  183. }
  184. return 0;
  185. }
  186. /* fill in the PAL handle based on the file descriptors and address given. */
  187. static inline
  188. PAL_HANDLE socket_create_handle (int type, int fd, int options,
  189. struct sockaddr * bind_addr,
  190. unsigned int bind_addrlen,
  191. struct sockaddr * dest_addr,
  192. unsigned int dest_addrlen,
  193. struct sockopt * sock_options)
  194. {
  195. PAL_HANDLE hdl = malloc(HANDLE_SIZE(sock) + (bind_addr ? bind_addrlen : 0) +
  196. (dest_addr ? dest_addrlen : 0));
  197. if (!hdl)
  198. return NULL;
  199. memset(hdl, 0, sizeof(struct pal_handle));
  200. init_handle_hdr(HANDLE_HDR(hdl), type);
  201. HANDLE_HDR(hdl)->flags |= RFD(0)|(type != pal_type_tcpsrv ? WFD(0) : 0);
  202. hdl->sock.fd = fd;
  203. void * addr = (void *) hdl + HANDLE_SIZE(sock);
  204. if (bind_addr) {
  205. hdl->sock.bind = (PAL_PTR) addr;
  206. memcpy(addr, bind_addr, bind_addrlen);
  207. addr += bind_addrlen;
  208. } else {
  209. hdl->sock.bind = (PAL_PTR) NULL;
  210. }
  211. if (dest_addr) {
  212. hdl->sock.conn = (PAL_PTR) addr;
  213. memcpy(addr, dest_addr, dest_addrlen);
  214. addr += dest_addrlen;
  215. } else {
  216. hdl->sock.conn = (PAL_PTR) NULL;
  217. }
  218. hdl->sock.nonblocking = (options & PAL_OPTION_NONBLOCK) ?
  219. PAL_TRUE : PAL_FALSE;
  220. hdl->sock.linger = sock_options->linger;
  221. hdl->sock.receivebuf = sock_options->receivebuf;
  222. hdl->sock.sendbuf = sock_options->sendbuf;
  223. hdl->sock.receivetimeout = sock_options->receivetimeout;
  224. hdl->sock.sendtimeout = sock_options->sendtimeout;
  225. hdl->sock.tcp_cork = sock_options->tcp_cork;
  226. hdl->sock.tcp_keepalive = sock_options->tcp_keepalive;
  227. hdl->sock.tcp_nodelay = sock_options->tcp_nodelay;
  228. return hdl;
  229. }
  230. #if ALLOW_BIND_ANY == 0
  231. static bool check_zero (void * mem, size_t size)
  232. {
  233. void * p = mem, * q = mem + size;
  234. while (p < q) {
  235. if (p <= q - sizeof(long)) {
  236. if (*(long *) p)
  237. return false;
  238. p += sizeof(long);
  239. } else if (p <= q - sizeof(int)) {
  240. if (*(int *) p)
  241. return false;
  242. p += sizeof(int);
  243. } else if (p <= q - sizeof(short)) {
  244. if (*(short *) p)
  245. return false;
  246. p += sizeof(short);
  247. } else {
  248. if (*(char *) p)
  249. return false;
  250. p++;
  251. }
  252. }
  253. return true;
  254. }
  255. /* check if an address is "Any" */
  256. static bool check_any_addr (struct sockaddr * addr)
  257. {
  258. if (addr->sa_family == AF_INET) {
  259. struct sockaddr_in * addr_in =
  260. (struct sockaddr_in *) addr;
  261. return addr_in->sin_port == 0 &&
  262. check_zero(&addr_in->sin_addr,
  263. sizeof(addr_in->sin_addr));
  264. } else if (addr->sa_family == AF_INET6) {
  265. struct sockaddr_in6 * addr_in6 =
  266. (struct sockaddr_in6 *) addr;
  267. return addr_in6->sin6_port == 0 &&
  268. check_zero(&addr_in6->sin6_addr,
  269. sizeof(addr_in6->sin6_addr));
  270. }
  271. return false;
  272. }
  273. #endif
  274. static inline int sock_type (int type, int options)
  275. {
  276. if (options & PAL_OPTION_NONBLOCK)
  277. type |= SOCK_NONBLOCK;
  278. return type;
  279. }
  280. /* listen on a tcp socket */
  281. static int tcp_listen (PAL_HANDLE * handle, char * uri, int options)
  282. {
  283. struct sockaddr buffer, * bind_addr = &buffer;
  284. unsigned int bind_addrlen;
  285. int ret;
  286. if ((ret = socket_parse_uri(uri, &bind_addr, &bind_addrlen,
  287. NULL, NULL)) < 0)
  288. return ret;
  289. #if ALLOW_BIND_ANY == 0
  290. /* the socket need to have a binding address, a null address or an
  291. any address is not allowed */
  292. if (addr_check_any(bind_addr))
  293. return -PAL_ERROR_INVAL;
  294. #endif
  295. struct sockopt sock_options;
  296. ret = ocall_sock_listen(bind_addr->sa_family,
  297. sock_type(SOCK_STREAM, options), 0,
  298. bind_addr, bind_addrlen,
  299. &sock_options);
  300. if (ret < 0)
  301. return ret;
  302. *handle = socket_create_handle(pal_type_tcpsrv, ret, options,
  303. bind_addr, bind_addrlen, NULL, 0,
  304. &sock_options);
  305. if (!(*handle)) {
  306. ocall_close(ret);
  307. return -PAL_ERROR_NOMEM;
  308. }
  309. return 0;
  310. }
  311. /* accept a tcp connection */
  312. static int tcp_accept (PAL_HANDLE handle, PAL_HANDLE * client)
  313. {
  314. if (!IS_HANDLE_TYPE(handle, tcpsrv) ||
  315. !handle->sock.bind || handle->sock.conn)
  316. return -PAL_ERROR_NOTSERVER;
  317. if (handle->sock.fd == PAL_IDX_POISON)
  318. return -PAL_ERROR_BADHANDLE;
  319. struct sockaddr * bind_addr = (struct sockaddr *) handle->sock.bind;
  320. unsigned int bind_addrlen = addr_size(bind_addr);
  321. struct sockaddr dest_addr;
  322. unsigned int dest_addrlen = sizeof(struct sockaddr);
  323. int ret = 0;
  324. struct sockopt sock_options;
  325. ret = ocall_sock_accept(handle->sock.fd, &dest_addr, &dest_addrlen,
  326. &sock_options);
  327. if (ret < 0)
  328. return ret;
  329. *client = socket_create_handle(pal_type_tcp, ret, 0, bind_addr,
  330. bind_addrlen,
  331. &dest_addr, dest_addrlen,
  332. &sock_options);
  333. if (!(*client)) {
  334. ocall_close(ret);
  335. return -PAL_ERROR_NOMEM;
  336. }
  337. return 0;
  338. }
  339. /* connect on a tcp socket */
  340. static int tcp_connect (PAL_HANDLE * handle, char * uri, int options)
  341. {
  342. struct sockaddr buffer[2];
  343. struct sockaddr * bind_addr = buffer, * dest_addr = buffer + 1;
  344. unsigned int bind_addrlen, dest_addrlen;
  345. int ret;
  346. /* accepting two kind of different uri:
  347. dest-ip:dest-port or bind-ip:bind-port:dest-ip:dest-port */
  348. if ((ret = socket_parse_uri(uri, &bind_addr, &bind_addrlen,
  349. &dest_addr, &dest_addrlen)) < 0)
  350. return ret;
  351. if (!dest_addr)
  352. return -PAL_ERROR_INVAL;
  353. if (bind_addr && bind_addr->sa_family != dest_addr->sa_family)
  354. return -PAL_ERROR_INVAL;
  355. #if ALLOW_BIND_ANY == 0
  356. /* the socket need to have a binding address, a null address or an
  357. any address is not allowed */
  358. if (bind_addr && addr_check_any(bind_addr))
  359. return -PAL_ERROR_INVAL;
  360. #endif
  361. struct sockopt sock_options;
  362. ret = ocall_sock_connect(dest_addr->sa_family,
  363. sock_type(SOCK_STREAM, options), 0,
  364. dest_addr, dest_addrlen,
  365. bind_addr, &bind_addrlen, &sock_options);
  366. if (ret < 0)
  367. return ret;
  368. *handle = socket_create_handle(pal_type_tcp, ret, options,
  369. bind_addr, bind_addrlen,
  370. dest_addr, dest_addrlen,
  371. &sock_options);
  372. if (!(*handle)) {
  373. ocall_close(ret);
  374. return -PAL_ERROR_NOMEM;
  375. }
  376. return 0;
  377. }
  378. /* 'open' operation of tcp stream */
  379. static int tcp_open (PAL_HANDLE *handle, const char * type, const char * uri,
  380. int access, int share, int create, int options)
  381. {
  382. int uri_len = strlen(uri) + 1;
  383. if (uri_len > PAL_SOCKADDR_SIZE)
  384. return -PAL_ERROR_TOOLONG;
  385. char uri_buf[PAL_SOCKADDR_SIZE];
  386. memcpy(uri_buf, uri, uri_len);
  387. if (strpartcmp_static(type, "tcp.srv:"))
  388. return tcp_listen(handle, uri_buf, options);
  389. if (strpartcmp_static(type, "tcp:"))
  390. return tcp_connect(handle, uri_buf, options);
  391. return -PAL_ERROR_NOTSUPPORT;
  392. }
  393. /* 'read' operation of tcp stream */
  394. static int tcp_read (PAL_HANDLE handle, int offset, int len, void * buf)
  395. {
  396. if (!IS_HANDLE_TYPE(handle, tcp) || !handle->sock.conn)
  397. return -PAL_ERROR_NOTCONNECTION;
  398. if (handle->sock.fd == PAL_IDX_POISON)
  399. return -PAL_ERROR_ENDOFSTREAM;
  400. int bytes = ocall_sock_recv(handle->sock.fd, buf, len, NULL, NULL);
  401. if (bytes < 0)
  402. return bytes;
  403. if (!bytes)
  404. return -PAL_ERROR_ENDOFSTREAM;
  405. return bytes;
  406. }
  407. /* write' operation of tcp stream */
  408. static int tcp_write (PAL_HANDLE handle, int offset, int len, const void * buf)
  409. {
  410. if (!IS_HANDLE_TYPE(handle, tcp) || !handle->sock.conn)
  411. return -PAL_ERROR_NOTCONNECTION;
  412. if (handle->sock.fd == PAL_IDX_POISON)
  413. return -PAL_ERROR_CONNFAILED;
  414. int bytes = ocall_sock_send(handle->sock.fd, buf, len, NULL, 0);
  415. if (bytes == -PAL_ERROR_TRYAGAIN)
  416. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  417. if (bytes < 0)
  418. return bytes;
  419. if (bytes == len)
  420. HANDLE_HDR(handle)->flags |= WRITEABLE(0);
  421. else
  422. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  423. return bytes;
  424. }
  425. /* used by 'open' operation of tcp stream for bound socket */
  426. static int udp_bind (PAL_HANDLE * handle, char * uri, int options)
  427. {
  428. struct sockaddr buffer, * bind_addr = &buffer;
  429. unsigned int bind_addrlen;
  430. int ret = 0;
  431. if ((ret = socket_parse_uri(uri, &bind_addr, &bind_addrlen,
  432. NULL, NULL)) < 0)
  433. return ret;
  434. assert(bind_addr);
  435. assert(bind_addrlen == addr_size(bind_addr));
  436. #if ALLOW_BIND_ANY == 0
  437. /* the socket need to have a binding address, a null address or an
  438. any address is not allowed */
  439. if (addr_check_any(bind_addr))
  440. return -PAL_ERROR_INVAL;
  441. #endif
  442. struct sockopt sock_options;
  443. ret = ocall_sock_listen(bind_addr->sa_family,
  444. sock_type(SOCK_DGRAM, options), 0,
  445. bind_addr, bind_addrlen, &sock_options);
  446. if (ret < 0)
  447. return ret;
  448. *handle = socket_create_handle(pal_type_udpsrv, ret, options,
  449. bind_addr, bind_addrlen, NULL, 0,
  450. &sock_options);
  451. if (!(*handle)) {
  452. ocall_close(ret);
  453. return -PAL_ERROR_NOMEM;
  454. }
  455. return 0;
  456. }
  457. /* used by 'open' operation of tcp stream for connected socket */
  458. static int udp_connect (PAL_HANDLE * handle, char * uri, int options)
  459. {
  460. struct sockaddr buffer[2];
  461. struct sockaddr * bind_addr = buffer, * dest_addr = buffer + 1;
  462. unsigned int bind_addrlen, dest_addrlen;
  463. int ret;
  464. if ((ret = socket_parse_uri(uri, &bind_addr, &bind_addrlen,
  465. &dest_addr, &dest_addrlen)) < 0)
  466. return ret;
  467. #if ALLOW_BIND_ANY == 0
  468. /* the socket need to have a binding address, a null address or an
  469. any address is not allowed */
  470. if (bind_addr && addr_check_any(bind_addr))
  471. return -PAL_ERROR_INVAL;
  472. #endif
  473. struct sockopt sock_options;
  474. ret = ocall_sock_connect(dest_addr ? dest_addr->sa_family : AF_INET,
  475. sock_type(SOCK_DGRAM, options), 0,
  476. dest_addr, dest_addrlen,
  477. bind_addr, &bind_addrlen, &sock_options);
  478. if (ret < 0)
  479. return ret;
  480. *handle = socket_create_handle(dest_addr ? pal_type_udp :
  481. pal_type_udpsrv, ret, options,
  482. bind_addr, bind_addrlen,
  483. dest_addr, dest_addrlen,
  484. &sock_options);
  485. if (!(*handle)) {
  486. ocall_close(ret);
  487. return -PAL_ERROR_NOMEM;
  488. }
  489. return 0;
  490. }
  491. static int udp_open (PAL_HANDLE *hdl, const char * type, const char * uri,
  492. int access, int share, int create, int options)
  493. {
  494. char buf[PAL_SOCKADDR_SIZE];
  495. int len = strlen(uri);
  496. if (len >= PAL_SOCKADDR_SIZE)
  497. return -PAL_ERROR_TOOLONG;
  498. memcpy(buf, uri, len + 1);
  499. options &= PAL_OPTION_MASK;
  500. if (strpartcmp_static(type, "udp.srv:"))
  501. return udp_bind(hdl, buf, options);
  502. if (strpartcmp_static(type, "udp:"))
  503. return udp_connect(hdl, buf, options);
  504. return -PAL_ERROR_NOTSUPPORT;
  505. }
  506. static int udp_receive (PAL_HANDLE handle, int offset, int len, void * buf)
  507. {
  508. if (!IS_HANDLE_TYPE(handle, udp))
  509. return -PAL_ERROR_NOTCONNECTION;
  510. if (handle->sock.fd == PAL_IDX_POISON)
  511. return -PAL_ERROR_BADHANDLE;
  512. return ocall_sock_recv(handle->sock.fd, buf, len, NULL, NULL);
  513. }
  514. static int udp_receivebyaddr (PAL_HANDLE handle, int offset, int len,
  515. void * buf, char * addr, int addrlen)
  516. {
  517. if (!IS_HANDLE_TYPE(handle, udpsrv))
  518. return -PAL_ERROR_NOTCONNECTION;
  519. if (handle->sock.fd == PAL_IDX_POISON)
  520. return -PAL_ERROR_BADHANDLE;
  521. struct sockaddr conn_addr;
  522. socklen_t conn_addrlen = sizeof(struct sockaddr);
  523. int bytes = ocall_sock_recv(handle->sock.fd, buf, len, &conn_addr,
  524. &conn_addrlen);
  525. if (bytes < 0)
  526. return bytes;
  527. char * addr_uri = strcpy_static(addr, "udp:", addrlen);
  528. if (!addr_uri)
  529. return -PAL_ERROR_OVERFLOW;
  530. int ret = inet_create_uri(addr_uri, addr + addrlen - addr_uri, &conn_addr,
  531. conn_addrlen);
  532. if (ret < 0)
  533. return ret;
  534. return bytes;
  535. }
  536. static int udp_send (PAL_HANDLE handle, int offset, int len, const void * buf)
  537. {
  538. if (!IS_HANDLE_TYPE(handle, udp))
  539. return -PAL_ERROR_NOTCONNECTION;
  540. if (handle->sock.fd == PAL_IDX_POISON)
  541. return -PAL_ERROR_BADHANDLE;
  542. int bytes = ocall_sock_send(handle->sock.fd, buf, len, NULL, 0);
  543. if (bytes == -PAL_ERROR_TRYAGAIN)
  544. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  545. if (bytes < 0)
  546. return bytes;
  547. if (bytes == len)
  548. HANDLE_HDR(handle)->flags |= WRITEABLE(0);
  549. else
  550. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  551. return bytes;
  552. }
  553. static int udp_sendbyaddr (PAL_HANDLE handle, int offset, int len,
  554. const void * buf, const char * addr, int addrlen)
  555. {
  556. if (!IS_HANDLE_TYPE(handle, udpsrv))
  557. return -PAL_ERROR_NOTCONNECTION;
  558. if (handle->sock.fd == PAL_IDX_POISON)
  559. return -PAL_ERROR_BADHANDLE;
  560. if (!strpartcmp_static(addr, "udp:"))
  561. return -PAL_ERROR_INVAL;
  562. addr += static_strlen("udp:");
  563. addrlen -= static_strlen("udp:");
  564. char * addrbuf = __alloca(addrlen);
  565. memcpy(addrbuf, addr, addrlen);
  566. struct sockaddr conn_addr;
  567. unsigned int conn_addrlen = sizeof(struct sockaddr);
  568. int ret = inet_parse_uri(&addrbuf, &conn_addr, &conn_addrlen);
  569. if (ret < 0)
  570. return ret;
  571. int bytes = ocall_sock_send(handle->sock.fd, buf, len, &conn_addr,
  572. conn_addrlen);
  573. if (bytes == -PAL_ERROR_TRYAGAIN)
  574. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  575. if (bytes < 0)
  576. return bytes;
  577. if (bytes == len)
  578. HANDLE_HDR(handle)->flags |= WRITEABLE(0);
  579. else
  580. HANDLE_HDR(handle)->flags &= ~WRITEABLE(0);
  581. return bytes;
  582. }
  583. static int socket_delete (PAL_HANDLE handle, int access)
  584. {
  585. if (handle->sock.fd == PAL_IDX_POISON)
  586. return 0;
  587. if (!IS_HANDLE_TYPE(handle, tcp) && access)
  588. return -PAL_ERROR_INVAL;
  589. if (IS_HANDLE_TYPE(handle, tcp) || IS_HANDLE_TYPE(handle, tcpsrv)) {
  590. int shutdown;
  591. switch (access) {
  592. case 0:
  593. shutdown = SHUT_RDWR;
  594. break;
  595. case PAL_DELETE_RD:
  596. shutdown = SHUT_RD;
  597. break;
  598. case PAL_DELETE_WR:
  599. shutdown = SHUT_WR;
  600. break;
  601. default:
  602. return -PAL_ERROR_INVAL;
  603. }
  604. ocall_sock_shutdown(handle->sock.fd, shutdown);
  605. }
  606. return 0;
  607. }
  608. static int socket_close (PAL_HANDLE handle)
  609. {
  610. if (handle->sock.fd != PAL_IDX_POISON) {
  611. ocall_close(handle->sock.fd);
  612. handle->sock.fd = PAL_IDX_POISON;
  613. }
  614. if (handle->sock.bind)
  615. handle->sock.bind = (PAL_PTR) NULL;
  616. if (handle->sock.conn)
  617. handle->sock.conn = (PAL_PTR) NULL;
  618. return 0;
  619. }
  620. static int socket_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
  621. {
  622. if (handle->sock.fd == PAL_IDX_POISON)
  623. return -PAL_ERROR_BADHANDLE;
  624. attr->handle_type = HANDLE_HDR(handle)->type;
  625. attr->disconnected = HANDLE_HDR(handle)->flags & ERROR(0);
  626. attr->nonblocking = handle->sock.nonblocking;
  627. attr->writeable = HANDLE_HDR(handle)->flags & WRITEABLE(0);
  628. attr->pending_size = 0; /* fill in later */
  629. attr->socket.linger = handle->sock.linger;
  630. attr->socket.receivebuf = handle->sock.receivebuf;
  631. attr->socket.sendbuf = handle->sock.sendbuf;
  632. attr->socket.receivetimeout = handle->sock.receivetimeout;
  633. attr->socket.sendtimeout = handle->sock.sendtimeout;
  634. attr->socket.tcp_cork = handle->sock.tcp_cork;
  635. attr->socket.tcp_keepalive = handle->sock.tcp_keepalive;
  636. attr->socket.tcp_nodelay = handle->sock.tcp_nodelay;
  637. int fd = handle->sock.fd, ret;
  638. if (!IS_HANDLE_TYPE(handle, tcpsrv)) {
  639. /* try use ioctl FIONEAD to get the size of socket */
  640. ret = ocall_fionread(fd);
  641. if (ret < 0)
  642. return ret;
  643. attr->pending_size = ret;
  644. }
  645. struct pollfd pfd = { .fd = fd, .events = POLLIN, .revents = 0 };
  646. unsigned long waittime = 0;
  647. ret = ocall_poll(&pfd, 1, &waittime);
  648. if (ret < 0)
  649. return ret;
  650. attr->readable = (ret == 1 && pfd.revents == POLLIN);
  651. return 0;
  652. }
  653. static int socket_attrsetbyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
  654. {
  655. if (handle->sock.fd == PAL_IDX_POISON)
  656. return -PAL_ERROR_BADHANDLE;
  657. int fd = handle->sock.fd, ret, val;
  658. if (attr->nonblocking != handle->sock.nonblocking) {
  659. ret = ocall_fsetnonblock(fd, attr->nonblocking);
  660. if (ret < 0)
  661. return ret;
  662. handle->sock.nonblocking = attr->nonblocking;
  663. }
  664. if (HANDLE_TYPE(handle) != pal_type_tcpsrv) {
  665. struct __kernel_linger {
  666. int l_onoff;
  667. int l_linger;
  668. };
  669. if (attr->socket.linger != handle->sock.linger) {
  670. struct __kernel_linger l;
  671. l.l_onoff = attr->socket.linger ? 1 : 0;
  672. l.l_linger = attr->socket.linger;
  673. ret = ocall_sock_setopt(fd, SOL_SOCKET, SO_LINGER, &l,
  674. sizeof(struct __kernel_linger));
  675. if (ret < 0)
  676. return ret;
  677. handle->sock.linger = attr->socket.linger;
  678. }
  679. if (attr->socket.receivebuf != handle->sock.receivebuf) {
  680. val = attr->socket.receivebuf;
  681. ret = ocall_sock_setopt(fd, SOL_SOCKET, SO_RCVBUF, &val,
  682. sizeof(int));
  683. if (ret < 0)
  684. return ret;
  685. handle->sock.receivebuf = attr->socket.receivebuf;
  686. }
  687. if (attr->socket.sendbuf != handle->sock.sendbuf) {
  688. val = attr->socket.sendbuf;
  689. ret = ocall_sock_setopt(fd, SOL_SOCKET, SO_SNDBUF,
  690. &val, sizeof(int));
  691. if (ret < 0)
  692. return ret;
  693. handle->sock.sendbuf = attr->socket.sendbuf;
  694. }
  695. if (attr->socket.receivetimeout != handle->sock.receivetimeout) {
  696. val = attr->socket.receivetimeout;
  697. ret = ocall_sock_setopt(fd, SOL_SOCKET, SO_RCVTIMEO,
  698. &val, sizeof(int));
  699. if (ret < 0)
  700. return ret;
  701. handle->sock.receivetimeout = attr->socket.receivetimeout;
  702. }
  703. if (attr->socket.sendtimeout != handle->sock.sendtimeout) {
  704. val = attr->socket.sendtimeout;
  705. ret = ocall_sock_setopt(fd, SOL_SOCKET, SO_SNDTIMEO,
  706. &val, sizeof(int));
  707. if (ret < 0)
  708. return ret;
  709. handle->sock.sendtimeout = attr->socket.sendtimeout;
  710. }
  711. }
  712. if (HANDLE_TYPE(handle) == pal_type_tcp ||
  713. HANDLE_TYPE(handle) == pal_type_tcpsrv) {
  714. if (attr->socket.tcp_cork != handle->sock.tcp_cork) {
  715. val = attr->socket.tcp_cork ? 1 : 0;
  716. ret = ocall_sock_setopt(fd, SOL_TCP, TCP_CORK,
  717. &val, sizeof(int));
  718. if (ret < 0)
  719. return ret;
  720. handle->sock.tcp_cork = attr->socket.tcp_cork;
  721. }
  722. if (attr->socket.tcp_keepalive != handle->sock.tcp_keepalive) {
  723. val = attr->socket.tcp_keepalive ? 1 : 0;
  724. ret = ocall_sock_setopt(fd, SOL_SOCKET, SO_KEEPALIVE,
  725. &val, sizeof(int));
  726. if (ret < 0)
  727. return ret;
  728. handle->sock.tcp_keepalive = attr->socket.tcp_keepalive;
  729. }
  730. if (attr->socket.tcp_nodelay != handle->sock.tcp_nodelay) {
  731. val = attr->socket.tcp_nodelay ? 1 : 0;
  732. ret = ocall_sock_setopt(fd, SOL_TCP, TCP_NODELAY,
  733. &val, sizeof(int));
  734. if (ret < 0)
  735. return ret;
  736. handle->sock.tcp_nodelay = attr->socket.tcp_nodelay;
  737. }
  738. }
  739. return 0;
  740. }
  741. static int socket_getname (PAL_HANDLE handle, char * buffer, int count)
  742. {
  743. int old_count = count;
  744. int ret;
  745. const char * prefix = NULL;
  746. int prefix_len = 0;
  747. struct sockaddr * bind_addr = NULL, * dest_addr = NULL;
  748. switch (HANDLE_TYPE(handle)) {
  749. case pal_type_tcpsrv:
  750. prefix_len = static_strlen("tcp.srv");
  751. prefix = "tcp.srv";
  752. bind_addr = (struct sockaddr *) handle->sock.bind;
  753. break;
  754. case pal_type_tcp:
  755. prefix_len = static_strlen("tcp");
  756. prefix = "tcp";
  757. bind_addr = (struct sockaddr *) handle->sock.bind;
  758. dest_addr = (struct sockaddr *) handle->sock.conn;
  759. break;
  760. case pal_type_udpsrv:
  761. prefix_len = static_strlen("udp.srv");
  762. prefix = "udp.srv";
  763. bind_addr = (struct sockaddr *) handle->sock.bind;
  764. break;
  765. case pal_type_udp:
  766. prefix_len = static_strlen("udp");
  767. prefix = "udp";
  768. bind_addr = (struct sockaddr *) handle->sock.bind;
  769. dest_addr = (struct sockaddr *) handle->sock.conn;
  770. break;
  771. default:
  772. return -PAL_ERROR_INVAL;
  773. }
  774. if (prefix_len >= count)
  775. return -PAL_ERROR_OVERFLOW;
  776. memcpy(buffer, prefix, prefix_len + 1);
  777. buffer += prefix_len;
  778. count -= prefix_len;
  779. for (int i = 0 ; i < 2 ; i++) {
  780. struct sockaddr * addr = i ? dest_addr : bind_addr;
  781. if (addr) {
  782. if (count <= 1)
  783. return -PAL_ERROR_OVERFLOW;
  784. buffer[0] = ':';
  785. buffer[1] = 0;
  786. buffer++;
  787. count--;
  788. if ((ret = inet_create_uri(buffer, count, addr,
  789. addr_size(addr))) < 0)
  790. return ret;
  791. buffer += ret;
  792. count -= ret;
  793. }
  794. }
  795. return old_count - count;
  796. }
  797. struct handle_ops tcp_ops = {
  798. .getname = &socket_getname,
  799. .open = &tcp_open,
  800. .waitforclient = &tcp_accept,
  801. .read = &tcp_read,
  802. .write = &tcp_write,
  803. .delete = &socket_delete,
  804. .close = &socket_close,
  805. .attrquerybyhdl = &socket_attrquerybyhdl,
  806. .attrsetbyhdl = &socket_attrsetbyhdl,
  807. };
  808. struct handle_ops udp_ops = {
  809. .getname = &socket_getname,
  810. .open = &udp_open,
  811. .read = &udp_receive,
  812. .write = &udp_send,
  813. .delete = &socket_delete,
  814. .close = &socket_close,
  815. .attrquerybyhdl = &socket_attrquerybyhdl,
  816. .attrsetbyhdl = &socket_attrsetbyhdl,
  817. };
  818. struct handle_ops udpsrv_ops = {
  819. .getname = &socket_getname,
  820. .open = &udp_open,
  821. .readbyaddr = &udp_receivebyaddr,
  822. .writebyaddr = &udp_sendbyaddr,
  823. .delete = &socket_delete,
  824. .close = &socket_close,
  825. .attrquerybyhdl = &socket_attrquerybyhdl,
  826. .attrsetbyhdl = &socket_attrsetbyhdl,
  827. };
  828. PAL_HANDLE _DkBroadcastStreamOpen (void)
  829. {
  830. PAL_HANDLE hdl = malloc(HANDLE_SIZE(file));
  831. SET_HANDLE_TYPE(hdl, mcast);
  832. HANDLE_HDR(hdl)->flags |= RFD(0)|WFD(1)|WRITEABLE(1);
  833. hdl->mcast.port = pal_sec.mcast_port;
  834. hdl->mcast.srv = pal_sec.mcast_srv;
  835. hdl->mcast.cli = pal_sec.mcast_cli;
  836. return hdl;
  837. }
  838. static int mcast_send (PAL_HANDLE handle, int offset, int size,
  839. const void * buf)
  840. {
  841. if (handle->mcast.srv == PAL_IDX_POISON)
  842. return -PAL_ERROR_BADHANDLE;
  843. int bytes = ocall_sock_send(handle->mcast.srv, buf, size,
  844. NULL, 0);
  845. if (bytes == -PAL_ERROR_TRYAGAIN)
  846. HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
  847. if (bytes < 0)
  848. return bytes;
  849. if (bytes == size)
  850. HANDLE_HDR(handle)->flags |= WRITEABLE(1);
  851. else
  852. HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
  853. return bytes;
  854. }
  855. static int mcast_receive (PAL_HANDLE handle, int offset, int size, void * buf)
  856. {
  857. if (handle->mcast.cli == PAL_IDX_POISON)
  858. return -PAL_ERROR_BADHANDLE;
  859. int bytes = ocall_sock_recv(handle->mcast.cli, buf, size, NULL,
  860. NULL);
  861. if (bytes == -PAL_ERROR_TRYAGAIN)
  862. HANDLE_HDR(handle)->flags &= ~WRITEABLE(1);
  863. return bytes;
  864. }
  865. static int mcast_close (PAL_HANDLE handle)
  866. {
  867. if (handle->mcast.srv != PAL_IDX_POISON) {
  868. ocall_close(handle->mcast.srv);
  869. handle->mcast.srv = PAL_IDX_POISON;
  870. }
  871. if (handle->mcast.cli != PAL_IDX_POISON) {
  872. ocall_close(handle->mcast.cli);
  873. handle->mcast.cli = PAL_IDX_POISON;
  874. }
  875. return 0;
  876. }
  877. static int mcast_attrquerybyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
  878. {
  879. if (handle->mcast.cli == PAL_IDX_POISON)
  880. return -PAL_ERROR_BADHANDLE;
  881. int ret = ocall_fionread(handle->mcast.cli);
  882. if (ret < 0)
  883. return ret;
  884. memset(attr, 0, sizeof(PAL_STREAM_ATTR));
  885. attr->pending_size = ret;
  886. attr->disconnected = HANDLE_HDR(handle)->flags & (ERROR(0)|ERROR(1));
  887. attr->readable = (attr->pending_size > 0);
  888. attr->writeable = HANDLE_HDR(handle)->flags & WRITEABLE(1);
  889. attr->nonblocking = handle->mcast.nonblocking;
  890. return 0;
  891. }
  892. static int mcast_attrsetbyhdl (PAL_HANDLE handle, PAL_STREAM_ATTR * attr)
  893. {
  894. if (handle->mcast.cli == PAL_IDX_POISON)
  895. return -PAL_ERROR_BADHANDLE;
  896. PAL_BOL * nonblocking = &handle->mcast.nonblocking;
  897. if (attr->nonblocking != *nonblocking) {
  898. int ret = ocall_fsetnonblock(handle->mcast.cli, *nonblocking);
  899. if (ret < 0)
  900. return ret;
  901. *nonblocking = attr->nonblocking;
  902. }
  903. return 0;
  904. }
  905. struct handle_ops mcast_ops = {
  906. .write = &mcast_send,
  907. .read = &mcast_receive,
  908. .close = &mcast_close,
  909. .attrquerybyhdl = &mcast_attrquerybyhdl,
  910. .attrsetbyhdl = &mcast_attrsetbyhdl,
  911. };