1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2014 Nexenta Systems, Inc. All rights reserved. 25 */ 26 27 /* Copyright (c) 1988 AT&T */ 28 /* All Rights Reserved */ 29 30 /* 31 * svc_generic.c, Server side for RPC. 32 * 33 */ 34 35 #include "mt.h" 36 #include <stdlib.h> 37 #include <sys/socket.h> 38 #include <netinet/in.h> 39 #include <netinet/tcp.h> 40 #include <netinet/udp.h> 41 #include <inttypes.h> 42 #include "rpc_mt.h" 43 #include <stdio.h> 44 #include <rpc/rpc.h> 45 #include <sys/types.h> 46 #include <errno.h> 47 #include <syslog.h> 48 #include <rpc/nettype.h> 49 #include <malloc.h> 50 #include <string.h> 51 #include <stropts.h> 52 #include <tsol/label.h> 53 #include <nfs/nfs.h> 54 #include <nfs/nfs_acl.h> 55 #include <rpcsvc/mount.h> 56 #include <rpcsvc/nsm_addr.h> 57 #include <rpcsvc/rquota.h> 58 #include <rpcsvc/sm_inter.h> 59 #include <rpcsvc/nlm_prot.h> 60 61 extern int __svc_vc_setflag(SVCXPRT *, int); 62 63 extern SVCXPRT *svc_dg_create_private(int, uint_t, uint_t); 64 extern SVCXPRT *svc_vc_create_private(int, uint_t, uint_t); 65 extern SVCXPRT *svc_fd_create_private(int, uint_t, uint_t); 66 67 extern bool_t __svc_add_to_xlist(SVCXPRT_LIST **, SVCXPRT *, mutex_t *); 68 extern void __svc_free_xlist(SVCXPRT_LIST **, mutex_t *); 69 70 extern bool_t __rpc_try_doors(const char *, bool_t *); 71 72 /* 73 * The highest level interface for server creation. 74 * It tries for all the nettokens in that particular class of token 75 * and returns the number of handles it can create and/or find. 76 * 77 * It creates a link list of all the handles it could create. 78 * If svc_create() is called multiple times, it uses the handle 79 * created earlier instead of creating a new handle every time. 80 */ 81 82 /* VARIABLES PROTECTED BY xprtlist_lock: xprtlist */ 83 84 SVCXPRT_LIST *_svc_xprtlist = NULL; 85 extern mutex_t xprtlist_lock; 86 87 static SVCXPRT * svc_tli_create_common(int, const struct netconfig *, 88 const struct t_bind *, uint_t, uint_t, boolean_t); 89 90 boolean_t 91 is_multilevel(rpcprog_t prognum) 92 { 93 /* This is a list of identified multilevel service provider */ 94 if ((prognum == MOUNTPROG) || (prognum == NFS_PROGRAM) || 95 (prognum == NFS_ACL_PROGRAM) || (prognum == NLM_PROG) || 96 (prognum == NSM_ADDR_PROGRAM) || (prognum == RQUOTAPROG) || 97 (prognum == SM_PROG)) 98 return (B_TRUE); 99 100 return (B_FALSE); 101 } 102 103 void 104 __svc_free_xprtlist(void) 105 { 106 __svc_free_xlist(&_svc_xprtlist, &xprtlist_lock); 107 } 108 109 int 110 svc_create(void (*dispatch)(), const rpcprog_t prognum, const rpcvers_t versnum, 111 const char *nettype) 112 { 113 SVCXPRT_LIST *l; 114 int num = 0; 115 SVCXPRT *xprt; 116 struct netconfig *nconf; 117 void *handle; 118 bool_t try_others; 119 120 /* 121 * Check if service should register over doors transport. 122 */ 123 if (__rpc_try_doors(nettype, &try_others)) { 124 if (svc_door_create(dispatch, prognum, versnum, 0) == NULL) 125 (void) syslog(LOG_ERR, 126 "svc_create: could not register over doors"); 127 else 128 num++; 129 } 130 if (!try_others) 131 return (num); 132 if ((handle = __rpc_setconf((char *)nettype)) == NULL) { 133 (void) syslog(LOG_ERR, "svc_create: unknown protocol"); 134 return (0); 135 } 136 while (nconf = __rpc_getconf(handle)) { 137 (void) mutex_lock(&xprtlist_lock); 138 for (l = _svc_xprtlist; l; l = l->next) { 139 if (strcmp(l->xprt->xp_netid, nconf->nc_netid) == 0) { 140 /* Found an old one, use it */ 141 (void) rpcb_unset(prognum, versnum, nconf); 142 if (svc_reg(l->xprt, prognum, versnum, 143 dispatch, nconf) == FALSE) 144 (void) syslog(LOG_ERR, "svc_create: " 145 "could not register prog %d vers " 146 "%d on %s", 147 prognum, versnum, nconf->nc_netid); 148 else 149 num++; 150 break; 151 } 152 } 153 (void) mutex_unlock(&xprtlist_lock); 154 if (l == NULL) { 155 /* It was not found. Now create a new one */ 156 xprt = svc_tp_create(dispatch, prognum, versnum, nconf); 157 if (xprt) { 158 if (!__svc_add_to_xlist(&_svc_xprtlist, xprt, 159 &xprtlist_lock)) { 160 (void) syslog(LOG_ERR, 161 "svc_create: no memory"); 162 return (0); 163 } 164 num++; 165 } 166 } 167 } 168 __rpc_endconf(handle); 169 /* 170 * In case of num == 0; the error messages are generated by the 171 * underlying layers; and hence not needed here. 172 */ 173 return (num); 174 } 175 176 /* 177 * The high level interface to svc_tli_create(). 178 * It tries to create a server for "nconf" and registers the service 179 * with the rpcbind. It calls svc_tli_create(); 180 */ 181 SVCXPRT * 182 svc_tp_create(void (*dispatch)(), const rpcprog_t prognum, 183 const rpcvers_t versnum, const struct netconfig *nconf) 184 { 185 SVCXPRT *xprt; 186 boolean_t anon_mlp = B_FALSE; 187 188 if (nconf == NULL) { 189 (void) syslog(LOG_ERR, "svc_tp_create: invalid netconfig " 190 "structure for prog %d vers %d", prognum, versnum); 191 return (NULL); 192 } 193 194 /* Some programs need to allocate MLP for multilevel services */ 195 if (is_system_labeled() && is_multilevel(prognum)) 196 anon_mlp = B_TRUE; 197 xprt = svc_tli_create_common(RPC_ANYFD, nconf, NULL, 0, 0, anon_mlp); 198 if (xprt == NULL) 199 return (NULL); 200 201 (void) rpcb_unset(prognum, versnum, (struct netconfig *)nconf); 202 if (svc_reg(xprt, prognum, versnum, dispatch, nconf) == FALSE) { 203 (void) syslog(LOG_ERR, 204 "svc_tp_create: Could not register prog %d vers %d on %s", 205 prognum, versnum, nconf->nc_netid); 206 SVC_DESTROY(xprt); 207 return (NULL); 208 } 209 return (xprt); 210 } 211 212 SVCXPRT * 213 svc_tli_create(const int fd, const struct netconfig *nconf, 214 const struct t_bind *bindaddr, const uint_t sendsz, const uint_t recvsz) 215 { 216 return (svc_tli_create_common(fd, nconf, bindaddr, sendsz, recvsz, 0)); 217 } 218 219 /* 220 * If fd is RPC_ANYFD, then it opens a fd for the given transport 221 * provider (nconf cannot be NULL then). If the t_state is T_UNBND and 222 * bindaddr is NON-NULL, it performs a t_bind using the bindaddr. For 223 * NULL bindadr and Connection oriented transports, the value of qlen 224 * is set arbitrarily. 225 * 226 * If sendsz or recvsz are zero, their default values are chosen. 227 */ 228 SVCXPRT * 229 svc_tli_create_common(const int ofd, const struct netconfig *nconf, 230 const struct t_bind *bindaddr, const uint_t sendsz, 231 const uint_t recvsz, boolean_t mlp_flag) 232 { 233 SVCXPRT *xprt = NULL; /* service handle */ 234 struct t_info tinfo; /* transport info */ 235 struct t_bind *tres = NULL; /* bind info */ 236 bool_t madefd = FALSE; /* whether fd opened here */ 237 int state; /* state of the transport provider */ 238 int fd = ofd; 239 240 if (fd == RPC_ANYFD) { 241 if (nconf == NULL) { 242 (void) syslog(LOG_ERR, 243 "svc_tli_create: invalid netconfig"); 244 return (NULL); 245 } 246 fd = t_open(nconf->nc_device, O_RDWR, &tinfo); 247 if (fd == -1) { 248 char errorstr[100]; 249 250 __tli_sys_strerror(errorstr, sizeof (errorstr), 251 t_errno, errno); 252 (void) syslog(LOG_ERR, "svc_tli_create: could not open " 253 "connection for %s: %s", nconf->nc_netid, errorstr); 254 return (NULL); 255 } 256 madefd = TRUE; 257 state = T_UNBND; 258 } else { 259 /* 260 * It is an open descriptor. Sync it & get the transport info. 261 */ 262 if ((state = t_sync(fd)) == -1) { 263 char errorstr[100]; 264 265 __tli_sys_strerror(errorstr, sizeof (errorstr), 266 t_errno, errno); 267 (void) syslog(LOG_ERR, 268 "svc_tli_create: could not do t_sync: %s", 269 errorstr); 270 return (NULL); 271 } 272 if (t_getinfo(fd, &tinfo) == -1) { 273 char errorstr[100]; 274 275 __tli_sys_strerror(errorstr, sizeof (errorstr), 276 t_errno, errno); 277 (void) syslog(LOG_ERR, "svc_tli_create: could not get " 278 "transport information: %s", errorstr); 279 return (NULL); 280 } 281 /* Enable options of returning the ip's for udp */ 282 if (nconf) { 283 int ret = 0; 284 if (strcmp(nconf->nc_netid, "udp6") == 0) { 285 ret = __rpc_tli_set_options(fd, IPPROTO_IPV6, 286 IPV6_RECVPKTINFO, 1); 287 if (ret < 0) { 288 char errorstr[100]; 289 290 __tli_sys_strerror(errorstr, 291 sizeof (errorstr), t_errno, errno); 292 (void) syslog(LOG_ERR, 293 "svc_tli_create: " 294 "IPV6_RECVPKTINFO(1): %s", 295 errorstr); 296 return (NULL); 297 } 298 } else if (strcmp(nconf->nc_netid, "udp") == 0) { 299 ret = __rpc_tli_set_options(fd, IPPROTO_IP, 300 IP_RECVDSTADDR, 1); 301 if (ret < 0) { 302 char errorstr[100]; 303 304 __tli_sys_strerror(errorstr, 305 sizeof (errorstr), t_errno, errno); 306 (void) syslog(LOG_ERR, 307 "svc_tli_create: " 308 "IP_RECVDSTADDR(1): %s", errorstr); 309 return (NULL); 310 } 311 } 312 } 313 } 314 315 /* 316 * If the fd is unbound, try to bind it. 317 * In any case, try to get its bound info in tres 318 */ 319 /* LINTED pointer alignment */ 320 tres = (struct t_bind *)t_alloc(fd, T_BIND, T_ADDR); 321 if (tres == NULL) { 322 (void) syslog(LOG_ERR, "svc_tli_create: No memory!"); 323 goto freedata; 324 } 325 326 switch (state) { 327 bool_t tcp, exclbind; 328 case T_UNBND: 329 /* If this is a labeled system, then ask for an MLP */ 330 if (is_system_labeled() && 331 (strcmp(nconf->nc_protofmly, NC_INET) == 0 || 332 strcmp(nconf->nc_protofmly, NC_INET6) == 0)) { 333 (void) __rpc_tli_set_options(fd, SOL_SOCKET, 334 SO_RECVUCRED, 1); 335 if (mlp_flag) 336 (void) __rpc_tli_set_options(fd, SOL_SOCKET, 337 SO_ANON_MLP, 1); 338 } 339 340 /* 341 * SO_EXCLBIND has the following properties 342 * - an fd bound to port P via IPv4 will prevent an IPv6 343 * bind to port P (and vice versa) 344 * - an fd bound to a wildcard IP address for port P will 345 * prevent a more specific IP address bind to port P 346 * (see {tcp,udp}.c for details) 347 * 348 * We use the latter property to prevent hijacking of RPC 349 * services that reside at non-privileged ports. 350 */ 351 tcp = nconf ? (strcmp(nconf->nc_proto, NC_TCP) == 0) : 0; 352 if (nconf && 353 (tcp || (strcmp(nconf->nc_proto, NC_UDP) == 0)) && 354 rpc_control(__RPC_SVC_EXCLBIND_GET, &exclbind)) { 355 if (exclbind) { 356 if (__rpc_tli_set_options(fd, SOL_SOCKET, 357 SO_EXCLBIND, 1) < 0) { 358 syslog(LOG_ERR, 359 "svc_tli_create: can't set EXCLBIND [netid='%s']", 360 nconf->nc_netid); 361 goto freedata; 362 } 363 } 364 } 365 if (bindaddr) { 366 if (t_bind(fd, (struct t_bind *)bindaddr, tres) == -1) { 367 char errorstr[100]; 368 369 __tli_sys_strerror(errorstr, sizeof (errorstr), 370 t_errno, errno); 371 (void) syslog(LOG_ERR, 372 "svc_tli_create: could not bind: %s", 373 errorstr); 374 goto freedata; 375 } 376 /* 377 * Should compare the addresses only if addr.len 378 * was non-zero 379 */ 380 if (bindaddr->addr.len && 381 (memcmp(bindaddr->addr.buf, tres->addr.buf, 382 (int)tres->addr.len) != 0)) { 383 (void) syslog(LOG_ERR, "svc_tli_create: could " 384 "not bind to requested address: address " 385 "mismatch"); 386 goto freedata; 387 } 388 } else { 389 if (rpc_control(__RPC_SVC_LSTNBKLOG_GET, &tres->qlen) 390 == FALSE) { 391 syslog(LOG_ERR, 392 "svc_tli_create: can't get listen backlog"); 393 goto freedata; 394 } 395 tres->addr.len = 0; 396 if (t_bind(fd, tres, tres) == -1) { 397 char errorstr[100]; 398 399 __tli_sys_strerror(errorstr, sizeof (errorstr), 400 t_errno, errno); 401 (void) syslog(LOG_ERR, 402 "svc_tli_create: could not bind: %s", 403 errorstr); 404 goto freedata; 405 } 406 } 407 408 /* Enable options of returning the ip's for udp */ 409 if (nconf) { 410 int ret = 0; 411 if (strcmp(nconf->nc_netid, "udp6") == 0) { 412 ret = __rpc_tli_set_options(fd, IPPROTO_IPV6, 413 IPV6_RECVPKTINFO, 1); 414 if (ret < 0) { 415 char errorstr[100]; 416 417 __tli_sys_strerror(errorstr, 418 sizeof (errorstr), t_errno, errno); 419 (void) syslog(LOG_ERR, 420 "svc_tli_create: " 421 "IPV6_RECVPKTINFO(2): %s", 422 errorstr); 423 goto freedata; 424 } 425 } else if (strcmp(nconf->nc_netid, "udp") == 0) { 426 ret = __rpc_tli_set_options(fd, IPPROTO_IP, 427 IP_RECVDSTADDR, 1); 428 if (ret < 0) { 429 char errorstr[100]; 430 431 __tli_sys_strerror(errorstr, 432 sizeof (errorstr), t_errno, errno); 433 (void) syslog(LOG_ERR, 434 "svc_tli_create: " 435 "IP_RECVDSTADDR(2): %s", errorstr); 436 goto freedata; 437 } 438 } 439 } 440 break; 441 442 case T_IDLE: 443 if (bindaddr) { 444 /* Copy the entire stuff in tres */ 445 if (tres->addr.maxlen < bindaddr->addr.len) { 446 (void) syslog(LOG_ERR, 447 "svc_tli_create: illegal netbuf length"); 448 goto freedata; 449 } 450 tres->addr.len = bindaddr->addr.len; 451 (void) memcpy(tres->addr.buf, bindaddr->addr.buf, 452 (int)tres->addr.len); 453 } else 454 if (t_getname(fd, &(tres->addr), LOCALNAME) == -1) 455 tres->addr.len = 0; 456 break; 457 case T_INREL: 458 (void) t_rcvrel(fd); 459 (void) t_sndrel(fd); 460 (void) syslog(LOG_ERR, "svc_tli_create: other side wants to " 461 "release connection"); 462 goto freedata; 463 464 case T_INCON: 465 /* Do nothing here. Assume this is handled in rendezvous */ 466 break; 467 case T_DATAXFER: 468 /* 469 * This takes care of the case where a fd 470 * is passed on which a connection has already 471 * been accepted. 472 */ 473 if (t_getname(fd, &(tres->addr), LOCALNAME) == -1) 474 tres->addr.len = 0; 475 break; 476 default: 477 (void) syslog(LOG_ERR, 478 "svc_tli_create: connection in a wierd state (%d)", state); 479 goto freedata; 480 } 481 482 /* 483 * call transport specific function. 484 */ 485 switch (tinfo.servtype) { 486 case T_COTS_ORD: 487 case T_COTS: 488 if (state == T_DATAXFER) 489 xprt = svc_fd_create_private(fd, sendsz, 490 recvsz); 491 else 492 xprt = svc_vc_create_private(fd, sendsz, 493 recvsz); 494 if (!nconf || !xprt) 495 break; 496 if ((tinfo.servtype == T_COTS_ORD) && 497 (state != T_DATAXFER) && 498 (strcmp(nconf->nc_protofmly, "inet") == 0)) 499 (void) __svc_vc_setflag(xprt, TRUE); 500 break; 501 case T_CLTS: 502 xprt = svc_dg_create_private(fd, sendsz, recvsz); 503 break; 504 default: 505 (void) syslog(LOG_ERR, 506 "svc_tli_create: bad service type"); 507 goto freedata; 508 } 509 if (xprt == NULL) 510 /* 511 * The error messages here are spitted out by the lower layers: 512 * svc_vc_create(), svc_fd_create() and svc_dg_create(). 513 */ 514 goto freedata; 515 516 /* fill in the other xprt information */ 517 518 /* Assign the local bind address */ 519 xprt->xp_ltaddr = tres->addr; 520 /* Fill in type of service */ 521 xprt->xp_type = tinfo.servtype; 522 tres->addr.buf = NULL; 523 (void) t_free((char *)tres, T_BIND); 524 tres = NULL; 525 526 xprt->xp_rtaddr.len = 0; 527 xprt->xp_rtaddr.maxlen = __rpc_get_a_size(tinfo.addr); 528 529 /* Allocate space for the remote bind info */ 530 if ((xprt->xp_rtaddr.buf = malloc(xprt->xp_rtaddr.maxlen)) == NULL) { 531 (void) syslog(LOG_ERR, "svc_tli_create: No memory!"); 532 goto freedata; 533 } 534 535 if (nconf) { 536 xprt->xp_netid = strdup(nconf->nc_netid); 537 if (xprt->xp_netid == NULL) { 538 if (xprt->xp_rtaddr.buf) 539 free(xprt->xp_rtaddr.buf); 540 syslog(LOG_ERR, "svc_tli_create: strdup failed!"); 541 goto freedata; 542 } 543 xprt->xp_tp = strdup(nconf->nc_device); 544 if (xprt->xp_tp == NULL) { 545 if (xprt->xp_rtaddr.buf) 546 free(xprt->xp_rtaddr.buf); 547 if (xprt->xp_netid) 548 free(xprt->xp_netid); 549 syslog(LOG_ERR, "svc_tli_create: strdup failed!"); 550 goto freedata; 551 } 552 } 553 554 /* 555 * if (madefd && (tinfo.servtype == T_CLTS)) 556 * (void) ioctl(fd, I_POP, NULL); 557 */ 558 xprt_register(xprt); 559 return (xprt); 560 561 freedata: 562 if (madefd) 563 (void) t_close(fd); 564 if (tres) 565 (void) t_free((char *)tres, T_BIND); 566 if (xprt) { 567 if (!madefd) /* so that svc_destroy doesnt close fd */ 568 xprt->xp_fd = RPC_ANYFD; 569 SVC_DESTROY(xprt); 570 } 571 return (NULL); 572 } 573