shim_socket.c 48 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763
  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. * shim_socket.c
  17. *
  18. * Implementation of system call "socket", "bind", "accept4", "listen",
  19. * "connect", "sendto", "recvfrom", "sendmsg", "recvmsg" and "shutdown" and
  20. * "getsockname", "getpeername".
  21. */
  22. #include <shim_internal.h>
  23. #include <shim_table.h>
  24. #include <shim_handle.h>
  25. #include <shim_fs.h>
  26. #include <shim_utils.h>
  27. #include <shim_checkpoint.h>
  28. #include <pal.h>
  29. #include <pal_error.h>
  30. #include <errno.h>
  31. #include <linux/fcntl.h>
  32. #include <linux/in.h>
  33. #include <linux/in6.h>
  34. #include <asm/socket.h>
  35. /*
  36. * User-settable options (used with setsockopt).
  37. */
  38. #define TCP_NODELAY 1 /* Don't delay send to coalesce packets */
  39. #define TCP_MAXSEG 2 /* Set maximum segment size */
  40. #define TCP_CORK 3 /* Control sending of partial frames */
  41. #define TCP_KEEPIDLE 4 /* Start keeplives after this period */
  42. #define TCP_KEEPINTVL 5 /* Interval between keepalives */
  43. #define TCP_KEEPCNT 6 /* Number of keepalives before death */
  44. #define TCP_SYNCNT 7 /* Number of SYN retransmits */
  45. #define TCP_LINGER2 8 /* Life time of orphaned FIN-WAIT-2 state */
  46. #define TCP_DEFER_ACCEPT 9 /* Wake up listener only when data arrive */
  47. #define TCP_WINDOW_CLAMP 10 /* Bound advertised window */
  48. #define TCP_INFO 11 /* Information about this connection. */
  49. #define TCP_QUICKACK 12 /* Bock/reenable quick ACKs. */
  50. #define TCP_CONGESTION 13 /* Congestion control algorithm. */
  51. #define TCP_MD5SIG 14 /* TCP MD5 Signature (RFC2385) */
  52. #define AF_UNSPEC 0
  53. #define SOCK_URI_SIZE 108
  54. static int rebase_on_lo __attribute_migratable = -1;
  55. static int init_port_rebase (void)
  56. {
  57. if (rebase_on_lo != -1)
  58. return 0;
  59. char cfg[CONFIG_MAX];
  60. int rebase = 0;
  61. if (!root_config ||
  62. get_config(root_config, "net.port.rebase_on_lo", cfg, CONFIG_MAX) <= 0) {
  63. rebase_on_lo = 0;
  64. return 0;
  65. }
  66. for (const char * p = cfg ; *p ; p++) {
  67. if (*p < '0' || *p > '9' || rebase > 32767) {
  68. rebase_on_lo = 0;
  69. return 0;
  70. }
  71. rebase = rebase * 10 + (*p - '0');
  72. }
  73. rebase_on_lo = rebase;
  74. return 0;
  75. }
  76. static int __process_pending_options (struct shim_handle * hdl);
  77. int shim_do_socket (int family, int type, int protocol)
  78. {
  79. struct shim_handle * hdl = get_new_handle();
  80. if (!hdl)
  81. return -ENOMEM;
  82. struct shim_sock_handle * sock = &hdl->info.sock;
  83. hdl->type = TYPE_SOCK;
  84. set_handle_fs(hdl, &socket_builtin_fs);
  85. hdl->flags = type & SOCK_NONBLOCK ? O_NONBLOCK : 0;
  86. hdl->acc_mode = 0;
  87. sock->domain = family;
  88. sock->sock_type = type & ~(SOCK_NONBLOCK|SOCK_CLOEXEC);
  89. sock->protocol = protocol;
  90. int ret = -ENOSYS;
  91. switch (sock->domain) {
  92. case AF_UNIX: //Local communication
  93. case AF_INET: //IPv4 Internet protocols ip(7)
  94. case AF_INET6: //IPv6 Internet protocols
  95. break;
  96. default:
  97. debug("shim_socket: unknown socket domain %d\n",
  98. sock->domain);
  99. goto err;
  100. }
  101. switch (sock->sock_type) {
  102. case SOCK_STREAM: //TCP
  103. break;
  104. case SOCK_DGRAM: //UDP
  105. hdl->acc_mode = MAY_READ|MAY_WRITE;
  106. break;
  107. default:
  108. debug("shim_socket: unknown socket type %d\n",
  109. sock->sock_type);
  110. goto err;
  111. }
  112. sock->sock_state = SOCK_CREATED;
  113. ret = set_new_fd_handle(hdl, type & SOCK_CLOEXEC ? FD_CLOEXEC : 0, NULL);
  114. err:
  115. put_handle(hdl);
  116. return ret;
  117. }
  118. static int unix_create_uri (char * uri, int count, enum shim_sock_state state,
  119. unsigned int pipeid)
  120. {
  121. int bytes = 0;
  122. switch (state) {
  123. case SOCK_CREATED:
  124. case SOCK_BOUNDCONNECTED:
  125. case SOCK_SHUTDOWN:
  126. return -ENOTCONN;
  127. case SOCK_BOUND:
  128. case SOCK_LISTENED:
  129. case SOCK_ACCEPTED:
  130. bytes = snprintf(uri, count, "pipe.srv:%u", pipeid);
  131. break;
  132. case SOCK_CONNECTED:
  133. bytes = snprintf(uri, count, "pipe:%u", pipeid);
  134. break;
  135. default:
  136. return -ENOTCONN;
  137. }
  138. return bytes == count ? -ENAMETOOLONG : bytes;
  139. }
  140. static void inet_rebase_port (bool reverse, int domain, struct addr_inet * addr,
  141. bool local)
  142. {
  143. init_port_rebase();
  144. if (rebase_on_lo) {
  145. if (domain == AF_INET) {
  146. unsigned char * ad = (unsigned char *) &addr->addr.v4.s_addr;
  147. if (!local && memcmp(ad, "\177\0\0\1", 4))
  148. return;
  149. }
  150. if (domain == AF_INET6) {
  151. unsigned short * ad = (void *) &addr->addr.v6.s6_addr;
  152. if (!local && memcmp(ad, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1", 16))
  153. return;
  154. }
  155. }
  156. if (reverse)
  157. addr->port = addr->ext_port - rebase_on_lo;
  158. else
  159. addr->ext_port = addr->port + rebase_on_lo;
  160. }
  161. static int inet_translate_addr (int domain, char * uri, int count,
  162. struct addr_inet * addr)
  163. {
  164. if (domain == AF_INET) {
  165. unsigned char * ad = (unsigned char *) &addr->addr.v4.s_addr;
  166. int bytes = snprintf(uri, count, "%u.%u.%u.%u:%u",
  167. ad[0], ad[1], ad[2], ad[3],
  168. addr->ext_port);
  169. return bytes == count ? -ENAMETOOLONG : bytes;
  170. }
  171. if (domain == AF_INET6) {
  172. unsigned short * ad = (void *) &addr->addr.v6.s6_addr;
  173. int bytes = snprintf(uri, count,
  174. "[%04x:%04x:%x:%04x:%04x:%04x:%04x:%04x]:%u",
  175. __ntohs(ad[0]), __ntohs(ad[1]),
  176. __ntohs(ad[2]), __ntohs(ad[3]),
  177. __ntohs(ad[4]), __ntohs(ad[5]),
  178. __ntohs(ad[6]), __ntohs(ad[7]),
  179. addr->ext_port);
  180. return bytes == count ? -ENAMETOOLONG : bytes;
  181. }
  182. return -EPROTONOSUPPORT;
  183. }
  184. static int inet_create_uri (int domain, char * uri, int count, int sock_type,
  185. enum shim_sock_state state,
  186. struct addr_inet * bind, struct addr_inet * conn)
  187. {
  188. int bytes = 0, ret;
  189. if (sock_type == SOCK_STREAM) {
  190. switch (state) {
  191. case SOCK_CREATED:
  192. case SOCK_SHUTDOWN:
  193. return -ENOTCONN;
  194. case SOCK_BOUND:
  195. case SOCK_LISTENED:
  196. if (count < 9)
  197. return -ENAMETOOLONG;
  198. memcpy(uri, "tcp.srv:", 9);
  199. ret = inet_translate_addr(domain, uri + 8, count - 8, bind);
  200. return ret < 0 ? ret : ret + 8;
  201. case SOCK_BOUNDCONNECTED:
  202. if (count < 5)
  203. return -ENAMETOOLONG;
  204. memcpy(uri, "tcp:", 5);
  205. bytes = 4;
  206. ret = inet_translate_addr(domain, uri + bytes, count - bytes,
  207. bind);
  208. if (ret < 0)
  209. return ret;
  210. uri[bytes + ret] = ':';
  211. bytes += ret + 1;
  212. ret = inet_translate_addr(domain, uri + bytes, count - bytes,
  213. conn);
  214. return ret < 0 ? ret : ret + bytes;
  215. case SOCK_CONNECTED:
  216. case SOCK_ACCEPTED:
  217. if (count < 5)
  218. return -ENAMETOOLONG;
  219. memcpy(uri, "tcp:", 5);
  220. ret = inet_translate_addr(domain, uri + 4, count - 4, conn);
  221. return ret < 0 ? ret : ret + 4;
  222. }
  223. }
  224. if (sock_type == SOCK_DGRAM) {
  225. switch (state) {
  226. case SOCK_CREATED:
  227. case SOCK_SHUTDOWN:
  228. return -ENOTCONN;
  229. case SOCK_LISTENED:
  230. case SOCK_ACCEPTED:
  231. return -EOPNOTSUPP;
  232. case SOCK_BOUNDCONNECTED:
  233. if (count < 9)
  234. return -ENAMETOOLONG;
  235. memcpy(uri, "tcp.srv:", 9);
  236. bytes = 8;
  237. ret = inet_translate_addr(domain, uri + bytes, count - bytes,
  238. bind);
  239. if (ret < 0)
  240. return ret;
  241. uri[bytes + ret] = ':';
  242. bytes += ret + 1;
  243. ret = inet_translate_addr(domain, uri + bytes, count - bytes,
  244. conn);
  245. return ret < 0 ? ret : ret + bytes;
  246. case SOCK_BOUND:
  247. if (count < 9)
  248. return -ENAMETOOLONG;
  249. memcpy(uri, "udp.srv:", 9);
  250. ret = inet_translate_addr(domain, uri + 8, count - 8, bind);
  251. return ret < 0 ? ret : ret + 9;
  252. case SOCK_CONNECTED:
  253. if (count < 5)
  254. return -ENAMETOOLONG;
  255. memcpy(uri, "udp:", 5);
  256. ret = inet_translate_addr(domain, uri + 4, count - 4, conn);
  257. return ret < 0 ? ret : ret + 4;
  258. }
  259. }
  260. return -EPROTONOSUPPORT;
  261. }
  262. static inline void unix_copy_addr (struct sockaddr * saddr,
  263. struct shim_dentry * dent)
  264. {
  265. struct sockaddr_un * un = (struct sockaddr_un *) saddr;
  266. un->sun_family = AF_UNIX;
  267. int size;
  268. const char * path = dentry_get_path(dent, true, &size);
  269. memcpy(un->sun_path, path, size + 1);
  270. }
  271. static bool inet_check_addr (int domain, struct sockaddr * addr, int addrlen)
  272. {
  273. if (domain == AF_INET) {
  274. if (addr->sa_family != AF_INET ||
  275. addrlen != sizeof(struct sockaddr_in))
  276. return false;
  277. return true;
  278. }
  279. if (domain == AF_INET6) {
  280. if (addr->sa_family != AF_INET && addr->sa_family != AF_INET6)
  281. return false;
  282. if (addrlen != ((addr->sa_family == AF_INET) ?
  283. sizeof(struct sockaddr_in) :
  284. sizeof(struct sockaddr_in6)))
  285. return false;
  286. return true;
  287. }
  288. return false;
  289. }
  290. static int inet_copy_addr (int domain, struct sockaddr * saddr,
  291. const struct addr_inet * addr)
  292. {
  293. if (domain == AF_INET) {
  294. struct sockaddr_in * in = (struct sockaddr_in *) saddr;
  295. in->sin_family = AF_INET;
  296. in->sin_port = __htons(addr->port);
  297. in->sin_addr = addr->addr.v4;
  298. return sizeof(struct sockaddr_in);
  299. }
  300. if (domain == AF_INET6) {
  301. struct sockaddr_in6 * in6 = (struct sockaddr_in6 *) saddr;
  302. in6->sin6_family = AF_INET6;
  303. in6->sin6_port = __htons(addr->port);
  304. in6->sin6_addr = addr->addr.v6;
  305. return sizeof(struct sockaddr_in6);
  306. }
  307. return sizeof(struct sockaddr);
  308. }
  309. static void inet_save_addr (int domain, struct addr_inet * addr,
  310. const struct sockaddr * saddr)
  311. {
  312. if (domain == AF_INET) {
  313. const struct sockaddr_in * in = (const struct sockaddr_in *) saddr;
  314. addr->port = __ntohs(in->sin_port);
  315. addr->addr.v4 = in->sin_addr;
  316. return;
  317. }
  318. if (domain == AF_INET6) {
  319. if (saddr->sa_family == AF_INET) {
  320. const struct sockaddr_in * in = (const struct sockaddr_in *) saddr;
  321. addr->port = __ntohs(in->sin_port);
  322. ((uint32_t *) &addr->addr.v6.s6_addr)[0] = 0;
  323. ((uint32_t *) &addr->addr.v6.s6_addr)[1] = 0;
  324. ((uint32_t *) &addr->addr.v6.s6_addr)[2] = 0xffff0000;
  325. ((uint32_t *) &addr->addr.v6.s6_addr)[3] = in->sin_addr.s_addr;
  326. } else {
  327. const struct sockaddr_in6 * in6 = (const struct sockaddr_in6 *) saddr;
  328. addr->port = __ntohs(in6->sin6_port);
  329. addr->addr.v6 = in6->sin6_addr;
  330. }
  331. return;
  332. }
  333. }
  334. static inline bool inet_comp_addr (int domain, const struct addr_inet * addr,
  335. const struct sockaddr * saddr)
  336. {
  337. if (domain == AF_INET) {
  338. const struct sockaddr_in * in = (const struct sockaddr_in *) saddr;
  339. return addr->port == __ntohs(in->sin_port) &&
  340. !memcmp(&addr->addr.v4, &in->sin_addr,
  341. sizeof(struct in_addr));
  342. }
  343. if (domain == AF_INET6) {
  344. const struct sockaddr_in6 * in6 = (const struct sockaddr_in6 *) saddr;
  345. return addr->port == __ntohs(in6->sin6_port) &&
  346. !memcmp(&addr->addr.v6, &in6->sin6_addr,
  347. sizeof(struct in6_addr));
  348. }
  349. return false;
  350. }
  351. static int create_socket_uri (struct shim_handle * hdl)
  352. {
  353. struct shim_sock_handle * sock = &hdl->info.sock;
  354. if (sock->domain == AF_UNIX) {
  355. char uri_buf[32];
  356. int bytes = unix_create_uri(uri_buf, 32, sock->sock_state,
  357. sock->addr.un.pipeid);
  358. if (bytes < 0)
  359. return bytes;
  360. qstrsetstr(&hdl->uri, uri_buf, bytes);
  361. return 0;
  362. }
  363. if (sock->domain == AF_INET || sock->domain == AF_INET6) {
  364. char uri_buf[SOCK_URI_SIZE];
  365. int bytes = inet_create_uri(sock->domain, uri_buf, SOCK_URI_SIZE,
  366. sock->sock_type, sock->sock_state,
  367. &sock->addr.in.bind, &sock->addr.in.conn);
  368. if (bytes < 0)
  369. return bytes;
  370. qstrsetstr(&hdl->uri, uri_buf, bytes);
  371. return 0;
  372. }
  373. return -EPROTONOSUPPORT;
  374. }
  375. int shim_do_bind (int sockfd, struct sockaddr * addr, socklen_t addrlen)
  376. {
  377. struct shim_handle * hdl = get_fd_handle(sockfd, NULL, NULL);
  378. int ret = -EINVAL;
  379. if (!hdl)
  380. return -EBADF;
  381. if (hdl->type != TYPE_SOCK) {
  382. put_handle(hdl);
  383. return -ENOTSOCK;
  384. }
  385. struct shim_sock_handle * sock = &hdl->info.sock;
  386. lock(hdl->lock);
  387. enum shim_sock_state state = sock->sock_state;
  388. if (state != SOCK_CREATED) {
  389. debug("shim_bind: bind on a bound socket\n");
  390. goto out;
  391. }
  392. if (sock->domain == AF_UNIX) {
  393. if (addrlen != sizeof(struct sockaddr_un))
  394. goto out;
  395. struct sockaddr_un * saddr = (struct sockaddr_un *) addr;
  396. char * spath = saddr->sun_path;
  397. struct shim_dentry * dent = NULL;
  398. if ((ret = path_lookupat(NULL, spath, LOOKUP_CREATE, &dent, NULL)) < 0) {
  399. // DEP 7/3/17: We actually want either 0 or -ENOENT, as the
  400. // expected case is that the name is free (and we get the dent to
  401. // populate the name)
  402. if (ret != -ENOENT || !dent)
  403. goto out;
  404. }
  405. if (dent->state & DENTRY_VALID &&
  406. !(dent->state & DENTRY_NEGATIVE)) {
  407. ret = -EADDRINUSE;
  408. goto out;
  409. }
  410. struct shim_unix_data * data = malloc(sizeof(struct shim_unix_data));
  411. data->pipeid = dent->rel_path.hash >> 32;
  412. sock->addr.un.pipeid = data->pipeid;
  413. sock->addr.un.data = data;
  414. sock->addr.un.dentry = dent;
  415. } else if (sock->domain == AF_INET || sock->domain == AF_INET6) {
  416. if (!inet_check_addr(sock->domain, addr, addrlen))
  417. goto out;
  418. inet_save_addr(sock->domain, &sock->addr.in.bind, addr);
  419. inet_rebase_port(false, sock->domain, &sock->addr.in.bind, true);
  420. }
  421. sock->sock_state = SOCK_BOUND;
  422. if ((ret = create_socket_uri(hdl)) < 0)
  423. goto out;
  424. PAL_HANDLE pal_hdl = DkStreamOpen(qstrgetstr(&hdl->uri),
  425. 0, 0, 0,
  426. hdl->flags & O_NONBLOCK);
  427. if (!pal_hdl) {
  428. ret = (PAL_NATIVE_ERRNO == PAL_ERROR_STREAMEXIST) ? -EADDRINUSE : -PAL_ERRNO;
  429. debug("bind: invalid handle returned\n");
  430. goto out;
  431. }
  432. if (sock->domain == AF_UNIX) {
  433. struct shim_dentry * dent = sock->addr.un.dentry;
  434. dent->state ^= DENTRY_NEGATIVE;
  435. dent->state |= DENTRY_VALID|DENTRY_RECENTLY;
  436. dent->fs = &socket_builtin_fs;
  437. dent->data = sock->addr.un.data;
  438. }
  439. hdl->pal_handle = pal_hdl;
  440. __process_pending_options(hdl);
  441. ret = 0;
  442. out:
  443. if (ret < 0) {
  444. sock->sock_state = state;
  445. sock->error = -ret;
  446. if (sock->domain == AF_UNIX) {
  447. if (sock->addr.un.dentry)
  448. put_dentry(sock->addr.un.dentry);
  449. if (sock->addr.un.data) {
  450. free(sock->addr.un.data);
  451. sock->addr.un.data = NULL;
  452. }
  453. }
  454. }
  455. unlock(hdl->lock);
  456. put_handle(hdl);
  457. return ret;
  458. }
  459. static int inet_parse_addr (int domain, int type, const char * uri,
  460. struct addr_inet * bind,
  461. struct addr_inet * conn)
  462. {
  463. char * ip_str, * port_str, * next_str;
  464. int ip_len = 0;
  465. if (!(next_str = strchr(uri, ':')))
  466. return -EINVAL;
  467. enum { UDP, UDPSRV, TCP, TCPSRV } prefix;
  468. int n = (next_str++) - uri;
  469. if (!memcmp(uri, "udp", n))
  470. prefix = UDP;
  471. else if (!memcmp(uri, "udp.srv", n))
  472. prefix = UDPSRV;
  473. else if (!memcmp(uri, "tcp", n))
  474. prefix = TCP;
  475. else if (!memcmp(uri, "tcp.srv", n))
  476. prefix = TCPSRV;
  477. else
  478. return -EINVAL;
  479. if ((prefix == UDP || prefix == UDPSRV) && type != SOCK_DGRAM)
  480. return -EINVAL;
  481. if ((prefix == TCP || prefix == TCPSRV) && type != SOCK_STREAM)
  482. return -EINVAL;
  483. for (int round = 0 ; (ip_str = next_str) ; round++) {
  484. if (ip_str[0] == '[') {
  485. ip_str++;
  486. if (domain != AF_INET6)
  487. return -EINVAL;
  488. if (!(port_str = strchr(ip_str, ']')))
  489. return -EINVAL;
  490. ip_len = port_str - ip_str;
  491. port_str++;
  492. if (*port_str != ':')
  493. return -EINVAL;
  494. } else {
  495. if (domain != AF_INET)
  496. return -EINVAL;
  497. if (!(port_str = strchr(ip_str, ':')))
  498. return -EINVAL;
  499. ip_len = port_str - ip_str;
  500. }
  501. port_str++;
  502. next_str = strchr(port_str, ':');
  503. if (next_str)
  504. next_str++;
  505. struct addr_inet * addr = round ? conn : bind;
  506. if (domain == AF_INET) {
  507. inet_pton4(ip_str, ip_len, &addr->addr.v4);
  508. addr->ext_port = atoi(port_str);
  509. }
  510. if (domain == AF_INET6) {
  511. inet_pton6(ip_str, ip_len, &addr->addr.v6);
  512. addr->ext_port = atoi(port_str);
  513. }
  514. }
  515. return 0;
  516. }
  517. struct un_conn {
  518. unsigned int pipeid;
  519. unsigned char path_size;
  520. char path[];
  521. } __attribute__((packed));
  522. int shim_do_listen (int sockfd, int backlog)
  523. {
  524. if (backlog < 0)
  525. return -EINVAL;
  526. struct shim_handle * hdl = get_fd_handle(sockfd, NULL, NULL);
  527. if (!hdl)
  528. return -EBADF;
  529. if (hdl->type != TYPE_SOCK) {
  530. put_handle(hdl);
  531. return -ENOTSOCK;
  532. }
  533. struct shim_sock_handle * sock = &hdl->info.sock;
  534. if (sock->sock_type != SOCK_STREAM) {
  535. debug("shim_listen: not a stream socket\n");
  536. put_handle(hdl);
  537. return -EINVAL;
  538. }
  539. lock(hdl->lock);
  540. enum shim_sock_state state = sock->sock_state;
  541. int ret = -EINVAL;
  542. if (state != SOCK_BOUND) {
  543. debug("shim_listen: listen on unbound socket\n");
  544. goto out;
  545. }
  546. hdl->acc_mode = MAY_READ;
  547. sock->sock_state = SOCK_LISTENED;
  548. ret = 0;
  549. out:
  550. if (ret < 0)
  551. sock->sock_state = state;
  552. unlock(hdl->lock);
  553. put_handle(hdl);
  554. return ret;
  555. }
  556. /* Connect with the TCP socket is always in the client.
  557. *
  558. * With UDP, the connection is make to the socket specific for a
  559. * destination. A process with a connected UDP socket can call
  560. * connect again for that socket for one of two reasons: 1. To
  561. * specify a new IP address and port 2. To unconnect the socket.
  562. */
  563. int shim_do_connect (int sockfd, struct sockaddr * addr, int addrlen)
  564. {
  565. struct shim_handle * hdl = get_fd_handle(sockfd, NULL, NULL);
  566. if (!hdl)
  567. return -EBADF;
  568. if (hdl->type != TYPE_SOCK) {
  569. put_handle(hdl);
  570. return -ENOTSOCK;
  571. }
  572. struct shim_sock_handle * sock = &hdl->info.sock;
  573. lock(hdl->lock);
  574. enum shim_sock_state state = sock->sock_state;
  575. int ret = -EINVAL;
  576. if (state == SOCK_CONNECTED) {
  577. if (addr->sa_family == AF_UNSPEC) {
  578. sock->sock_state = SOCK_CREATED;
  579. if (sock->sock_type == SOCK_STREAM && hdl->pal_handle) {
  580. DkStreamDelete(hdl->pal_handle, 0);
  581. DkObjectClose(hdl->pal_handle);
  582. hdl->pal_handle = NULL;
  583. }
  584. debug("shim_connect: reconnect on a stream socket\n");
  585. ret = 0;
  586. goto out;
  587. }
  588. debug("shim_connect: reconnect on a stream socket\n");
  589. goto out;
  590. }
  591. if (state != SOCK_BOUND &&
  592. state != SOCK_CREATED) {
  593. debug("shim_connect: connect on invalid socket\n");
  594. goto out;
  595. }
  596. if (sock->domain == AF_UNIX) {
  597. if (addrlen != sizeof(struct sockaddr_un))
  598. goto out;
  599. struct sockaddr_un * saddr = (struct sockaddr_un *) addr;
  600. char * spath = saddr->sun_path;
  601. struct shim_dentry * dent;
  602. if ((ret = path_lookupat(NULL, spath, LOOKUP_CREATE, &dent, NULL)) < 0)
  603. goto out;
  604. struct shim_unix_data * data = dent->data;
  605. if (!(dent->state & DENTRY_VALID) || dent->state & DENTRY_NEGATIVE) {
  606. data = malloc(sizeof(struct shim_unix_data));
  607. data->pipeid = dent->rel_path.hash >> 32;
  608. } else if (dent->fs != &socket_builtin_fs) {
  609. ret = -ECONNREFUSED;
  610. goto out;
  611. }
  612. sock->addr.un.pipeid = data->pipeid;
  613. sock->addr.un.data = data;
  614. sock->addr.un.dentry = dent;
  615. get_dentry(dent);
  616. }
  617. if (state == SOCK_BOUND) {
  618. /* if the socket is bound, the stream needs to be shut and rebound. */
  619. assert(hdl->pal_handle);
  620. DkStreamDelete(hdl->pal_handle, 0);
  621. DkObjectClose(hdl->pal_handle);
  622. hdl->pal_handle = NULL;
  623. }
  624. if (sock->domain != AF_UNIX) {
  625. if (!inet_check_addr(sock->domain, addr, addrlen))
  626. goto out;
  627. inet_save_addr(sock->domain, &sock->addr.in.conn, addr);
  628. inet_rebase_port(false, sock->domain, &sock->addr.in.conn, false);
  629. }
  630. sock->sock_state = (state == SOCK_BOUND) ? SOCK_BOUNDCONNECTED :
  631. SOCK_CONNECTED;
  632. if ((ret = create_socket_uri(hdl)) < 0)
  633. goto out;
  634. PAL_HANDLE pal_hdl = DkStreamOpen(qstrgetstr(&hdl->uri),
  635. 0, 0, 0,
  636. hdl->flags & O_NONBLOCK);
  637. if (!pal_hdl) {
  638. ret = -PAL_ERRNO;
  639. goto out;
  640. }
  641. hdl->pal_handle = pal_hdl;
  642. if (sock->domain == AF_UNIX) {
  643. struct shim_dentry * dent = sock->addr.un.dentry;
  644. lock(dent->lock);
  645. dent->state ^= DENTRY_NEGATIVE;
  646. dent->state |= DENTRY_VALID|DENTRY_RECENTLY;
  647. dent->fs = &socket_builtin_fs;
  648. dent->data = sock->addr.un.data;
  649. unlock(dent->lock);
  650. }
  651. if (sock->domain == AF_INET || sock->domain == AF_INET6) {
  652. char uri[SOCK_URI_SIZE];
  653. if (!DkStreamGetName(pal_hdl, uri, SOCK_URI_SIZE)) {
  654. ret = -PAL_ERRNO;
  655. goto out;
  656. }
  657. if ((ret = inet_parse_addr(sock->domain, sock->sock_type, uri,
  658. &sock->addr.in.bind,
  659. &sock->addr.in.conn)) < 0)
  660. goto out;
  661. inet_rebase_port(true, sock->domain, &sock->addr.in.bind, true);
  662. inet_rebase_port(true, sock->domain, &sock->addr.in.conn, false);
  663. }
  664. hdl->acc_mode = MAY_READ|MAY_WRITE;
  665. __process_pending_options(hdl);
  666. ret = 0;
  667. out:
  668. if (ret < 0) {
  669. sock->sock_state = state;
  670. sock->error = -ret;
  671. if (sock->domain == AF_UNIX) {
  672. if (sock->addr.un.dentry)
  673. put_dentry(sock->addr.un.dentry);
  674. if (sock->addr.un.data) {
  675. free(sock->addr.un.data);
  676. sock->addr.un.data = NULL;
  677. }
  678. }
  679. }
  680. unlock(hdl->lock);
  681. put_handle(hdl);
  682. return ret;
  683. }
  684. int __do_accept (struct shim_handle * hdl, int flags, struct sockaddr * addr,
  685. socklen_t * addrlen)
  686. {
  687. if (hdl->type != TYPE_SOCK)
  688. return -ENOTSOCK;
  689. struct shim_sock_handle * sock = &hdl->info.sock;
  690. int ret;
  691. PAL_HANDLE accepted = NULL;
  692. if (sock->sock_type != SOCK_STREAM) {
  693. debug("shim_accept: not a stream socket\n");
  694. return -EOPNOTSUPP;
  695. }
  696. lock(hdl->lock);
  697. if (sock->sock_state != SOCK_LISTENED) {
  698. debug("shim_accpet: invalid socket\n");
  699. ret = -EINVAL;
  700. goto out;
  701. }
  702. accepted = DkStreamWaitForClient(hdl->pal_handle);
  703. if (!accepted) {
  704. ret = -PAL_ERRNO;
  705. goto out;
  706. }
  707. if (flags & O_NONBLOCK) {
  708. PAL_STREAM_ATTR attr;
  709. if (!DkStreamAttributesQuerybyHandle(accepted, &attr)) {
  710. ret = -PAL_ERRNO;
  711. goto out;
  712. }
  713. attr.nonblocking = PAL_TRUE;
  714. if (!DkStreamAttributesSetbyHandle(accepted, &attr)) {
  715. ret = -PAL_ERRNO;
  716. goto out;
  717. }
  718. }
  719. struct shim_handle * cli = get_new_handle();
  720. if (!cli) {
  721. ret = -ENOMEM;
  722. goto out;
  723. }
  724. struct shim_sock_handle * cli_sock = &cli->info.sock;
  725. cli->type = TYPE_SOCK;
  726. set_handle_fs(cli, &socket_builtin_fs);
  727. cli->acc_mode = MAY_READ|MAY_WRITE;
  728. cli->flags = O_RDWR|flags;
  729. cli->pal_handle = accepted;
  730. accepted = NULL;
  731. cli_sock->domain = sock->domain;
  732. cli_sock->sock_type = sock->sock_type;
  733. cli_sock->protocol = sock->protocol;
  734. cli_sock->sock_state = SOCK_ACCEPTED;
  735. if (sock->domain == AF_UNIX) {
  736. cli_sock->addr.un.pipeid = sock->addr.un.pipeid;
  737. if (sock->addr.un.dentry) {
  738. get_dentry(sock->addr.un.dentry);
  739. cli_sock->addr.un.dentry = sock->addr.un.dentry;
  740. }
  741. qstrsetstr(&cli->uri, qstrgetstr(&hdl->uri), hdl->uri.len);
  742. if (addr) {
  743. unix_copy_addr(addr, sock->addr.un.dentry);
  744. if (addrlen)
  745. *addrlen = sizeof(struct sockaddr_un);
  746. }
  747. }
  748. if (sock->domain == AF_INET || sock->domain == AF_INET6) {
  749. char uri[SOCK_URI_SIZE];
  750. int uri_len;
  751. if (!(uri_len = DkStreamGetName(cli->pal_handle, uri, SOCK_URI_SIZE))) {
  752. ret = -PAL_ERRNO;
  753. goto out_cli;
  754. }
  755. if ((ret = inet_parse_addr(cli_sock->domain, cli_sock->sock_type, uri,
  756. &cli_sock->addr.in.bind,
  757. &cli_sock->addr.in.conn)) < 0)
  758. goto out_cli;
  759. qstrsetstr(&cli->uri, uri, uri_len);
  760. inet_rebase_port(true, cli_sock->domain, &cli_sock->addr.in.bind, true);
  761. inet_rebase_port(true, cli_sock->domain, &cli_sock->addr.in.conn, false);
  762. if (addr) {
  763. inet_copy_addr(sock->domain, addr, &sock->addr.in.conn);
  764. if (addrlen)
  765. *addrlen = (sock->domain == AF_INET) ?
  766. sizeof(struct sockaddr_in) :
  767. sizeof(struct sockaddr_in6);
  768. }
  769. }
  770. ret = set_new_fd_handle(cli, flags & O_CLOEXEC ? FD_CLOEXEC : 0, NULL);
  771. out_cli:
  772. put_handle(cli);
  773. out:
  774. if (ret < 0)
  775. sock->error = -ret;
  776. if (accepted)
  777. DkObjectClose(accepted);
  778. unlock(hdl->lock);
  779. return ret;
  780. }
  781. int shim_do_accept (int fd, struct sockaddr * addr, socklen_t * addrlen)
  782. {
  783. int flags;
  784. struct shim_handle * hdl = get_fd_handle(fd, &flags, NULL);
  785. if (!hdl)
  786. return -EBADF;
  787. int ret = __do_accept(hdl, flags & O_CLOEXEC,
  788. addr, addrlen);
  789. put_handle(hdl);
  790. return ret;
  791. }
  792. int shim_do_accept4 (int fd, struct sockaddr * addr, socklen_t * addrlen,
  793. int flags)
  794. {
  795. struct shim_handle * hdl = get_fd_handle(fd, NULL, NULL);
  796. if (!hdl)
  797. return -EBADF;
  798. int ret = __do_accept(hdl,
  799. (flags & SOCK_CLOEXEC ? O_CLOEXEC : 0) |
  800. (flags & SOCK_NONBLOCK ? O_NONBLOCK : 0),
  801. addr, addrlen);
  802. put_handle(hdl);
  803. return ret;
  804. }
  805. static ssize_t do_sendmsg (int fd, struct iovec * bufs, int nbufs, int flags,
  806. const struct sockaddr * addr, socklen_t addrlen)
  807. {
  808. struct shim_handle * hdl = get_fd_handle(fd, NULL, NULL);
  809. if (!hdl)
  810. return -EBADF;
  811. int ret = -EINVAL;
  812. if (hdl->type != TYPE_SOCK) {
  813. ret = -ENOTSOCK;
  814. goto out;
  815. }
  816. struct shim_sock_handle * sock = &hdl->info.sock;
  817. lock(hdl->lock);
  818. PAL_HANDLE pal_hdl = hdl->pal_handle;
  819. char * uri = NULL;
  820. /* Data gram sock need not be conneted or bound at all */
  821. if (sock->sock_type == SOCK_STREAM &&
  822. sock->sock_state != SOCK_CONNECTED &&
  823. sock->sock_state != SOCK_BOUNDCONNECTED &&
  824. sock->sock_state != SOCK_ACCEPTED) {
  825. ret = -ENOTCONN;
  826. goto out_locked;
  827. }
  828. if (sock->sock_type == SOCK_DGRAM &&
  829. sock->sock_state == SOCK_SHUTDOWN) {
  830. ret = -ENOTCONN;
  831. goto out_locked;
  832. }
  833. if (!(hdl->acc_mode & MAY_WRITE)) {
  834. ret = -ECONNRESET;
  835. goto out_locked;
  836. }
  837. if (sock->sock_type == SOCK_DGRAM &&
  838. sock->sock_state != SOCK_BOUNDCONNECTED &&
  839. sock->sock_state != SOCK_CONNECTED) {
  840. if (!addr) {
  841. ret = -EDESTADDRREQ;
  842. goto out_locked;
  843. }
  844. if (sock->sock_state == SOCK_CREATED && !pal_hdl) {
  845. pal_hdl = DkStreamOpen("udp:", 0, 0, 0,
  846. hdl->flags & O_NONBLOCK);
  847. if (!pal_hdl) {
  848. ret = -PAL_ERRNO;
  849. goto out_locked;
  850. }
  851. hdl->pal_handle = pal_hdl;
  852. }
  853. if (addr && addr->sa_family != sock->domain) {
  854. ret = -EINVAL;
  855. goto out_locked;
  856. }
  857. uri = __alloca(SOCK_URI_SIZE);
  858. }
  859. unlock(hdl->lock);
  860. if (uri) {
  861. struct addr_inet addr_buf;
  862. inet_save_addr(sock->domain, &addr_buf, addr);
  863. inet_rebase_port(false, sock->domain, &addr_buf, false);
  864. memcpy(uri, "udp:", 5);
  865. if ((ret = inet_translate_addr(sock->domain, uri + 4, SOCK_URI_SIZE - 4,
  866. &addr_buf)) < 0) {
  867. lock(hdl->lock);
  868. goto out_locked;
  869. }
  870. debug("next packet send to %s\n", uri);
  871. }
  872. int bytes = 0;
  873. ret = 0;
  874. for (int i = 0 ; i < nbufs ; i++) {
  875. ret = DkStreamWrite(pal_hdl, 0, bufs[i].iov_len, bufs[i].iov_base,
  876. uri);
  877. if (!ret) {
  878. ret = (PAL_NATIVE_ERRNO == PAL_ERROR_STREAMEXIST) ?
  879. - ECONNABORTED : -PAL_ERRNO;
  880. break;
  881. }
  882. bytes += ret;
  883. }
  884. if (bytes)
  885. ret = bytes;
  886. if (ret < 0) {
  887. lock(hdl->lock);
  888. goto out_locked;
  889. }
  890. goto out;
  891. out_locked:
  892. if (ret < 0)
  893. sock->error = -ret;
  894. unlock(hdl->lock);
  895. out:
  896. put_handle(hdl);
  897. return ret;
  898. }
  899. ssize_t shim_do_sendto (int sockfd, const void * buf, size_t len, int flags,
  900. const struct sockaddr * addr, socklen_t addrlen)
  901. {
  902. struct iovec iovbuf;
  903. iovbuf.iov_base = (void *) buf;
  904. iovbuf.iov_len = len;
  905. return do_sendmsg(sockfd, &iovbuf, 1, flags, addr, addrlen);
  906. }
  907. ssize_t shim_do_sendmsg (int sockfd, struct msghdr * msg, int flags)
  908. {
  909. return do_sendmsg(sockfd, msg->msg_iov, msg->msg_iovlen, flags,
  910. msg->msg_name, msg->msg_namelen);
  911. }
  912. int shim_do_sendmmsg (int sockfd, struct mmsghdr * msg, int vlen, int flags)
  913. {
  914. int i, total = 0;
  915. for (i = 0 ; i * sizeof(struct mmsghdr) < vlen ; i++) {
  916. struct msghdr * m = &msg[i].msg_hdr;
  917. int bytes = do_sendmsg(sockfd, m->msg_iov, m->msg_iovlen, flags,
  918. m->msg_name, m->msg_namelen);
  919. if (bytes < 0)
  920. return total ? : bytes;
  921. msg[i].msg_len = bytes;
  922. total++;
  923. }
  924. return total;
  925. }
  926. static ssize_t do_recvmsg (int fd, struct iovec * bufs, int nbufs, int flags,
  927. struct sockaddr * addr, socklen_t * addrlen)
  928. {
  929. struct shim_handle * hdl = get_fd_handle(fd, NULL, NULL);
  930. if (!hdl)
  931. return -EBADF;
  932. int ret = 0;
  933. if (hdl->type != TYPE_SOCK) {
  934. ret = -ENOTSOCK;
  935. goto out;
  936. }
  937. struct shim_sock_handle * sock = &hdl->info.sock;
  938. lock(hdl->lock);
  939. PAL_HANDLE pal_hdl = hdl->pal_handle;
  940. char * uri = NULL;
  941. if (sock->sock_type == SOCK_STREAM &&
  942. sock->sock_state != SOCK_CONNECTED &&
  943. sock->sock_state != SOCK_BOUNDCONNECTED &&
  944. sock->sock_state != SOCK_ACCEPTED) {
  945. ret = -ENOTCONN;
  946. goto out_locked;
  947. }
  948. if (!(hdl->acc_mode & MAY_READ)) {
  949. ret = 0;
  950. goto out_locked;
  951. }
  952. if (addr && sock->sock_type == SOCK_DGRAM &&
  953. sock->sock_state != SOCK_CONNECTED &&
  954. sock->sock_state != SOCK_BOUNDCONNECTED) {
  955. if (sock->sock_state == SOCK_CREATED) {
  956. ret = -EINVAL;
  957. goto out_locked;
  958. }
  959. uri = __alloca(SOCK_URI_SIZE);
  960. }
  961. unlock(hdl->lock);
  962. bool address_received = false;
  963. int bytes = 0;
  964. ret = 0;
  965. for (int i = 0 ; i < nbufs ; i++) {
  966. ret = DkStreamRead(pal_hdl, 0, bufs[i].iov_len, bufs[i].iov_base,
  967. uri, uri ? SOCK_URI_SIZE : 0);
  968. if (!ret) {
  969. ret = (PAL_NATIVE_ERRNO == PAL_ERROR_STREAMNOTEXIST) ?
  970. - ECONNABORTED : -PAL_ERRNO;
  971. break;
  972. }
  973. bytes += ret;
  974. if (!addr || !bytes || address_received)
  975. continue;
  976. if (sock->domain == AF_UNIX) {
  977. unix_copy_addr(addr, sock->addr.un.dentry);
  978. *addrlen = sizeof(struct sockaddr_un);
  979. }
  980. if (sock->domain == AF_INET || sock->domain == AF_INET6) {
  981. if (uri) {
  982. struct addr_inet conn;
  983. if ((ret = inet_parse_addr(sock->domain, sock->sock_type, uri,
  984. &conn, NULL)) < 0) {
  985. lock(hdl->lock);
  986. goto out_locked;
  987. }
  988. debug("last packet received from %s\n", uri);
  989. inet_rebase_port(true, sock->domain, &conn, false);
  990. inet_copy_addr(sock->domain, addr, &conn);
  991. } else {
  992. inet_copy_addr(sock->domain, addr, &sock->addr.in.conn);
  993. }
  994. *addrlen = (sock->domain == AF_INET) ?
  995. sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
  996. }
  997. address_received = false;
  998. }
  999. if (bytes)
  1000. ret = bytes;
  1001. if (ret < 0) {
  1002. lock(hdl->lock);
  1003. goto out_locked;
  1004. }
  1005. goto out;
  1006. out_locked:
  1007. if (ret < 0)
  1008. sock->error = -ret;
  1009. unlock(hdl->lock);
  1010. out:
  1011. put_handle(hdl);
  1012. return ret;
  1013. }
  1014. ssize_t shim_do_recvfrom (int sockfd, void * buf, size_t len, int flags,
  1015. struct sockaddr * addr, socklen_t * addrlen)
  1016. {
  1017. struct iovec iovbuf;
  1018. iovbuf.iov_base = (void *) buf;
  1019. iovbuf.iov_len = len;
  1020. return do_recvmsg(sockfd, &iovbuf, 1, flags, addr, addrlen);
  1021. }
  1022. ssize_t shim_do_recvmsg (int sockfd, struct msghdr * msg, int flags)
  1023. {
  1024. return do_recvmsg(sockfd, msg->msg_iov, msg->msg_iovlen, flags,
  1025. msg->msg_name, &msg->msg_namelen);
  1026. }
  1027. int shim_do_recvmmsg (int sockfd, struct mmsghdr * msg, int vlen, int flags,
  1028. struct __kernel_timespec * timeout)
  1029. {
  1030. int i, total = 0;
  1031. for (i = 0 ; i * sizeof(struct mmsghdr) < vlen ; i++) {
  1032. struct msghdr * m = &msg[i].msg_hdr;
  1033. int bytes = do_recvmsg(sockfd, m->msg_iov, m->msg_iovlen, flags,
  1034. m->msg_name, &m->msg_namelen);
  1035. if (bytes < 0)
  1036. return total ? : bytes;
  1037. msg[i].msg_len = bytes;
  1038. total++;
  1039. }
  1040. return total;
  1041. }
  1042. #define SHUT_RD 0
  1043. #define SHUT_WR 1
  1044. #define SHUT_RDWR 2
  1045. int shim_do_shutdown (int sockfd, int how)
  1046. {
  1047. struct shim_handle * hdl = get_fd_handle(sockfd, NULL, NULL);
  1048. if (!hdl)
  1049. return -EBADF;
  1050. int ret = 0;
  1051. struct shim_sock_handle * sock = &hdl->info.sock;
  1052. if (hdl->type != TYPE_SOCK) {
  1053. ret = -ENOTSOCK;
  1054. goto out;
  1055. }
  1056. lock(hdl->lock);
  1057. if (sock->sock_state != SOCK_LISTENED &&
  1058. sock->sock_state != SOCK_ACCEPTED &&
  1059. sock->sock_state != SOCK_CONNECTED &&
  1060. sock->sock_state != SOCK_BOUNDCONNECTED) {
  1061. ret = -ENOTCONN;
  1062. goto out_locked;
  1063. }
  1064. switch (how) {
  1065. case SHUT_RD:
  1066. DkStreamDelete(hdl->pal_handle, PAL_DELETE_RD);
  1067. hdl->acc_mode &= ~MAY_READ;
  1068. break;
  1069. case SHUT_WR:
  1070. DkStreamDelete(hdl->pal_handle, PAL_DELETE_WR);
  1071. hdl->acc_mode &= ~MAY_WRITE;
  1072. break;
  1073. case SHUT_RDWR:
  1074. DkStreamDelete(hdl->pal_handle, 0);
  1075. hdl->acc_mode = 0;
  1076. sock->sock_state = SOCK_SHUTDOWN;
  1077. break;
  1078. }
  1079. ret = 0;
  1080. out_locked:
  1081. if (ret < 0)
  1082. sock->error = -ret;
  1083. unlock(hdl->lock);
  1084. out:
  1085. put_handle(hdl);
  1086. return ret;
  1087. }
  1088. int shim_do_getsockname (int sockfd, struct sockaddr * addr, int * addrlen)
  1089. {
  1090. if (!addr || !addrlen)
  1091. return -EFAULT;
  1092. if (*addrlen <= 0)
  1093. return -EINVAL;
  1094. struct shim_handle * hdl = get_fd_handle(sockfd, NULL, NULL);
  1095. if (!hdl)
  1096. return -EBADF;
  1097. int ret = -EINVAL;
  1098. if (hdl->type != TYPE_SOCK) {
  1099. ret = -ENOTSOCK;
  1100. goto out;
  1101. }
  1102. struct shim_sock_handle * sock = &hdl->info.sock;
  1103. lock(hdl->lock);
  1104. struct sockaddr saddr;
  1105. int len = inet_copy_addr(sock->domain, &saddr, &sock->addr.in.bind);
  1106. if (len < *addrlen)
  1107. len = *addrlen;
  1108. memcpy(addr, &saddr, len);
  1109. *addrlen = len;
  1110. ret = 0;
  1111. unlock(hdl->lock);
  1112. out:
  1113. put_handle(hdl);
  1114. return ret;
  1115. }
  1116. int shim_do_getpeername (int sockfd, struct sockaddr * addr, int * addrlen)
  1117. {
  1118. if (!addr || !addrlen)
  1119. return -EFAULT;
  1120. if (*addrlen <= 0)
  1121. return -EINVAL;
  1122. struct shim_handle * hdl = get_fd_handle(sockfd, NULL, NULL);
  1123. if (!hdl)
  1124. return -EBADF;
  1125. int ret = -EINVAL;
  1126. if (hdl->type != TYPE_SOCK) {
  1127. ret = -ENOTSOCK;
  1128. goto out;
  1129. }
  1130. struct shim_sock_handle * sock = &hdl->info.sock;
  1131. lock(hdl->lock);
  1132. /* Data gram sock need not be conneted or bound at all */
  1133. if (sock->sock_type == SOCK_STREAM &&
  1134. sock->sock_state != SOCK_CONNECTED &&
  1135. sock->sock_state != SOCK_BOUNDCONNECTED &&
  1136. sock->sock_state != SOCK_ACCEPTED) {
  1137. ret = -ENOTCONN;
  1138. goto out_locked;
  1139. }
  1140. if (sock->sock_type == SOCK_DGRAM &&
  1141. sock->sock_state != SOCK_CONNECTED &&
  1142. sock->sock_state != SOCK_BOUNDCONNECTED) {
  1143. ret = -ENOTCONN;
  1144. goto out_locked;
  1145. }
  1146. struct sockaddr saddr;
  1147. int len = inet_copy_addr (sock->domain, &saddr, &sock->addr.in.conn);
  1148. if (len < *addrlen)
  1149. len = *addrlen;
  1150. memcpy(addr, &saddr, len);
  1151. *addrlen = len;
  1152. ret = 0;
  1153. out_locked:
  1154. unlock(hdl->lock);
  1155. out:
  1156. put_handle(hdl);
  1157. return ret;
  1158. }
  1159. struct __kernel_linger {
  1160. int l_onoff;
  1161. int l_linger;
  1162. };
  1163. static int __do_setsockopt (struct shim_handle * hdl, int level, int optname,
  1164. char * optval, int optlen, PAL_STREAM_ATTR * attr)
  1165. {
  1166. int intval = *((int *) optval);
  1167. PAL_BOL bolval = intval ? PAL_TRUE : PAL_FALSE;
  1168. if (level == SOL_SOCKET) {
  1169. switch(optname) {
  1170. case SO_ACCEPTCONN:
  1171. case SO_DOMAIN:
  1172. case SO_ERROR:
  1173. case SO_PROTOCOL:
  1174. case SO_TYPE:
  1175. return -EPERM;
  1176. case SO_KEEPALIVE:
  1177. case SO_LINGER:
  1178. case SO_RCVBUF:
  1179. case SO_SNDBUF:
  1180. case SO_RCVTIMEO:
  1181. case SO_SNDTIMEO:
  1182. case SO_REUSEADDR:
  1183. goto query;
  1184. default:
  1185. goto unknown;
  1186. }
  1187. }
  1188. if (level == SOL_TCP) {
  1189. switch(optname) {
  1190. case TCP_CORK:
  1191. case TCP_NODELAY:
  1192. goto query;
  1193. default:
  1194. goto unknown;
  1195. }
  1196. }
  1197. unknown:
  1198. return -ENOPROTOOPT;
  1199. query:
  1200. if (!attr) {
  1201. attr = __alloca(sizeof(PAL_STREAM_ATTR));
  1202. if (!DkStreamAttributesQuerybyHandle(hdl->pal_handle, attr))
  1203. return -PAL_ERRNO;
  1204. }
  1205. if (level == SOL_SOCKET) {
  1206. switch(optname) {
  1207. case SO_KEEPALIVE:
  1208. if (bolval != attr->socket.tcp_keepalive) {
  1209. attr->socket.tcp_keepalive = bolval;
  1210. goto set;
  1211. }
  1212. break;
  1213. case SO_LINGER: {
  1214. struct __kernel_linger * l = (struct __kernel_linger *) optval;
  1215. int linger = l->l_onoff ? l->l_linger : 0;
  1216. if (linger != (int) attr->socket.linger) {
  1217. attr->socket.linger = linger;
  1218. goto set;
  1219. }
  1220. break;
  1221. }
  1222. case SO_RCVBUF:
  1223. if (intval != (int) attr->socket.receivebuf) {
  1224. attr->socket.receivebuf = intval;
  1225. goto set;
  1226. }
  1227. break;
  1228. case SO_SNDBUF:
  1229. if (intval != (int) attr->socket.sendbuf) {
  1230. attr->socket.sendbuf = intval;
  1231. goto set;
  1232. }
  1233. break;
  1234. case SO_RCVTIMEO:
  1235. if (intval != (int) attr->socket.receivetimeout) {
  1236. attr->socket.receivetimeout = intval;
  1237. goto set;
  1238. }
  1239. break;
  1240. case SO_SNDTIMEO:
  1241. if (intval != (int) attr->socket.sendtimeout) {
  1242. attr->socket.sendtimeout = intval;
  1243. goto set;
  1244. }
  1245. break;
  1246. case SO_REUSEADDR:
  1247. break;
  1248. }
  1249. }
  1250. if (level == SOL_TCP) {
  1251. switch(optname) {
  1252. case TCP_CORK:
  1253. if (bolval != attr->socket.tcp_cork) {
  1254. attr->socket.tcp_cork = bolval;
  1255. goto set;
  1256. }
  1257. break;
  1258. case TCP_NODELAY:
  1259. if (bolval != attr->socket.tcp_nodelay) {
  1260. attr->socket.tcp_nodelay = bolval;
  1261. goto set;
  1262. }
  1263. break;
  1264. }
  1265. }
  1266. return 0;
  1267. set:
  1268. if (!DkStreamAttributesSetbyHandle(hdl->pal_handle, attr))
  1269. return -PAL_ERRNO;
  1270. return 0;
  1271. }
  1272. static int __process_pending_options (struct shim_handle * hdl)
  1273. {
  1274. struct shim_sock_handle * sock = &hdl->info.sock;
  1275. if (!sock->pending_options)
  1276. return 0;
  1277. PAL_STREAM_ATTR attr;
  1278. if (!DkStreamAttributesQuerybyHandle(hdl->pal_handle, &attr))
  1279. return -PAL_ERRNO;
  1280. struct shim_sock_option * o = sock->pending_options;
  1281. while (o) {
  1282. PAL_STREAM_ATTR tmp = attr;
  1283. int ret = __do_setsockopt(hdl, o->level, o->optname, o->optval,
  1284. o->optlen, &tmp);
  1285. if (!ret)
  1286. attr = tmp;
  1287. struct shim_sock_option * next = o->next;
  1288. free(o);
  1289. o = next;
  1290. }
  1291. return 0;
  1292. }
  1293. int shim_do_setsockopt (int fd, int level, int optname, char * optval,
  1294. int optlen)
  1295. {
  1296. if (!optval)
  1297. return -EFAULT;
  1298. struct shim_handle * hdl = get_fd_handle(fd, NULL, NULL);
  1299. if (!hdl)
  1300. return -EBADF;
  1301. int ret = 0;
  1302. if (hdl->type != TYPE_SOCK) {
  1303. ret = -ENOTSOCK;
  1304. goto out;
  1305. }
  1306. struct shim_sock_handle * sock = &hdl->info.sock;
  1307. lock(hdl->lock);
  1308. if (!hdl->pal_handle) {
  1309. struct shim_sock_option * o = malloc(sizeof(struct shim_sock_option) +
  1310. optlen);
  1311. if (!o) {
  1312. ret = -ENOMEM;
  1313. goto out_locked;
  1314. }
  1315. struct shim_sock_option ** next = &sock->pending_options;
  1316. while (*next)
  1317. next = &(*next)->next;
  1318. o->next = NULL;
  1319. *next = o;
  1320. o->level = level;
  1321. o->optname = optname;
  1322. o->optlen = optlen;
  1323. memcpy(&o->optval, optval, optlen);
  1324. goto out_locked;
  1325. }
  1326. ret = __do_setsockopt(hdl, level, optname, optval, optlen, NULL);
  1327. out_locked:
  1328. unlock(hdl->lock);
  1329. out:
  1330. put_handle(hdl);
  1331. return ret;
  1332. }
  1333. int shim_do_getsockopt (int fd, int level, int optname, char * optval,
  1334. int * optlen)
  1335. {
  1336. if (!optval || !optlen)
  1337. return -EFAULT;
  1338. struct shim_handle * hdl = get_fd_handle(fd, NULL, NULL);
  1339. if (!hdl)
  1340. return -EBADF;
  1341. int ret = 0;
  1342. if (hdl->type != TYPE_SOCK) {
  1343. ret = -ENOTSOCK;
  1344. goto out;
  1345. }
  1346. struct shim_sock_handle * sock = &hdl->info.sock;
  1347. lock(hdl->lock);
  1348. int * intval = (int *) optval;
  1349. if (level == SOL_SOCKET) {
  1350. switch(optname) {
  1351. case SO_ACCEPTCONN:
  1352. *intval = (sock->sock_state == SOCK_LISTENED) ? 1 : 0;
  1353. goto out;
  1354. case SO_DOMAIN:
  1355. *intval = sock->domain;
  1356. goto out;
  1357. case SO_ERROR:
  1358. *intval = sock->error;
  1359. goto out;
  1360. case SO_PROTOCOL:
  1361. switch(sock->protocol) {
  1362. case SOCK_STREAM:
  1363. *intval = IPPROTO_SCTP;
  1364. break;
  1365. case SOCK_DGRAM:
  1366. *intval = IPPROTO_UDP;
  1367. break;
  1368. default:
  1369. goto unknown;
  1370. }
  1371. goto out;
  1372. case SO_TYPE:
  1373. *intval = sock->sock_type;
  1374. goto out;
  1375. case SO_KEEPALIVE:
  1376. case SO_LINGER:
  1377. case SO_RCVBUF:
  1378. case SO_SNDBUF:
  1379. case SO_RCVTIMEO:
  1380. case SO_SNDTIMEO:
  1381. case SO_REUSEADDR:
  1382. goto query;
  1383. default:
  1384. goto unknown;
  1385. }
  1386. }
  1387. if (level == SOL_TCP) {
  1388. switch(optname) {
  1389. case TCP_CORK:
  1390. case TCP_NODELAY:
  1391. goto query;
  1392. default:
  1393. goto unknown;
  1394. }
  1395. }
  1396. unknown:
  1397. ret = -ENOPROTOOPT;
  1398. goto out;
  1399. query:
  1400. {
  1401. PAL_STREAM_ATTR attr;
  1402. if (!DkStreamAttributesQuerybyHandle(hdl->pal_handle, &attr)) {
  1403. ret = -PAL_ERRNO;
  1404. goto out;
  1405. }
  1406. if (level == SOL_SOCKET) {
  1407. switch(optname) {
  1408. case SO_KEEPALIVE:
  1409. *intval = attr.socket.tcp_keepalive ? 1 : 0;
  1410. break;
  1411. case SO_LINGER: {
  1412. struct __kernel_linger * l =
  1413. (struct __kernel_linger *) optval;
  1414. l->l_onoff = attr.socket.linger ? 1 : 0;
  1415. l->l_linger = attr.socket.linger;
  1416. break;
  1417. }
  1418. case SO_RCVBUF:
  1419. *intval = attr.socket.receivebuf;
  1420. break;
  1421. case SO_SNDBUF:
  1422. *intval = attr.socket.sendbuf;
  1423. break;
  1424. case SO_RCVTIMEO:
  1425. *intval = attr.socket.receivetimeout;
  1426. break;
  1427. case SO_SNDTIMEO:
  1428. *intval = attr.socket.sendtimeout;
  1429. break;
  1430. case SO_REUSEADDR:
  1431. *intval = 1;
  1432. break;
  1433. }
  1434. }
  1435. if (level == SOL_TCP) {
  1436. switch(optname) {
  1437. case TCP_CORK:
  1438. *intval = attr.socket.tcp_cork ? 1 : 0;
  1439. break;
  1440. case TCP_NODELAY:
  1441. *intval = attr.socket.tcp_nodelay ? 1 : 0;
  1442. break;
  1443. }
  1444. }
  1445. }
  1446. out:
  1447. unlock(hdl->lock);
  1448. put_handle(hdl);
  1449. return ret;
  1450. }