1 /*- 2 * SPDX-License-Identifier: BSD-4-Clause 3 * 4 * Copyright (c) 1995 5 * A.R. Gordon (andrew.gordon@net-tel.co.uk). All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed for the FreeBSD project 18 * 4. Neither the name of the author nor the names of any co-contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY ANDREW GORDON AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 */ 35 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 #include <errno.h> 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <string.h> 43 #include <unistd.h> 44 #include <rpc/rpc.h> 45 #include <syslog.h> 46 #include <vis.h> 47 #include <netdb.h> /* for getaddrinfo() */ 48 #include <sys/types.h> 49 #include <sys/socket.h> 50 #include <netinet/in.h> 51 #include <arpa/inet.h> 52 53 #include "statd.h" 54 55 static const char * 56 from_addr(saddr) 57 struct sockaddr *saddr; 58 { 59 static char inet_buf[INET6_ADDRSTRLEN]; 60 61 if (getnameinfo(saddr, saddr->sa_len, inet_buf, sizeof(inet_buf), 62 NULL, 0, NI_NUMERICHOST) == 0) 63 return inet_buf; 64 return "???"; 65 } 66 67 /* sm_check_hostname -------------------------------------------------------- */ 68 /* 69 * Purpose: Check `mon_name' member of sm_name struct to ensure that the array 70 * consists only of printable characters. 71 * 72 * Returns: TRUE if hostname is good. FALSE if hostname contains binary or 73 * otherwise non-printable characters. 74 * 75 * Notes: Will syslog(3) to warn of corrupt hostname. 76 */ 77 78 int sm_check_hostname(struct svc_req *req, char *arg) 79 { 80 int len, dstlen, ret; 81 struct sockaddr *claddr; 82 char *dst; 83 84 len = strlen(arg); 85 dstlen = (4 * len) + 1; 86 dst = malloc(dstlen); 87 claddr = (struct sockaddr *) (svc_getrpccaller(req->rq_xprt)->buf) ; 88 ret = 1; 89 90 if (claddr == NULL || dst == NULL) 91 { 92 ret = 0; 93 } 94 else if (strvis(dst, arg, VIS_WHITE) != len) 95 { 96 syslog(LOG_ERR, 97 "sm_stat: client %s hostname %s contained invalid characters.", 98 from_addr(claddr), 99 dst); 100 ret = 0; 101 } 102 free(dst); 103 return (ret); 104 } 105 106 /* sm_stat_1 --------------------------------------------------------------- */ 107 /* 108 Purpose: RPC call to enquire if a host can be monitored 109 Returns: TRUE for any hostname that can be looked up to give 110 an address. 111 */ 112 113 struct sm_stat_res *sm_stat_1_svc(sm_name *arg, struct svc_req *req) 114 { 115 static sm_stat_res res; 116 struct addrinfo *ai; 117 struct sockaddr *claddr; 118 static int err; 119 120 err = 1; 121 if ((err = sm_check_hostname(req, arg->mon_name)) == 0) 122 { 123 res.res_stat = stat_fail; 124 } 125 if (err != 0) 126 { 127 if (debug) 128 syslog(LOG_DEBUG, "stat called for host %s", arg->mon_name); 129 if (getaddrinfo(arg->mon_name, NULL, NULL, &ai) == 0) { 130 res.res_stat = stat_succ; 131 freeaddrinfo(ai); 132 } 133 else 134 { 135 claddr = (struct sockaddr *) (svc_getrpccaller(req->rq_xprt)->buf) ; 136 syslog(LOG_ERR, "invalid hostname to sm_stat from %s: %s", 137 from_addr(claddr), arg->mon_name); 138 res.res_stat = stat_fail; 139 } 140 } 141 res.state = status_info->ourState; 142 return (&res); 143 } 144 145 /* sm_mon_1 ---------------------------------------------------------------- */ 146 /* 147 Purpose: RPC procedure to establish a monitor request 148 Returns: Success, unless lack of resources prevents 149 the necessary structures from being set up 150 to record the request, or if the hostname is not 151 valid (as judged by getaddrinfo()) 152 */ 153 154 struct sm_stat_res *sm_mon_1_svc(mon *arg, struct svc_req *req) 155 { 156 static sm_stat_res res; 157 HostInfo *hp; 158 static int err; 159 MonList *lp; 160 struct addrinfo *ai; 161 162 if ((err = sm_check_hostname(req, arg->mon_id.mon_name)) == 0) 163 { 164 res.res_stat = stat_fail; 165 } 166 167 if (err != 0) 168 { 169 if (debug) 170 { 171 syslog(LOG_DEBUG, "monitor request for host %s", arg->mon_id.mon_name); 172 syslog(LOG_DEBUG, "recall host: %s prog: %d ver: %d proc: %d", 173 arg->mon_id.my_id.my_name, 174 arg->mon_id.my_id.my_prog, 175 arg->mon_id.my_id.my_vers, 176 arg->mon_id.my_id.my_proc); 177 } 178 res.res_stat = stat_fail; /* Assume fail until set otherwise */ 179 res.state = status_info->ourState; 180 181 /* Find existing host entry, or create one if not found */ 182 /* If find_host() fails, it will have logged the error already. */ 183 if (getaddrinfo(arg->mon_id.mon_name, NULL, NULL, &ai) != 0) 184 { 185 syslog(LOG_ERR, "Invalid hostname to sm_mon: %s", arg->mon_id.mon_name); 186 return (&res); 187 } 188 freeaddrinfo(ai); 189 if ((hp = find_host(arg->mon_id.mon_name, TRUE))) 190 { 191 lp = (MonList *)malloc(sizeof(MonList)); 192 if (!lp) 193 { 194 syslog(LOG_ERR, "Out of memory"); 195 } 196 else 197 { 198 strncpy(lp->notifyHost, arg->mon_id.my_id.my_name, SM_MAXSTRLEN); 199 lp->notifyProg = arg->mon_id.my_id.my_prog; 200 lp->notifyVers = arg->mon_id.my_id.my_vers; 201 lp->notifyProc = arg->mon_id.my_id.my_proc; 202 memcpy(lp->notifyData, arg->priv, sizeof(lp->notifyData)); 203 204 lp->next = hp->monList; 205 hp->monList = lp; 206 sync_file(); 207 208 res.res_stat = stat_succ; /* Report success */ 209 } 210 } 211 } 212 return (&res); 213 } 214 215 /* do_unmon ---------------------------------------------------------------- */ 216 /* 217 Purpose: Remove a monitor request from a host 218 Returns: TRUE if found, FALSE if not found. 219 Notes: Common code from sm_unmon_1_svc and sm_unmon_all_1_svc 220 In the unlikely event of more than one identical monitor 221 request, all are removed. 222 */ 223 224 static int do_unmon(HostInfo *hp, my_id *idp) 225 { 226 MonList *lp, *next; 227 MonList *last = NULL; 228 int result = FALSE; 229 230 lp = hp->monList; 231 while (lp) 232 { 233 if (!strncasecmp(idp->my_name, lp->notifyHost, SM_MAXSTRLEN) 234 && (idp->my_prog == lp->notifyProg) && (idp->my_proc == lp->notifyProc) 235 && (idp->my_vers == lp->notifyVers)) 236 { 237 /* found one. Unhook from chain and free. */ 238 next = lp->next; 239 if (last) last->next = next; 240 else hp->monList = next; 241 free(lp); 242 lp = next; 243 result = TRUE; 244 } 245 else 246 { 247 last = lp; 248 lp = lp->next; 249 } 250 } 251 return (result); 252 } 253 254 /* sm_unmon_1 -------------------------------------------------------------- */ 255 /* 256 Purpose: RPC procedure to release a monitor request. 257 Returns: Local machine's status number 258 Notes: The supplied mon_id should match the value passed in an 259 earlier call to sm_mon_1 260 */ 261 262 struct sm_stat *sm_unmon_1_svc(mon_id *arg, struct svc_req *req __unused) 263 { 264 static sm_stat res; 265 HostInfo *hp; 266 267 if (debug) 268 { 269 syslog(LOG_DEBUG, "un-monitor request for host %s", arg->mon_name); 270 syslog(LOG_DEBUG, "recall host: %s prog: %d ver: %d proc: %d", 271 arg->mon_name, 272 arg->my_id.my_prog, arg->my_id.my_vers, arg->my_id.my_proc); 273 } 274 275 if ((hp = find_host(arg->mon_name, FALSE))) 276 { 277 if (do_unmon(hp, &arg->my_id)) sync_file(); 278 else 279 { 280 syslog(LOG_ERR, "unmon request from %s, no matching monitor", 281 arg->my_id.my_name); 282 } 283 } 284 else syslog(LOG_ERR, "unmon request from %s for unknown host %s", 285 arg->my_id.my_name, arg->mon_name); 286 287 res.state = status_info->ourState; 288 289 return (&res); 290 } 291 292 /* sm_unmon_all_1 ---------------------------------------------------------- */ 293 /* 294 Purpose: RPC procedure to release monitor requests. 295 Returns: Local machine's status number 296 Notes: Releases all monitor requests (if any) from the specified 297 host and program number. 298 */ 299 300 struct sm_stat *sm_unmon_all_1_svc(my_id *arg, struct svc_req *req __unused) 301 { 302 static sm_stat res; 303 HostInfo *hp; 304 int i; 305 306 if (debug) 307 { 308 syslog(LOG_DEBUG, "unmon_all for host: %s prog: %d ver: %d proc: %d", 309 arg->my_name, arg->my_prog, arg->my_vers, arg->my_proc); 310 } 311 312 for (i = status_info->noOfHosts, hp = status_info->hosts; i; i--, hp++) 313 { 314 do_unmon(hp, arg); 315 } 316 sync_file(); 317 318 res.state = status_info->ourState; 319 320 return (&res); 321 } 322 323 /* sm_simu_crash_1 --------------------------------------------------------- */ 324 /* 325 Purpose: RPC procedure to simulate a crash 326 Returns: Nothing 327 Notes: Standardised mechanism for debug purposes 328 The specification says that we should drop all of our 329 status information (apart from the list of monitored hosts 330 on disc). However, this would confuse the rpc.lockd 331 which would be unaware that all of its monitor requests 332 had been silently junked. Hence we in fact retain all 333 current requests and simply increment the status counter 334 and inform all hosts on the monitor list. 335 */ 336 337 void *sm_simu_crash_1_svc(void *v __unused, struct svc_req *req __unused) 338 { 339 static char dummy; 340 int work_to_do; 341 HostInfo *hp; 342 int i; 343 344 work_to_do = FALSE; 345 if (debug) syslog(LOG_DEBUG, "simu_crash called!!"); 346 347 /* Simulate crash by setting notify-required flag on all monitored */ 348 /* hosts, and incrementing our status number. notify_hosts() is */ 349 /* then called to fork a process to do the notifications. */ 350 351 for (i = status_info->noOfHosts, hp = status_info->hosts; i ; i--, hp++) 352 { 353 if (hp->monList) 354 { 355 work_to_do = TRUE; 356 hp->notifyReqd = TRUE; 357 } 358 } 359 status_info->ourState += 2; /* always even numbers if not crashed */ 360 361 if (work_to_do) notify_hosts(); 362 363 return (&dummy); 364 } 365 366 /* sm_notify_1 ------------------------------------------------------------- */ 367 /* 368 Purpose: RPC procedure notifying local statd of the crash of another 369 Returns: Nothing 370 Notes: There is danger of deadlock, since it is quite likely that 371 the client procedure that we call will in turn call us 372 to remove or adjust the monitor request. 373 We therefore fork() a process to do the notifications. 374 Note that the main HostInfo structure is in a mmap() 375 region and so will be shared with the child, but the 376 monList pointed to by the HostInfo is in normal memory. 377 Hence if we read the monList before forking, we are 378 protected from the parent servicing other requests 379 that modify the list. 380 */ 381 382 void *sm_notify_1_svc(stat_chge *arg, struct svc_req *req __unused) 383 { 384 struct timeval timeout = { 20, 0 }; /* 20 secs timeout */ 385 CLIENT *cli; 386 static char dummy; 387 sm_status tx_arg; /* arg sent to callback procedure */ 388 MonList *lp; 389 HostInfo *hp; 390 pid_t pid; 391 392 if (debug) syslog(LOG_DEBUG, "notify from host %s, new state %d", 393 arg->mon_name, arg->state); 394 395 hp = find_host(arg->mon_name, FALSE); 396 if (!hp) 397 { 398 /* Never heard of this host - why is it notifying us? */ 399 syslog(LOG_ERR, "Unsolicited notification from host %s", arg->mon_name); 400 return (&dummy); 401 } 402 lp = hp->monList; 403 if (!lp) return (&dummy); /* We know this host, but have no */ 404 /* outstanding requests. */ 405 pid = fork(); 406 if (pid == -1) 407 { 408 syslog(LOG_ERR, "Unable to fork notify process - %s", strerror(errno)); 409 return (NULL); /* no answer, the client will retry */ 410 } 411 if (pid) return (&dummy); /* Parent returns */ 412 413 while (lp) 414 { 415 tx_arg.mon_name = arg->mon_name; 416 tx_arg.state = arg->state; 417 memcpy(tx_arg.priv, lp->notifyData, sizeof(tx_arg.priv)); 418 cli = clnt_create(lp->notifyHost, lp->notifyProg, lp->notifyVers, "udp"); 419 if (!cli) 420 { 421 syslog(LOG_ERR, "Failed to contact host %s%s", lp->notifyHost, 422 clnt_spcreateerror("")); 423 } 424 else 425 { 426 if (clnt_call(cli, lp->notifyProc, (xdrproc_t)xdr_sm_status, &tx_arg, 427 (xdrproc_t)xdr_void, &dummy, timeout) != RPC_SUCCESS) 428 { 429 syslog(LOG_ERR, "Failed to call rpc.statd client at host %s", 430 lp->notifyHost); 431 } 432 clnt_destroy(cli); 433 } 434 lp = lp->next; 435 } 436 437 exit (0); /* Child quits */ 438 } 439