pmap_clnt.c 9.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383
  1. /*
  2. * linux/net/sunrpc/pmap_clnt.c
  3. *
  4. * In-kernel RPC portmapper client.
  5. *
  6. * Portmapper supports version 2 of the rpcbind protocol (RFC 1833).
  7. *
  8. * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
  9. */
  10. #include <linux/types.h>
  11. #include <linux/socket.h>
  12. #include <linux/kernel.h>
  13. #include <linux/errno.h>
  14. #include <linux/uio.h>
  15. #include <linux/in.h>
  16. #include <linux/sunrpc/clnt.h>
  17. #include <linux/sunrpc/sched.h>
  18. #ifdef RPC_DEBUG
  19. # define RPCDBG_FACILITY RPCDBG_PMAP
  20. #endif
  21. #define PMAP_SET 1
  22. #define PMAP_UNSET 2
  23. #define PMAP_GETPORT 3
  24. struct portmap_args {
  25. u32 pm_prog;
  26. u32 pm_vers;
  27. u32 pm_prot;
  28. unsigned short pm_port;
  29. struct rpc_xprt * pm_xprt;
  30. };
  31. static struct rpc_procinfo pmap_procedures[];
  32. static struct rpc_clnt * pmap_create(char *, struct sockaddr_in *, int, int);
  33. static void pmap_getport_done(struct rpc_task *, void *);
  34. static struct rpc_program pmap_program;
  35. static void pmap_getport_prepare(struct rpc_task *task, void *calldata)
  36. {
  37. struct portmap_args *map = calldata;
  38. struct rpc_message msg = {
  39. .rpc_proc = &pmap_procedures[PMAP_GETPORT],
  40. .rpc_argp = map,
  41. .rpc_resp = &map->pm_port,
  42. };
  43. rpc_call_setup(task, &msg, 0);
  44. }
  45. static inline struct portmap_args *pmap_map_alloc(void)
  46. {
  47. return kmalloc(sizeof(struct portmap_args), GFP_NOFS);
  48. }
  49. static inline void pmap_map_free(struct portmap_args *map)
  50. {
  51. kfree(map);
  52. }
  53. static void pmap_map_release(void *data)
  54. {
  55. struct portmap_args *map = data;
  56. xprt_put(map->pm_xprt);
  57. pmap_map_free(map);
  58. }
  59. static const struct rpc_call_ops pmap_getport_ops = {
  60. .rpc_call_prepare = pmap_getport_prepare,
  61. .rpc_call_done = pmap_getport_done,
  62. .rpc_release = pmap_map_release,
  63. };
  64. static inline void pmap_wake_portmap_waiters(struct rpc_xprt *xprt, int status)
  65. {
  66. xprt_clear_binding(xprt);
  67. rpc_wake_up_status(&xprt->binding, status);
  68. }
  69. /**
  70. * rpc_getport - obtain the port for a given RPC service on a given host
  71. * @task: task that is waiting for portmapper request
  72. *
  73. * This one can be called for an ongoing RPC request, and can be used in
  74. * an async (rpciod) context.
  75. */
  76. void rpc_getport(struct rpc_task *task)
  77. {
  78. struct rpc_clnt *clnt = task->tk_client;
  79. struct rpc_xprt *xprt = task->tk_xprt;
  80. struct sockaddr_in addr;
  81. struct portmap_args *map;
  82. struct rpc_clnt *pmap_clnt;
  83. struct rpc_task *child;
  84. int status;
  85. dprintk("RPC: %5u rpc_getport(%s, %u, %u, %d)\n",
  86. task->tk_pid, clnt->cl_server,
  87. clnt->cl_prog, clnt->cl_vers, xprt->prot);
  88. /* Autobind on cloned rpc clients is discouraged */
  89. BUG_ON(clnt->cl_parent != clnt);
  90. status = -EACCES; /* tell caller to check again */
  91. if (xprt_test_and_set_binding(xprt))
  92. goto bailout_nowake;
  93. /* Put self on queue before sending rpcbind request, in case
  94. * pmap_getport_done completes before we return from rpc_run_task */
  95. rpc_sleep_on(&xprt->binding, task, NULL, NULL);
  96. /* Someone else may have bound if we slept */
  97. status = 0;
  98. if (xprt_bound(xprt))
  99. goto bailout_nofree;
  100. status = -ENOMEM;
  101. map = pmap_map_alloc();
  102. if (!map)
  103. goto bailout_nofree;
  104. map->pm_prog = clnt->cl_prog;
  105. map->pm_vers = clnt->cl_vers;
  106. map->pm_prot = xprt->prot;
  107. map->pm_port = 0;
  108. map->pm_xprt = xprt_get(xprt);
  109. rpc_peeraddr(clnt, (struct sockaddr *) &addr, sizeof(addr));
  110. pmap_clnt = pmap_create(clnt->cl_server, &addr, map->pm_prot, 0);
  111. status = PTR_ERR(pmap_clnt);
  112. if (IS_ERR(pmap_clnt))
  113. goto bailout;
  114. status = -EIO;
  115. child = rpc_run_task(pmap_clnt, RPC_TASK_ASYNC, &pmap_getport_ops, map);
  116. if (IS_ERR(child))
  117. goto bailout_nofree;
  118. rpc_put_task(child);
  119. task->tk_xprt->stat.bind_count++;
  120. return;
  121. bailout:
  122. pmap_map_free(map);
  123. xprt_put(xprt);
  124. bailout_nofree:
  125. pmap_wake_portmap_waiters(xprt, status);
  126. bailout_nowake:
  127. task->tk_status = status;
  128. }
  129. #ifdef CONFIG_ROOT_NFS
  130. /**
  131. * rpc_getport_external - obtain the port for a given RPC service on a given host
  132. * @sin: address of remote peer
  133. * @prog: RPC program number to bind
  134. * @vers: RPC version number to bind
  135. * @prot: transport protocol to use to make this request
  136. *
  137. * This one is called from outside the RPC client in a synchronous task context.
  138. */
  139. int rpc_getport_external(struct sockaddr_in *sin, __u32 prog, __u32 vers, int prot)
  140. {
  141. struct portmap_args map = {
  142. .pm_prog = prog,
  143. .pm_vers = vers,
  144. .pm_prot = prot,
  145. .pm_port = 0
  146. };
  147. struct rpc_message msg = {
  148. .rpc_proc = &pmap_procedures[PMAP_GETPORT],
  149. .rpc_argp = &map,
  150. .rpc_resp = &map.pm_port,
  151. };
  152. struct rpc_clnt *pmap_clnt;
  153. char hostname[32];
  154. int status;
  155. dprintk("RPC: rpc_getport_external(%u.%u.%u.%u, %u, %u, %d)\n",
  156. NIPQUAD(sin->sin_addr.s_addr), prog, vers, prot);
  157. sprintf(hostname, "%u.%u.%u.%u", NIPQUAD(sin->sin_addr.s_addr));
  158. pmap_clnt = pmap_create(hostname, sin, prot, 0);
  159. if (IS_ERR(pmap_clnt))
  160. return PTR_ERR(pmap_clnt);
  161. /* Setup the call info struct */
  162. status = rpc_call_sync(pmap_clnt, &msg, 0);
  163. if (status >= 0) {
  164. if (map.pm_port != 0)
  165. return map.pm_port;
  166. status = -EACCES;
  167. }
  168. return status;
  169. }
  170. #endif
  171. /*
  172. * Portmapper child task invokes this callback via tk_exit.
  173. */
  174. static void pmap_getport_done(struct rpc_task *child, void *data)
  175. {
  176. struct portmap_args *map = data;
  177. struct rpc_xprt *xprt = map->pm_xprt;
  178. int status = child->tk_status;
  179. if (status < 0) {
  180. /* Portmapper not available */
  181. xprt->ops->set_port(xprt, 0);
  182. } else if (map->pm_port == 0) {
  183. /* Requested RPC service wasn't registered */
  184. xprt->ops->set_port(xprt, 0);
  185. status = -EACCES;
  186. } else {
  187. /* Succeeded */
  188. xprt->ops->set_port(xprt, map->pm_port);
  189. xprt_set_bound(xprt);
  190. status = 0;
  191. }
  192. dprintk("RPC: %5u pmap_getport_done(status %d, port %u)\n",
  193. child->tk_pid, status, map->pm_port);
  194. pmap_wake_portmap_waiters(xprt, status);
  195. }
  196. /**
  197. * rpc_register - set or unset a port registration with the local portmapper
  198. * @prog: RPC program number to bind
  199. * @vers: RPC version number to bind
  200. * @prot: transport protocol to use to make this request
  201. * @port: port value to register
  202. * @okay: result code
  203. *
  204. * port == 0 means unregister, port != 0 means register.
  205. */
  206. int rpc_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
  207. {
  208. struct sockaddr_in sin = {
  209. .sin_family = AF_INET,
  210. .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
  211. };
  212. struct portmap_args map = {
  213. .pm_prog = prog,
  214. .pm_vers = vers,
  215. .pm_prot = prot,
  216. .pm_port = port,
  217. };
  218. struct rpc_message msg = {
  219. .rpc_proc = &pmap_procedures[port ? PMAP_SET : PMAP_UNSET],
  220. .rpc_argp = &map,
  221. .rpc_resp = okay,
  222. };
  223. struct rpc_clnt *pmap_clnt;
  224. int error = 0;
  225. dprintk("RPC: registering (%u, %u, %d, %u) with portmapper.\n",
  226. prog, vers, prot, port);
  227. pmap_clnt = pmap_create("localhost", &sin, IPPROTO_UDP, 1);
  228. if (IS_ERR(pmap_clnt)) {
  229. error = PTR_ERR(pmap_clnt);
  230. dprintk("RPC: couldn't create pmap client. Error = %d\n",
  231. error);
  232. return error;
  233. }
  234. error = rpc_call_sync(pmap_clnt, &msg, 0);
  235. if (error < 0) {
  236. printk(KERN_WARNING
  237. "RPC: failed to contact portmap (errno %d).\n",
  238. error);
  239. }
  240. dprintk("RPC: registration status %d/%d\n", error, *okay);
  241. /* Client deleted automatically because cl_oneshot == 1 */
  242. return error;
  243. }
  244. static struct rpc_clnt *pmap_create(char *hostname, struct sockaddr_in *srvaddr, int proto, int privileged)
  245. {
  246. struct rpc_create_args args = {
  247. .protocol = proto,
  248. .address = (struct sockaddr *)srvaddr,
  249. .addrsize = sizeof(*srvaddr),
  250. .servername = hostname,
  251. .program = &pmap_program,
  252. .version = RPC_PMAP_VERSION,
  253. .authflavor = RPC_AUTH_UNIX,
  254. .flags = (RPC_CLNT_CREATE_ONESHOT |
  255. RPC_CLNT_CREATE_NOPING),
  256. };
  257. srvaddr->sin_port = htons(RPC_PMAP_PORT);
  258. if (!privileged)
  259. args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
  260. return rpc_create(&args);
  261. }
  262. /*
  263. * XDR encode/decode functions for PMAP
  264. */
  265. static int xdr_encode_mapping(struct rpc_rqst *req, __be32 *p, struct portmap_args *map)
  266. {
  267. dprintk("RPC: xdr_encode_mapping(%u, %u, %u, %u)\n",
  268. map->pm_prog, map->pm_vers,
  269. map->pm_prot, map->pm_port);
  270. *p++ = htonl(map->pm_prog);
  271. *p++ = htonl(map->pm_vers);
  272. *p++ = htonl(map->pm_prot);
  273. *p++ = htonl(map->pm_port);
  274. req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
  275. return 0;
  276. }
  277. static int xdr_decode_port(struct rpc_rqst *req, __be32 *p, unsigned short *portp)
  278. {
  279. *portp = (unsigned short) ntohl(*p++);
  280. return 0;
  281. }
  282. static int xdr_decode_bool(struct rpc_rqst *req, __be32 *p, unsigned int *boolp)
  283. {
  284. *boolp = (unsigned int) ntohl(*p++);
  285. return 0;
  286. }
  287. static struct rpc_procinfo pmap_procedures[] = {
  288. [PMAP_SET] = {
  289. .p_proc = PMAP_SET,
  290. .p_encode = (kxdrproc_t) xdr_encode_mapping,
  291. .p_decode = (kxdrproc_t) xdr_decode_bool,
  292. .p_bufsiz = 4,
  293. .p_count = 1,
  294. .p_statidx = PMAP_SET,
  295. .p_name = "SET",
  296. },
  297. [PMAP_UNSET] = {
  298. .p_proc = PMAP_UNSET,
  299. .p_encode = (kxdrproc_t) xdr_encode_mapping,
  300. .p_decode = (kxdrproc_t) xdr_decode_bool,
  301. .p_bufsiz = 4,
  302. .p_count = 1,
  303. .p_statidx = PMAP_UNSET,
  304. .p_name = "UNSET",
  305. },
  306. [PMAP_GETPORT] = {
  307. .p_proc = PMAP_GETPORT,
  308. .p_encode = (kxdrproc_t) xdr_encode_mapping,
  309. .p_decode = (kxdrproc_t) xdr_decode_port,
  310. .p_bufsiz = 4,
  311. .p_count = 1,
  312. .p_statidx = PMAP_GETPORT,
  313. .p_name = "GETPORT",
  314. },
  315. };
  316. static struct rpc_version pmap_version2 = {
  317. .number = 2,
  318. .nrprocs = 4,
  319. .procs = pmap_procedures
  320. };
  321. static struct rpc_version * pmap_version[] = {
  322. NULL,
  323. NULL,
  324. &pmap_version2
  325. };
  326. static struct rpc_stat pmap_stats;
  327. static struct rpc_program pmap_program = {
  328. .name = "portmap",
  329. .number = RPC_PMAP_PROGRAM,
  330. .nrvers = ARRAY_SIZE(pmap_version),
  331. .version = pmap_version,
  332. .stats = &pmap_stats,
  333. };