You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

resolv.c 11KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432
  1. /*
  2. * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
  3. *
  4. * This program is free software; you can redistribute it and/or
  5. * modify it under the terms of the GNU General Public License as
  6. * published by the Free Software Foundation; either version 2 of the
  7. * License, or any later version.
  8. *
  9. * This program is distributed in the hope that it will be useful, but
  10. * WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12. * General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write to the Free Software
  16. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17. * 02110-1301, USA.
  18. */
  19. FILE_LICENCE ( GPL2_OR_LATER );
  20. #include <stdint.h>
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include <errno.h>
  24. #include <ipxe/in.h>
  25. #include <ipxe/xfer.h>
  26. #include <ipxe/open.h>
  27. #include <ipxe/process.h>
  28. #include <ipxe/resolv.h>
  29. /** @file
  30. *
  31. * Name resolution
  32. *
  33. */
  34. /***************************************************************************
  35. *
  36. * Name resolution interfaces
  37. *
  38. ***************************************************************************
  39. */
  40. /**
  41. * Name resolved
  42. *
  43. * @v intf Object interface
  44. * @v sa Completed socket address (if successful)
  45. */
  46. void resolv_done ( struct interface *intf, struct sockaddr *sa ) {
  47. struct interface *dest;
  48. resolv_done_TYPE ( void * ) *op =
  49. intf_get_dest_op ( intf, resolv_done, &dest );
  50. void *object = intf_object ( dest );
  51. DBGC ( INTF_COL ( intf ), "INTF " INTF_INTF_FMT " resolv_done\n",
  52. INTF_INTF_DBG ( intf, dest ) );
  53. if ( op ) {
  54. op ( object, sa );
  55. } else {
  56. /* Default is to ignore resolutions */
  57. }
  58. intf_put ( dest );
  59. }
  60. /***************************************************************************
  61. *
  62. * Numeric name resolver
  63. *
  64. ***************************************************************************
  65. */
  66. /** A numeric name resolver */
  67. struct numeric_resolv {
  68. /** Reference counter */
  69. struct refcnt refcnt;
  70. /** Name resolution interface */
  71. struct interface resolv;
  72. /** Process */
  73. struct process process;
  74. /** Completed socket address */
  75. struct sockaddr sa;
  76. /** Overall status code */
  77. int rc;
  78. };
  79. static void numeric_step ( struct numeric_resolv *numeric ) {
  80. if ( numeric->rc == 0 )
  81. resolv_done ( &numeric->resolv, &numeric->sa );
  82. intf_shutdown ( &numeric->resolv, numeric->rc );
  83. }
  84. static struct process_descriptor numeric_process_desc =
  85. PROC_DESC_ONCE ( struct numeric_resolv, process, numeric_step );
  86. static int numeric_resolv ( struct interface *resolv,
  87. const char *name, struct sockaddr *sa ) {
  88. struct numeric_resolv *numeric;
  89. struct sockaddr_in *sin;
  90. /* Allocate and initialise structure */
  91. numeric = zalloc ( sizeof ( *numeric ) );
  92. if ( ! numeric )
  93. return -ENOMEM;
  94. ref_init ( &numeric->refcnt, NULL );
  95. intf_init ( &numeric->resolv, &null_intf_desc, &numeric->refcnt );
  96. process_init ( &numeric->process, &numeric_process_desc,
  97. &numeric->refcnt );
  98. memcpy ( &numeric->sa, sa, sizeof ( numeric->sa ) );
  99. DBGC ( numeric, "NUMERIC %p attempting to resolve \"%s\"\n",
  100. numeric, name );
  101. /* Attempt to resolve name */
  102. sin = ( ( struct sockaddr_in * ) &numeric->sa );
  103. if ( inet_aton ( name, &sin->sin_addr ) != 0 ) {
  104. sin->sin_family = AF_INET;
  105. } else {
  106. numeric->rc = -EINVAL;
  107. }
  108. /* Attach to parent interface, mortalise self, and return */
  109. intf_plug_plug ( &numeric->resolv, resolv );
  110. ref_put ( &numeric->refcnt );
  111. return 0;
  112. }
  113. struct resolver numeric_resolver __resolver ( RESOLV_NUMERIC ) = {
  114. .name = "NUMERIC",
  115. .resolv = numeric_resolv,
  116. };
  117. /***************************************************************************
  118. *
  119. * Name resolution multiplexer
  120. *
  121. ***************************************************************************
  122. */
  123. /** A name resolution multiplexer */
  124. struct resolv_mux {
  125. /** Reference counter */
  126. struct refcnt refcnt;
  127. /** Parent name resolution interface */
  128. struct interface parent;
  129. /** Child name resolution interface */
  130. struct interface child;
  131. /** Current child resolver */
  132. struct resolver *resolver;
  133. /** Socket address to complete */
  134. struct sockaddr sa;
  135. /** Name to be resolved
  136. *
  137. * Must be at end of structure
  138. */
  139. char name[0];
  140. };
  141. /**
  142. * Try current child name resolver
  143. *
  144. * @v mux Name resolution multiplexer
  145. * @ret rc Return status code
  146. */
  147. static int resmux_try ( struct resolv_mux *mux ) {
  148. struct resolver *resolver = mux->resolver;
  149. int rc;
  150. DBGC ( mux, "RESOLV %p trying method %s\n", mux, resolver->name );
  151. if ( ( rc = resolver->resolv ( &mux->child, mux->name,
  152. &mux->sa ) ) != 0 ) {
  153. DBGC ( mux, "RESOLV %p could not use method %s: %s\n",
  154. mux, resolver->name, strerror ( rc ) );
  155. return rc;
  156. }
  157. return 0;
  158. }
  159. /**
  160. * Child resolved name
  161. *
  162. * @v mux Name resolution multiplexer
  163. * @v sa Completed socket address
  164. */
  165. static void resmux_child_resolv_done ( struct resolv_mux *mux,
  166. struct sockaddr *sa ) {
  167. DBGC ( mux, "RESOLV %p resolved \"%s\" using method %s\n",
  168. mux, mux->name, mux->resolver->name );
  169. /* Pass resolution to parent */
  170. resolv_done ( &mux->parent, sa );
  171. }
  172. /**
  173. * Child finished resolution
  174. *
  175. * @v mux Name resolution multiplexer
  176. * @v rc Return status code
  177. */
  178. static void resmux_child_close ( struct resolv_mux *mux, int rc ) {
  179. /* Restart child interface */
  180. intf_restart ( &mux->child, rc );
  181. /* If this resolution succeeded, stop now */
  182. if ( rc == 0 ) {
  183. DBGC ( mux, "RESOLV %p succeeded using method %s\n",
  184. mux, mux->resolver->name );
  185. goto finished;
  186. }
  187. /* Attempt next child resolver, if possible */
  188. mux->resolver++;
  189. if ( mux->resolver >= table_end ( RESOLVERS ) ) {
  190. DBGC ( mux, "RESOLV %p failed to resolve name\n", mux );
  191. goto finished;
  192. }
  193. if ( ( rc = resmux_try ( mux ) ) != 0 )
  194. goto finished;
  195. /* Next resolver is now running */
  196. return;
  197. finished:
  198. intf_shutdown ( &mux->parent, rc );
  199. }
  200. /** Name resolution multiplexer child interface operations */
  201. static struct interface_operation resmux_child_op[] = {
  202. INTF_OP ( resolv_done, struct resolv_mux *, resmux_child_resolv_done ),
  203. INTF_OP ( intf_close, struct resolv_mux *, resmux_child_close ),
  204. };
  205. /** Name resolution multiplexer child interface descriptor */
  206. static struct interface_descriptor resmux_child_desc =
  207. INTF_DESC ( struct resolv_mux, child, resmux_child_op );
  208. /**
  209. * Start name resolution
  210. *
  211. * @v resolv Name resolution interface
  212. * @v name Name to resolve
  213. * @v sa Socket address to complete
  214. * @ret rc Return status code
  215. */
  216. int resolv ( struct interface *resolv, const char *name,
  217. struct sockaddr *sa ) {
  218. struct resolv_mux *mux;
  219. size_t name_len = ( strlen ( name ) + 1 );
  220. int rc;
  221. /* Allocate and initialise structure */
  222. mux = zalloc ( sizeof ( *mux ) + name_len );
  223. if ( ! mux )
  224. return -ENOMEM;
  225. ref_init ( &mux->refcnt, NULL );
  226. intf_init ( &mux->parent, &null_intf_desc, &mux->refcnt );
  227. intf_init ( &mux->child, &resmux_child_desc, &mux->refcnt );
  228. mux->resolver = table_start ( RESOLVERS );
  229. if ( sa )
  230. memcpy ( &mux->sa, sa, sizeof ( mux->sa ) );
  231. memcpy ( mux->name, name, name_len );
  232. DBGC ( mux, "RESOLV %p attempting to resolve \"%s\"\n", mux, name );
  233. /* Start first resolver in chain. There will always be at
  234. * least one resolver (the numeric resolver), so no need to
  235. * check for the zero-resolvers-available case.
  236. */
  237. if ( ( rc = resmux_try ( mux ) ) != 0 )
  238. goto err;
  239. /* Attach parent interface, mortalise self, and return */
  240. intf_plug_plug ( &mux->parent, resolv );
  241. ref_put ( &mux->refcnt );
  242. return 0;
  243. err:
  244. ref_put ( &mux->refcnt );
  245. return rc;
  246. }
  247. /***************************************************************************
  248. *
  249. * Named socket opening
  250. *
  251. ***************************************************************************
  252. */
  253. /** A named socket */
  254. struct named_socket {
  255. /** Reference counter */
  256. struct refcnt refcnt;
  257. /** Data transfer interface */
  258. struct interface xfer;
  259. /** Name resolution interface */
  260. struct interface resolv;
  261. /** Communication semantics (e.g. SOCK_STREAM) */
  262. int semantics;
  263. /** Stored local socket address, if applicable */
  264. struct sockaddr local;
  265. /** Stored local socket address exists */
  266. int have_local;
  267. };
  268. /**
  269. * Terminate named socket opener
  270. *
  271. * @v named Named socket
  272. * @v rc Reason for termination
  273. */
  274. static void named_close ( struct named_socket *named, int rc ) {
  275. /* Shut down interfaces */
  276. intf_shutdown ( &named->resolv, rc );
  277. intf_shutdown ( &named->xfer, rc );
  278. }
  279. /**
  280. * Check flow control window
  281. *
  282. * @v named Named socket
  283. * @ret len Length of window
  284. */
  285. static size_t named_window ( struct named_socket *named __unused ) {
  286. /* Not ready for data until we have redirected away */
  287. return 0;
  288. }
  289. /** Named socket opener data transfer interface operations */
  290. static struct interface_operation named_xfer_ops[] = {
  291. INTF_OP ( xfer_window, struct named_socket *, named_window ),
  292. INTF_OP ( intf_close, struct named_socket *, named_close ),
  293. };
  294. /** Named socket opener data transfer interface descriptor */
  295. static struct interface_descriptor named_xfer_desc =
  296. INTF_DESC ( struct named_socket, xfer, named_xfer_ops );
  297. /**
  298. * Name resolved
  299. *
  300. * @v named Named socket
  301. * @v sa Completed socket address
  302. */
  303. static void named_resolv_done ( struct named_socket *named,
  304. struct sockaddr *sa ) {
  305. int rc;
  306. /* Nullify data transfer interface */
  307. intf_nullify ( &named->xfer );
  308. /* Redirect data-xfer interface */
  309. if ( ( rc = xfer_redirect ( &named->xfer, LOCATION_SOCKET,
  310. named->semantics, sa,
  311. ( named->have_local ?
  312. &named->local : NULL ) ) ) != 0 ) {
  313. /* Redirection failed - do not unplug data-xfer interface */
  314. DBGC ( named, "NAMED %p could not redirect: %s\n",
  315. named, strerror ( rc ) );
  316. } else {
  317. /* Redirection succeeded - unplug data-xfer interface */
  318. DBGC ( named, "NAMED %p redirected successfully\n", named );
  319. intf_unplug ( &named->xfer );
  320. }
  321. /* Terminate named socket opener */
  322. named_close ( named, rc );
  323. }
  324. /** Named socket opener resolver interface operations */
  325. static struct interface_operation named_resolv_op[] = {
  326. INTF_OP ( intf_close, struct named_socket *, named_close ),
  327. INTF_OP ( resolv_done, struct named_socket *, named_resolv_done ),
  328. };
  329. /** Named socket opener resolver interface descriptor */
  330. static struct interface_descriptor named_resolv_desc =
  331. INTF_DESC ( struct named_socket, resolv, named_resolv_op );
  332. /**
  333. * Open named socket
  334. *
  335. * @v semantics Communication semantics (e.g. SOCK_STREAM)
  336. * @v peer Peer socket address to complete
  337. * @v name Name to resolve
  338. * @v local Local socket address, or NULL
  339. * @ret rc Return status code
  340. */
  341. int xfer_open_named_socket ( struct interface *xfer, int semantics,
  342. struct sockaddr *peer, const char *name,
  343. struct sockaddr *local ) {
  344. struct named_socket *named;
  345. int rc;
  346. /* Allocate and initialise structure */
  347. named = zalloc ( sizeof ( *named ) );
  348. if ( ! named )
  349. return -ENOMEM;
  350. ref_init ( &named->refcnt, NULL );
  351. intf_init ( &named->xfer, &named_xfer_desc, &named->refcnt );
  352. intf_init ( &named->resolv, &named_resolv_desc, &named->refcnt );
  353. named->semantics = semantics;
  354. if ( local ) {
  355. memcpy ( &named->local, local, sizeof ( named->local ) );
  356. named->have_local = 1;
  357. }
  358. DBGC ( named, "NAMED %p opening \"%s\"\n",
  359. named, name );
  360. /* Start name resolution */
  361. if ( ( rc = resolv ( &named->resolv, name, peer ) ) != 0 )
  362. goto err;
  363. /* Attach parent interface, mortalise self, and return */
  364. intf_plug_plug ( &named->xfer, xfer );
  365. ref_put ( &named->refcnt );
  366. return 0;
  367. err:
  368. ref_put ( &named->refcnt );
  369. return rc;
  370. }