sunrpc/portmap.c

   1 /* @(#)portmap.c        2.3 88/08/11 4.0 RPCSRC */
   2 #ifndef lint
   3 static  char sccsid[] = "@(#)portmap.c 1.32 87/08/06 Copyr 1984 Sun Micro";
   4 #endif
   5
   6 /*
   7  * Copyright (c) 1984 by Sun Microsystems, Inc.
   8  */
   9
  10 /*
  11  * portmap.c, Implements the program,version to port number mapping for
  12  * rpc.
  13  */
  14
  15 /*
  16  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  17  * unrestricted use provided that this legend is included on all tape
  18  * media and as a part of the software program in whole or part.  Users
  19  * may copy or modify Sun RPC without charge, but are not authorized
  20  * to license or distribute it to anyone else except as part of a product or
  21  * program developed by the user.
  22  *
  23  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  24  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  25  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  26  *
  27  * Sun RPC is provided with no support and without any obligation on the
  28  * part of Sun Microsystems, Inc. to assist in its use, correction,
  29  * modification or enhancement.
  30  *
  31  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  32  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  33  * OR ANY PART THEREOF.
  34  *
  35  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  36  * or profits or other special, indirect and consequential damages, even if
  37  * Sun has been advised of the possibility of such damages.
  38  *
  39  * Sun Microsystems, Inc.
  40  * 2550 Garcia Avenue
  41  * Mountain View, California  94043
  42  */
  43
  44 #include <rpc/rpc.h>
  45 #include <rpc/pmap_prot.h>
  46 #include <stdio.h>
  47 #include <netdb.h>
  48 #include <sys/socket.h>
  49 #include <sys/ioctl.h>
  50 #include <sys/wait.h>
  51 #include <sys/signal.h>
  52
  53 int reg_service();
  54 void reap();
  55 struct pmaplist *pmaplist;
  56 static int debugging = 0;
  57
  58 main()
  59 {
  60         SVCXPRT *xprt;
  61         int sock, pid, t;
  62         struct sockaddr_in addr;
  63         int len = sizeof(struct sockaddr_in);
  64         register struct pmaplist *pml;
  65
  66 #ifndef DEBUG
  67         pid = fork();
  68         if (pid < 0) {
  69                 perror("portmap: fork");
  70                 exit(1);
  71         }
  72         if (pid != 0)
  73                 exit(0);
  74         for (t = 0; t < 20; t++)
  75                 close(t);
  76         open("/", 0);
  77         dup2(0, 1);
  78         dup2(0, 2);
  79         t = open("/dev/tty", 2);
  80         if (t >= 0) {
  81                 ioctl(t, TIOCNOTTY, (char *)0);
  82                 close(t);
  83         }
  84 #endif
  85         if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
  86                 perror(_("portmap cannot create socket"));
  87                 exit(1);
  88         }
  89
  90         addr.sin_addr.s_addr = 0;
  91         addr.sin_family = AF_INET;
  92         addr.sin_port = htons(PMAPPORT);
  93         if (bind(sock, (struct sockaddr *)&addr, len) != 0) {
  94                 perror(_("portmap cannot bind"));
  95                 exit(1);
  96         }
  97
  98         if ((xprt = svcudp_create(sock)) == (SVCXPRT *)NULL) {
  99                 fprintf(stderr, _("couldn't do udp_create\n"));
 100                 exit(1);
 101         }
 102         /* make an entry for ourself */
 103         pml = (struct pmaplist *)malloc((u_int)sizeof(struct pmaplist));
 104         pml->pml_next = 0;
 105         pml->pml_map.pm_prog = PMAPPROG;
 106         pml->pml_map.pm_vers = PMAPVERS;
 107         pml->pml_map.pm_prot = IPPROTO_UDP;
 108         pml->pml_map.pm_port = PMAPPORT;
 109         pmaplist = pml;
 110
 111         if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
 112                 perror(_("portmap cannot create socket"));
 113                 exit(1);
 114         }
 115         if (bind(sock, (struct sockaddr *)&addr, len) != 0) {
 116                 perror(_("portmap cannot bind"));
 117                 exit(1);
 118         }
 119         if ((xprt = svctcp_create(sock, RPCSMALLMSGSIZE, RPCSMALLMSGSIZE))
 120             == (SVCXPRT *)NULL) {
 121                 fprintf(stderr, _("couldn't do tcp_create\n"));
 122                 exit(1);
 123         }
 124         /* make an entry for ourself */
 125         pml = (struct pmaplist *)malloc((u_int)sizeof(struct pmaplist));
 126         pml->pml_map.pm_prog = PMAPPROG;
 127         pml->pml_map.pm_vers = PMAPVERS;
 128         pml->pml_map.pm_prot = IPPROTO_TCP;
 129         pml->pml_map.pm_port = PMAPPORT;
 130         pml->pml_next = pmaplist;
 131         pmaplist = pml;
 132
 133         (void)svc_register(xprt, PMAPPROG, PMAPVERS, reg_service, FALSE);
 134
 135         (void)signal(SIGCHLD, reap);
 136         svc_run();
 137         fprintf(stderr, _("run_svc returned unexpectedly\n"));
 138         abort();
 139 }
 140
 141 static struct pmaplist *
 142 find_service(prog, vers, prot)
 143         u_long prog;
 144         u_long vers;
 145 {
 146         register struct pmaplist *hit = NULL;
 147         register struct pmaplist *pml;
 148
 149         for (pml = pmaplist; pml != NULL; pml = pml->pml_next) {
 150                 if ((pml->pml_map.pm_prog != prog) ||
 151                         (pml->pml_map.pm_prot != prot))
 152                         continue;
 153                 hit = pml;
 154                 if (pml->pml_map.pm_vers == vers)
 155                     break;
 156         }
 157         return (hit);
 158 }
 159
 160 /*
 161  * 1 OK, 0 not
 162  */
 163 reg_service(rqstp, xprt)
 164         struct svc_req *rqstp;
 165         SVCXPRT *xprt;
 166 {
 167         struct pmap reg;
 168         struct pmaplist *pml, *prevpml, *fnd;
 169         int ans, port;
 170         caddr_t t;
 171
 172 #ifdef DEBUG
 173         fprintf(stderr, "server: about do a switch\n");
 174 #endif
 175         switch (rqstp->rq_proc) {
 176
 177         case PMAPPROC_NULL:
 178                 /*
 179                  * Null proc call
 180                  */
 181                 if ((!svc_sendreply(xprt, xdr_void, NULL)) && debugging) {
 182                         abort();
 183                 }
 184                 break;
 185
 186         case PMAPPROC_SET:
 187                 /*
 188                  * Set a program,version to port mapping
 189                  */
 190                 if (!svc_getargs(xprt, xdr_pmap, &reg))
 191                         svcerr_decode(xprt);
 192                 else {
 193                         /*
 194                          * check to see if already used
 195                          * find_service returns a hit even if
 196                          * the versions don't match, so check for it
 197                          */
 198                         fnd = find_service(reg.pm_prog, reg.pm_vers, reg.pm_prot);
 199                         if (fnd && fnd->pml_map.pm_vers == reg.pm_vers) {
 200                                 if (fnd->pml_map.pm_port == reg.pm_port) {
 201                                         ans = 1;
 202                                         goto done;
 203                                 }
 204                                 else {
 205                                         ans = 0;
 206                                         goto done;
 207                                 }
 208                         } else {
 209                                 /*
 210                                  * add to END of list
 211                                  */
 212                                 pml = (struct pmaplist *)
 213                                     malloc((u_int)sizeof(struct pmaplist));
 214                                 pml->pml_map = reg;
 215                                 pml->pml_next = 0;
 216                                 if (pmaplist == 0) {
 217                                         pmaplist = pml;
 218                                 } else {
 219                                         for (fnd= pmaplist; fnd->pml_next != 0;
 220                                             fnd = fnd->pml_next);
 221                                         fnd->pml_next = pml;
 222                                 }
 223                                 ans = 1;
 224                         }
 225                 done:
 226                         if ((!svc_sendreply(xprt, xdr_long, (caddr_t)&ans)) &&
 227                             debugging) {
 228                                 fprintf(stderr, "svc_sendreply\n");
 229                                 abort();
 230                         }
 231                 }
 232                 break;
 233
 234         case PMAPPROC_UNSET:
 235                 /*
 236                  * Remove a program,version to port mapping.
 237                  */
 238                 if (!svc_getargs(xprt, xdr_pmap, &reg))
 239                         svcerr_decode(xprt);
 240                 else {
 241                         ans = 0;
 242                         for (prevpml = NULL, pml = pmaplist; pml != NULL; ) {
 243                                 if ((pml->pml_map.pm_prog != reg.pm_prog) ||
 244                                         (pml->pml_map.pm_vers != reg.pm_vers)) {
 245                                         /* both pml & prevpml move forwards */
 246                                         prevpml = pml;
 247                                         pml = pml->pml_next;
 248                                         continue;
 249                                 }
 250                                 /* found it; pml moves forward, prevpml stays */
 251                                 ans = 1;
 252                                 t = (caddr_t)pml;
 253                                 pml = pml->pml_next;
 254                                 if (prevpml == NULL)
 255                                         pmaplist = pml;
 256                                 else
 257                                         prevpml->pml_next = pml;
 258                                 free(t);
 259                         }
 260                         if ((!svc_sendreply(xprt, xdr_long, (caddr_t)&ans)) &&
 261                             debugging) {
 262                                 fprintf(stderr, "svc_sendreply\n");
 263                                 abort();
 264                         }
 265                 }
 266                 break;
 267
 268         case PMAPPROC_GETPORT:
 269                 /*
 270                  * Lookup the mapping for a program,version and return its port
 271                  */
 272                 if (!svc_getargs(xprt, xdr_pmap, &reg))
 273                         svcerr_decode(xprt);
 274                 else {
 275                         fnd = find_service(reg.pm_prog, reg.pm_vers, reg.pm_prot);
 276                         if (fnd)
 277                                 port = fnd->pml_map.pm_port;
 278                         else
 279                                 port = 0;
 280                         if ((!svc_sendreply(xprt, xdr_long, (caddr_t)&port)) &&
 281                             debugging) {
 282                                 fprintf(stderr, "svc_sendreply\n");
 283                                 abort();
 284                         }
 285                 }
 286                 break;
 287
 288         case PMAPPROC_DUMP:
 289                 /*
 290                  * Return the current set of mapped program,version
 291                  */
 292                 if (!svc_getargs(xprt, xdr_void, NULL))
 293                         svcerr_decode(xprt);
 294                 else {
 295                         if ((!svc_sendreply(xprt, xdr_pmaplist,
 296                             (caddr_t)&pmaplist)) && debugging) {
 297                                 fprintf(stderr, "svc_sendreply\n");
 298                                 abort();
 299                         }
 300                 }
 301                 break;
 302
 303         case PMAPPROC_CALLIT:
 304                 /*
 305                  * Calls a procedure on the local machine.  If the requested
 306                  * procedure is not registered this procedure does not return
 307                  * error information!!
 308                  * This procedure is only supported on rpc/udp and calls via
 309                  * rpc/udp.  It passes null authentication parameters.
 310                  */
 311                 callit(rqstp, xprt);
 312                 break;
 313
 314         default:
 315                 svcerr_noproc(xprt);
 316                 break;
 317         }
 318 }
 319
 320
 321 /*
 322  * Stuff for the rmtcall service
 323  */
 324 #define ARGSIZE 9000
 325
 326 typedef struct encap_parms {
 327         u_long arglen;
 328         char *args;
 329 };
 330
 331 static bool_t
 332 xdr_encap_parms(xdrs, epp)
 333         XDR *xdrs;
 334         struct encap_parms *epp;
 335 {
 336
 337         return (xdr_bytes(xdrs, &(epp->args), &(epp->arglen), ARGSIZE));
 338 }
 339
 340 typedef struct rmtcallargs {
 341         u_long  rmt_prog;
 342         u_long  rmt_vers;
 343         u_long  rmt_port;
 344         u_long  rmt_proc;
 345         struct encap_parms rmt_args;
 346 };
 347
 348 static bool_t
 349 xdr_rmtcall_args(xdrs, cap)
 350         register XDR *xdrs;
 351         register struct rmtcallargs *cap;
 352 {
 353
 354         /* does not get a port number */
 355         if (xdr_u_long(xdrs, &(cap->rmt_prog)) &&
 356             xdr_u_long(xdrs, &(cap->rmt_vers)) &&
 357             xdr_u_long(xdrs, &(cap->rmt_proc))) {
 358                 return (xdr_encap_parms(xdrs, &(cap->rmt_args)));
 359         }
 360         return (FALSE);
 361 }
 362
 363 static bool_t
 364 xdr_rmtcall_result(xdrs, cap)
 365         register XDR *xdrs;
 366         register struct rmtcallargs *cap;
 367 {
 368         if (xdr_u_long(xdrs, &(cap->rmt_port)))
 369                 return (xdr_encap_parms(xdrs, &(cap->rmt_args)));
 370         return (FALSE);
 371 }
 372
 373 /*
 374  * only worries about the struct encap_parms part of struct rmtcallargs.
 375  * The arglen must already be set!!
 376  */
 377 static bool_t
 378 xdr_opaque_parms(xdrs, cap)
 379         XDR *xdrs;
 380         struct rmtcallargs *cap;
 381 {
 382
 383         return (xdr_opaque(xdrs, cap->rmt_args.args, cap->rmt_args.arglen));
 384 }
 385
 386 /*
 387  * This routine finds and sets the length of incoming opaque paraters
 388  * and then calls xdr_opaque_parms.
 389  */
 390 static bool_t
 391 xdr_len_opaque_parms(xdrs, cap)
 392         register XDR *xdrs;
 393         struct rmtcallargs *cap;
 394 {
 395         register u_int beginpos, lowpos, highpos, currpos, pos;
 396
 397         beginpos = lowpos = pos = xdr_getpos(xdrs);
 398         highpos = lowpos + ARGSIZE;
 399         while ((int)(highpos - lowpos) >= 0) {
 400                 currpos = (lowpos + highpos) / 2;
 401                 if (xdr_setpos(xdrs, currpos)) {
 402                         pos = currpos;
 403                         lowpos = currpos + 1;
 404                 } else {
 405                         highpos = currpos - 1;
 406                 }
 407         }
 408         xdr_setpos(xdrs, beginpos);
 409         cap->rmt_args.arglen = pos - beginpos;
 410         return (xdr_opaque_parms(xdrs, cap));
 411 }
 412
 413 /*
 414  * Call a remote procedure service
 415  * This procedure is very quiet when things go wrong.
 416  * The proc is written to support broadcast rpc.  In the broadcast case,
 417  * a machine should shut-up instead of complain, less the requestor be
 418  * overrun with complaints at the expense of not hearing a valid reply ...
 419  *
 420  * This now forks so that the program & process that it calls can call
 421  * back to the portmapper.
 422  */
 423 static
 424 callit(rqstp, xprt)
 425         struct svc_req *rqstp;
 426         SVCXPRT *xprt;
 427 {
 428         struct rmtcallargs a;
 429         struct pmaplist *pml;
 430         u_short port;
 431         struct sockaddr_in me;
 432         int pid, socket = -1;
 433         CLIENT *client;
 434         struct authunix_parms *au = (struct authunix_parms *)rqstp->rq_clntcred;
 435         struct timeval timeout;
 436         char buf[ARGSIZE];
 437
 438         timeout.tv_sec = 5;
 439         timeout.tv_usec = 0;
 440         a.rmt_args.args = buf;
 441         if (!svc_getargs(xprt, xdr_rmtcall_args, &a))
 442             return;
 443         if ((pml = find_service(a.rmt_prog, a.rmt_vers, IPPROTO_UDP)) == NULL)
 444             return;
 445         /*
 446          * fork a child to do the work.  Parent immediately returns.
 447          * Child exits upon completion.
 448          */
 449         if ((pid = fork()) != 0) {
 450                 if (debugging && (pid < 0)) {
 451                         fprintf(stderr, _("portmap CALLIT: cannot fork.\n"));
 452                 }
 453                 return;
 454         }
 455         port = pml->pml_map.pm_port;
 456         get_myaddress(&me);
 457         me.sin_port = htons(port);
 458         client = clntudp_create(&me, a.rmt_prog, a.rmt_vers, timeout, &socket);
 459         if (client != (CLIENT *)NULL) {
 460                 if (rqstp->rq_cred.oa_flavor == AUTH_UNIX) {
 461                         client->cl_auth = authunix_create(au->aup_machname,
 462                            au->aup_uid, au->aup_gid, au->aup_len, au->aup_gids);
 463                 }
 464                 a.rmt_port = (u_long)port;
 465                 if (clnt_call(client, a.rmt_proc, xdr_opaque_parms, &a,
 466                     xdr_len_opaque_parms, &a, timeout) == RPC_SUCCESS) {
 467                         svc_sendreply(xprt, xdr_rmtcall_result, &a);
 468                 }
 469                 AUTH_DESTROY(client->cl_auth);
 470                 clnt_destroy(client);
 471         }
 472         /* (void)close(socket); clnt_destroy already closed it */
 473         exit(0);
 474 }
 475
 476 void
 477 reap()
 478 {
 479         while (wait3(NULL, WNOHANG, NULL) > 0);
 480 }