1/* 2 * Copyright (c) 2005 3 * Hartmut Brandt. 4 * All rights reserved. 5 * 6 * Author: Harti Brandt <harti@freebsd.org> 7 * 8 * Redistribution of this software and documentation and use in source and 9 * binary forms, with or without modification, are permitted provided that 10 * the following conditions are met: 11 * 12 * 1. Redistributions of source code or documentation must retain the above 13 * copyright notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY FRAUNHOFER FOKUS 19 * AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 21 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 22 * FRAUNHOFER FOKUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 25 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 26 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 27 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 28 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 * 30 * $Begemot: bsnmp/snmp_ntp/snmp_ntp.c,v 1.9 2005/10/06 07:15:01 brandt_h Exp $ 31 * 32 * NTP interface for SNMPd. 33 */ 34 35#include <sys/queue.h> 36#include <sys/time.h> 37#include <sys/types.h> 38#include <sys/select.h> 39#include <sys/socket.h> 40#include <ctype.h> 41#include <errno.h> 42#include <netdb.h> 43#ifdef HAVE_STDINT_H 44#include <stdint.h> 45#elif defined(HAVE_INTTYPES_H) 46#include <inttypes.h> 47#endif 48#include <stdio.h> 49#include <stdlib.h> 50#include <string.h> 51#include <syslog.h> 52#include <unistd.h> 53 54#include "support.h" 55#include "snmpmod.h" 56#include "ntp_tree.h" 57#include "ntp_oid.h" 58 59#define NTPC_MAX 576 60#define NTPC_VERSION 3 61#define NTPC_MODE 6 62#define NTPC_DMAX 468 63 64#define NTPC_BIT_RESP 0x80 65#define NTPC_BIT_ERROR 0x40 66#define NTPC_BIT_MORE 0x20 67 68#define NTPC_OPMASK 0x1f 69#define NTPC_OP_READSTAT 1 70#define NTPC_OP_READVAR 2 71 72/* our module handle */ 73static struct lmodule *module; 74 75/* debug flag */ 76static uint32_t ntp_debug; 77#define DBG_DUMP_PKTS 0x01 78#define DBG_DUMP_VARS 0x02 79 80/* OIDs */ 81static const struct asn_oid oid_ntpMIB = OIDX_ntpMIB; 82 83/* the Object Resource registration index */ 84static u_int reg_index; 85 86/* last time we've fetch the system variables */ 87static uint64_t sysinfo_tick; 88 89/* cached system variables */ 90static int32_t sys_leap; 91static int sysb_leap; 92static int32_t sys_stratum; 93static int sysb_stratum; 94static int32_t sys_precision; 95static int sysb_precision; 96static char *sys_rootdelay; 97static char *sys_rootdispersion; 98static char *sys_refid; 99static char sys_reftime[8]; 100static int sysb_reftime; 101static int32_t sys_poll; 102static int sysb_poll; 103static uint32_t sys_peer; 104static int sysb_peer; 105static u_char sys_clock[8]; 106static int sysb_clock; 107static char *sys_system; 108static char *sys_processor; 109static int sysb_jitter; 110static double sys_jitter; 111static int sysb_stability; 112static double sys_stability; 113 114/* last time we've fetch the peer list */ 115static uint64_t peers_tick; 116 117/* request sequence number generator */ 118static uint16_t seqno; 119 120/* NTPD socket */ 121static int ntpd_sock; 122static void *ntpd_fd; 123 124struct peer { 125 /* required entries for macros */ 126 uint32_t index; 127 TAILQ_ENTRY(peer) link; 128 129 int32_t config; /* config bit */ 130 u_char srcadr[4]; /* PeerAddress */ 131 uint32_t srcport; /* PeerPort */ 132 u_char dstadr[4]; /* HostAddress */ 133 uint32_t dstport; /* HostPort */ 134 int32_t leap; /* Leap */ 135 int32_t hmode; /* Mode */ 136 int32_t stratum; /* Stratum */ 137 int32_t ppoll; /* PeerPoll */ 138 int32_t hpoll; /* HostPoll */ 139 int32_t precision; /* Precision */ 140 char *rootdelay; /* RootDelay */ 141 char *rootdispersion;/* RootDispersion */ 142 char *refid; /* RefId */ 143 u_char reftime[8]; /* RefTime */ 144 u_char orgtime[8]; /* OrgTime */ 145 u_char rcvtime[8]; /* ReceiveTime */ 146 u_char xmttime[8]; /* TransmitTime */ 147 u_int32_t reach; /* Reach */ 148 int32_t timer; /* Timer */ 149 char *offset; /* Offset */ 150 char *delay; /* Delay */ 151 char *dispersion; /* Dispersion */ 152 int32_t filt_entries; 153}; 154TAILQ_HEAD(peer_list, peer); 155 156/* list of peers */ 157static struct peer_list peers = TAILQ_HEAD_INITIALIZER(peers); 158 159struct filt { 160 /* required fields */ 161 struct asn_oid index; 162 TAILQ_ENTRY(filt) link; 163 164 char *offset; 165 char *delay; 166 char *dispersion; 167}; 168TAILQ_HEAD(filt_list, filt); 169 170/* list of filters */ 171static struct filt_list filts = TAILQ_HEAD_INITIALIZER(filts); 172 173/* configuration */ 174static u_char *ntp_host; 175static u_char *ntp_port; 176static uint32_t ntp_timeout; 177 178static void ntpd_input(int, void *); 179static int open_socket(void); 180 181/* the initialization function */ 182static int 183ntp_init(struct lmodule *mod, int argc, char *argv[] __unused) 184{ 185 186 module = mod; 187 188 if (argc != 0) { 189 syslog(LOG_ERR, "bad number of arguments for %s", __func__); 190 return (EINVAL); 191 } 192 193 ntp_host = strdup("localhost"); 194 ntp_port = strdup("ntp"); 195 ntp_timeout = 50; /* 0.5sec */ 196 197 return (0); 198} 199 200/* 201 * Module is started 202 */ 203static void 204ntp_start(void) 205{ 206 207 if (open_socket() != -1) { 208 ntpd_fd = fd_select(ntpd_sock, ntpd_input, NULL, module); 209 if (ntpd_fd == NULL) { 210 syslog(LOG_ERR, "fd_select failed on ntpd socket: %m"); 211 return; 212 } 213 } 214 reg_index = or_register(&oid_ntpMIB, "The MIB for NTP.", module); 215} 216 217/* 218 * Called, when the module is to be unloaded after it was successfully loaded 219 */ 220static int 221ntp_fini(void) 222{ 223 224 or_unregister(reg_index); 225 fd_deselect(ntpd_fd); 226 227 return (0); 228} 229 230const struct snmp_module config = { 231 .comment = "This module implements the NTP MIB", 232 .init = ntp_init, 233 .start = ntp_start, 234 .fini = ntp_fini, 235 .tree = ntp_ctree, 236 .tree_size = ntp_CTREE_SIZE, 237}; 238 239/* 240 * Open the NTPD socket 241 */ 242static int 243open_socket(void) 244{ 245 struct addrinfo hints, *res, *res0; 246 int error; 247 const char *cause; 248 249 memset(&hints, 0, sizeof(hints)); 250 hints.ai_family = AF_INET; 251 hints.ai_socktype = SOCK_DGRAM; 252 253 error = getaddrinfo(ntp_host, ntp_port, &hints, &res0); 254 if (error) { 255 syslog(LOG_ERR, "%s(%s): %s", ntp_host, ntp_port, 256 gai_strerror(error)); 257 return (-1); 258 } 259 260 ntpd_sock = -1; 261 cause = "no address"; 262 errno = EADDRNOTAVAIL; 263 for (res = res0; res != NULL; res = res->ai_next) { 264 ntpd_sock = socket(res->ai_family, res->ai_socktype, 265 res->ai_protocol); 266 if (ntpd_sock == -1) { 267 cause = "socket"; 268 continue; 269 } 270 if (connect(ntpd_sock, res->ai_addr, res->ai_addrlen) == -1) { 271 cause = "connect"; 272 (void)close(ntpd_sock); 273 ntpd_sock = -1; 274 continue; 275 } 276 break; 277 } 278 if (ntpd_sock == -1) { 279 syslog(LOG_ERR, "%s: %m", cause); 280 return (-1); 281 } 282 freeaddrinfo(res0); 283 return (0); 284} 285 286/* 287 * Dump a packet 288 */ 289static void 290dump_packet(const u_char *pkt, size_t ret) 291{ 292 char buf[8 * 3 + 1]; 293 size_t i, j; 294 295 for (i = 0; i < ret; i += 8) { 296 buf[0] = '\0'; 297 for (j = 0; i + j < (size_t)ret && j < 8; j++) 298 sprintf(buf + strlen(buf), " %02x", pkt[i + j]); 299 syslog(LOG_INFO, "%04zu:%s", i, buf); 300 } 301} 302 303/* 304 * Execute an NTP request. 305 */ 306static int 307ntpd_request(u_int op, u_int associd, const char *vars) 308{ 309 u_char *rpkt; 310 u_char *ptr; 311 size_t vlen; 312 ssize_t ret; 313 314 if ((rpkt = malloc(NTPC_MAX)) == NULL) { 315 syslog(LOG_ERR, "%m"); 316 return (-1); 317 } 318 memset(rpkt, 0, NTPC_MAX); 319 320 ptr = rpkt; 321 *ptr++ = (NTPC_VERSION << 3) | NTPC_MODE; 322 *ptr++ = op; 323 324 if (++seqno == 0) 325 seqno++; 326 *ptr++ = seqno >> 8; 327 *ptr++ = seqno; 328 329 /* skip status */ 330 ptr += 2; 331 332 *ptr++ = associd >> 8; 333 *ptr++ = associd; 334 335 /* skip offset */ 336 ptr += 2; 337 338 if (vars != NULL) { 339 vlen = strlen(vars); 340 if (vlen > NTPC_DMAX) { 341 syslog(LOG_ERR, "NTP request too long (%zu)", vlen); 342 free(rpkt); 343 return (-1); 344 } 345 *ptr++ = vlen >> 8; 346 *ptr++ = vlen; 347 348 memcpy(ptr, vars, vlen); 349 ptr += vlen; 350 } else 351 /* skip data length (is already zero) */ 352 ptr += 2; 353 354 while ((ptr - rpkt) % 4 != 0) 355 *ptr++ = 0; 356 357 if (ntp_debug & DBG_DUMP_PKTS) { 358 syslog(LOG_INFO, "sending %zd bytes", ptr - rpkt); 359 dump_packet(rpkt, ptr - rpkt); 360 } 361 362 ret = send(ntpd_sock, rpkt, ptr - rpkt, 0); 363 if (ret == -1) { 364 syslog(LOG_ERR, "cannot send to ntpd: %m"); 365 free(rpkt); 366 return (-1); 367 } 368 return (0); 369} 370 371/* 372 * Callback if packet arrived from NTPD 373 */ 374static int 375ntpd_read(uint16_t *op, uint16_t *associd, u_char **data, size_t *datalen) 376{ 377 u_char pkt[NTPC_MAX + 1]; 378 u_char *ptr, *nptr; 379 u_int n; 380 ssize_t ret; 381 size_t z; 382 u_int offset; /* current offset */ 383 int more; /* more flag */ 384 int sel; 385 struct timeval inc, end, rem; 386 fd_set iset; 387 388 *datalen = 0; 389 *data = NULL; 390 offset = 0; 391 392 inc.tv_sec = ntp_timeout / 100; 393 inc.tv_usec = (ntp_timeout % 100) * 1000; 394 395 (void)gettimeofday(&end, NULL); 396 timeradd(&end, &inc, &end); 397 398 next: 399 /* compute remaining time */ 400 (void)gettimeofday(&rem, NULL); 401 if (timercmp(&rem, &end, >=)) { 402 /* do a poll */ 403 rem.tv_sec = 0; 404 rem.tv_usec = 0; 405 } else { 406 timersub(&end, &rem, &rem); 407 } 408 409 /* select */ 410 FD_ZERO(&iset); 411 FD_SET(ntpd_sock, &iset); 412 sel = select(ntpd_sock + 1, &iset, NULL, NULL, &rem); 413 if (sel == -1) { 414 if (errno == EINTR) 415 goto next; 416 syslog(LOG_ERR, "select ntpd_sock: %m"); 417 free(*data); 418 return (-1); 419 } 420 if (sel == 0) { 421 syslog(LOG_ERR, "timeout on NTP connection"); 422 free(*data); 423 return (-1); 424 } 425 426 /* now read it */ 427 ret = recv(ntpd_sock, pkt, sizeof(pkt), 0); 428 if (ret == -1) { 429 syslog(LOG_ERR, "error reading from ntpd: %m"); 430 free(*data); 431 return (-1); 432 } 433 434 if (ntp_debug & DBG_DUMP_PKTS) { 435 syslog(LOG_INFO, "got %zd bytes", ret); 436 dump_packet(pkt, (size_t)ret); 437 } 438 439 ptr = pkt; 440 if ((*ptr & 0x3f) != ((NTPC_VERSION << 3) | NTPC_MODE)) { 441 syslog(LOG_ERR, "unexpected packet version 0x%x", *ptr); 442 free(*data); 443 return (-1); 444 } 445 ptr++; 446 447 if (!(*ptr & NTPC_BIT_RESP)) { 448 syslog(LOG_ERR, "not a response packet"); 449 return (-1); 450 } 451 if (*ptr & NTPC_BIT_ERROR) { 452 z = *datalen - 12; 453 if (z > NTPC_DMAX) 454 z = NTPC_DMAX; 455 syslog(LOG_ERR, "error response: %.*s", (int)z, pkt + 12); 456 free(*data); 457 return (-1); 458 } 459 more = (*ptr & NTPC_BIT_MORE); 460 461 *op = *ptr++ & NTPC_OPMASK; 462 463 /* seqno */ 464 n = *ptr++ << 8; 465 n |= *ptr++; 466 467 if (n != seqno) { 468 syslog(LOG_ERR, "expecting seqno %u, got %u", seqno, n); 469 free(*data); 470 return (-1); 471 } 472 473 /* status */ 474 n = *ptr++ << 8; 475 n |= *ptr++; 476 477 /* associd */ 478 *associd = *ptr++ << 8; 479 *associd |= *ptr++; 480 481 /* offset */ 482 n = *ptr++ << 8; 483 n |= *ptr++; 484 485 if (n != offset) { 486 syslog(LOG_ERR, "offset: expecting %u, got %u", offset, n); 487 free(*data); 488 return (-1); 489 } 490 491 /* count */ 492 n = *ptr++ << 8; 493 n |= *ptr++; 494 495 if ((size_t)ret < 12 + n) { 496 syslog(LOG_ERR, "packet too short"); 497 return (-1); 498 } 499 500 nptr = realloc(*data, *datalen + n); 501 if (nptr == NULL) { 502 syslog(LOG_ERR, "cannot allocate memory: %m"); 503 free(*data); 504 return (-1); 505 } 506 *data = nptr; 507 508 memcpy(*data + offset, ptr, n); 509 *datalen += n; 510 511 if (!more) 512 return (0); 513 514 offset += n; 515 goto next; 516} 517 518/* 519 * Send a request and wait for the response 520 */ 521static int 522ntpd_dialog(u_int op, u_int associd, const char *vars, u_char **data, 523 size_t *datalen) 524{ 525 uint16_t rassocid; 526 uint16_t rop; 527 528 if (ntpd_request(op, associd, vars) == -1) 529 return (-1); 530 if (ntpd_read(&rop, &rassocid, data, datalen) == -1) 531 return (-1); 532 533 if (rop != op) { 534 syslog(LOG_ERR, "bad response op 0x%x", rop); 535 free(data); 536 return (-1); 537 } 538 539 if (associd != rassocid) { 540 syslog(LOG_ERR, "response for wrong associd"); 541 free(data); 542 return (-1); 543 } 544 return (0); 545} 546 547/* 548 * Callback if packet arrived from NTPD 549 */ 550static void 551ntpd_input(int fd __unused, void *arg __unused) 552{ 553 uint16_t associd; 554 uint16_t op; 555 u_char *data; 556 size_t datalen; 557 558 if (ntpd_read(&op, &associd, &data, &datalen) == -1) 559 return; 560 561 free(data); 562} 563 564/* 565 * Find the value of a variable 566 */ 567static int 568ntpd_parse(u_char **data, size_t *datalen, char **namep, char **valp) 569{ 570 u_char *ptr = *data; 571 u_char *end = ptr + *datalen; 572 char *ptr1; 573 char endc; 574 575 /* skip leading spaces */ 576 while (ptr < end && isspace((int)*ptr)) 577 ptr++; 578 579 if (ptr == end) 580 return (0); 581 582 *namep = ptr; 583 584 /* skip to space or '=' or ','*/ 585 while (ptr < end && !isspace((int)*ptr) && *ptr != '=' && *ptr != ',') 586 ptr++; 587 endc = *ptr; 588 *ptr++ = '\0'; 589 590 /* skip space */ 591 while (ptr < end && isspace((int)*ptr)) 592 ptr++; 593 594 if (ptr == end || endc == ',') { 595 /* no value */ 596 *valp = NULL; 597 *datalen -= ptr - *data; 598 *data = ptr; 599 return (1); 600 } 601 602 if (*ptr == '"') { 603 /* quoted */ 604 ptr++; 605 *valp = ptr; 606 while (ptr < end && *ptr != '"') 607 ptr++; 608 if (ptr == end) 609 return (0); 610 611 *ptr++ = '\0'; 612 613 /* find comma */ 614 while (ptr < end && isspace((int)*ptr) && *ptr == ',') 615 ptr++; 616 } else { 617 *valp = ptr; 618 619 /* skip to end of value */ 620 while (ptr < end && *ptr != ',') 621 ptr++; 622 623 /* remove trailing blanks */ 624 for (ptr1 = ptr; ptr1 > *valp; ptr1--) 625 if (!isspace((int)ptr1[-1])) 626 break; 627 *ptr1 = '\0'; 628 629 if (ptr < end) 630 ptr++; 631 } 632 633 *datalen -= ptr - *data; 634 *data = ptr; 635 636 return (1); 637} 638 639/* 640 * Parse an int32 value 641 */ 642static int 643val_parse_int32(const char *val, int32_t *p, int32_t min, int32_t max, int base) 644{ 645 long n; 646 char *end; 647 648 errno = 0; 649 n = strtol(val, &end, base); 650 if (errno != 0 || *end != '\0') 651 return (0); 652 if (n < min || n > max) 653 return (0); 654 *p = (int32_t)n; 655 return (1); 656} 657 658/* 659 * Parse an uint32 value 660 */ 661static int 662val_parse_uint32(const char *val, uint32_t *p, uint32_t min, uint32_t max, 663 int base) 664{ 665 u_long n; 666 char *end; 667 668 errno = 0; 669 n = strtoul(val, &end, base); 670 if (errno != 0 || *end != '\0') 671 return (0); 672 if (n < min || n > max) 673 return (0); 674 *p = (uint32_t)n; 675 return (1); 676} 677 678/* 679 * Parse a double 680 */ 681static int 682val_parse_double(const char *val, double *p) 683{ 684 char *end; 685 686 errno = 0; 687 *p = strtod(val, &end); 688 if (errno != 0 || *end != '\0') 689 return (0); 690 return (1); 691} 692 693static int 694val_parse_ts(const char *val, char *buf) 695{ 696 int r, n; 697 u_int i, f; 698 699 if (strlen(val) > 2 && val[0] == '0' && val[1] == 'x') { 700 /* hex format */ 701 r = sscanf(val + 2, "%x.%x%n", &i, &f, &n); 702 if (r != 2 || (size_t)n != strlen(val + 2)) 703 return (0); 704 } else { 705 /* probably decimal */ 706 r = sscanf(val, "%d.%d%n", &i, &f, &n); 707 if (r != 2 || (size_t)n != strlen(val)) 708 return (0); 709 } 710 buf[0] = i >> 24; 711 buf[1] = i >> 16; 712 buf[2] = i >> 8; 713 buf[3] = i >> 0; 714 buf[4] = f >> 24; 715 buf[5] = f >> 16; 716 buf[6] = f >> 8; 717 buf[7] = f >> 0; 718 return (1); 719} 720 721/* 722 * Parse an IP address. This resolves non-numeric names. 723 */ 724static int 725val_parse_ip(const char *val, u_char ip[4]) 726{ 727 int r, n, error; 728 struct addrinfo hints, *res0; 729 struct sockaddr_in *sin_local; 730 731 r = sscanf(val, "%hhd.%hhd.%hhd.%hhd%n", 732 &ip[0], &ip[1], &ip[2], &ip[3], &n); 733 if (n == 4 && (size_t)n == strlen(val)) 734 return (0); 735 736 memset(ip, 0, 4); 737 738 memset(&hints, 0, sizeof(hints)); 739 hints.ai_family = AF_INET; 740 hints.ai_socktype = SOCK_DGRAM; 741 742 error = getaddrinfo(val, NULL, &hints, &res0); 743 if (error) { 744 syslog(LOG_ERR, "%s: %s", val, gai_strerror(error)); 745 return (-1); 746 } 747 if (res0 == NULL) { 748 syslog(LOG_ERR, "%s: no address", val); 749 return (-1); 750 } 751 752 sin_local = (struct sockaddr_in *)(void *)res0->ai_addr; 753 ip[3] = sin_local->sin_addr.s_addr >> 24; 754 ip[2] = sin_local->sin_addr.s_addr >> 16; 755 ip[1] = sin_local->sin_addr.s_addr >> 8; 756 ip[0] = sin_local->sin_addr.s_addr >> 0; 757 758 freeaddrinfo(res0); 759 return (0); 760} 761 762/* 763 * Fetch system info 764 */ 765static int 766fetch_sysinfo(void) 767{ 768 u_char *data; 769 u_char *ptr; 770 size_t datalen; 771 char *name; 772 char *val; 773 774 if (ntpd_dialog(NTPC_OP_READVAR, 0, 775 "leap,stratum,precision,rootdelay,rootdispersion,refid,reftime," 776 "poll,peer,clock,system,processor,jitter,stability", 777 &data, &datalen)) 778 return (-1); 779 780 /* clear info */ 781 sysb_leap = 0; 782 sysb_stratum = 0; 783 sysb_precision = 0; 784 free(sys_rootdelay); 785 sys_rootdelay = NULL; 786 free(sys_rootdispersion); 787 sys_rootdispersion = NULL; 788 free(sys_refid); 789 sys_refid = NULL; 790 sysb_reftime = 0; 791 sysb_poll = 0; 792 sysb_peer = 0; 793 sysb_clock = 0; 794 free(sys_system); 795 sys_system = NULL; 796 free(sys_processor); 797 sys_processor = NULL; 798 sysb_jitter = 0; 799 sysb_stability = 0; 800 801 ptr = data; 802 while (ntpd_parse(&ptr, &datalen, &name, &val)) { 803 if (ntp_debug & DBG_DUMP_VARS) 804 syslog(LOG_DEBUG, "%s: '%s'='%s'", __func__, name, val); 805 if (strcmp(name, "leap") == 0 || 806 strcmp(name, "sys.leap") == 0) { 807 sysb_leap = val_parse_int32(val, &sys_leap, 808 0, 3, 2); 809 810 } else if (strcmp(name, "stratum") == 0 || 811 strcmp(name, "sys.stratum") == 0) { 812 sysb_stratum = val_parse_int32(val, &sys_stratum, 813 0, 255, 0); 814 815 } else if (strcmp(name, "precision") == 0 || 816 strcmp(name, "sys.precision") == 0) { 817 sysb_precision = val_parse_int32(val, &sys_precision, 818 INT32_MIN, INT32_MAX, 0); 819 820 } else if (strcmp(name, "rootdelay") == 0 || 821 strcmp(name, "sys.rootdelay") == 0) { 822 sys_rootdelay = strdup(val); 823 824 } else if (strcmp(name, "rootdispersion") == 0 || 825 strcmp(name, "sys.rootdispersion") == 0) { 826 sys_rootdispersion = strdup(val); 827 828 } else if (strcmp(name, "refid") == 0 || 829 strcmp(name, "sys.refid") == 0) { 830 sys_refid = strdup(val); 831 832 } else if (strcmp(name, "reftime") == 0 || 833 strcmp(name, "sys.reftime") == 0) { 834 sysb_reftime = val_parse_ts(val, sys_reftime); 835 836 } else if (strcmp(name, "poll") == 0 || 837 strcmp(name, "sys.poll") == 0) { 838 sysb_poll = val_parse_int32(val, &sys_poll, 839 INT32_MIN, INT32_MAX, 0); 840 841 } else if (strcmp(name, "peer") == 0 || 842 strcmp(name, "sys.peer") == 0) { 843 sysb_peer = val_parse_uint32(val, &sys_peer, 844 0, UINT32_MAX, 0); 845 846 } else if (strcmp(name, "clock") == 0 || 847 strcmp(name, "sys.clock") == 0) { 848 sysb_clock = val_parse_ts(val, sys_clock); 849 850 } else if (strcmp(name, "system") == 0 || 851 strcmp(name, "sys.system") == 0) { 852 sys_system = strdup(val); 853 854 } else if (strcmp(name, "processor") == 0 || 855 strcmp(name, "sys.processor") == 0) { 856 sys_processor = strdup(val); 857 858 } else if (strcmp(name, "jitter") == 0 || 859 strcmp(name, "sys.jitter") == 0) { 860 sysb_jitter = val_parse_double(val, &sys_jitter); 861 862 } else if (strcmp(name, "stability") == 0 || 863 strcmp(name, "sys.stability") == 0) { 864 sysb_stability = val_parse_double(val, &sys_stability); 865 } 866 } 867 868 free(data); 869 return (0); 870} 871 872static int 873parse_filt(char *val, uint16_t associd, int which) 874{ 875 char *w; 876 int cnt; 877 struct filt *f; 878 879 cnt = 0; 880 for (w = strtok(val, " \t"); w != NULL; w = strtok(NULL, " \t")) { 881 TAILQ_FOREACH(f, &filts, link) 882 if (f->index.subs[0] == associd && 883 f->index.subs[1] == (asn_subid_t)(cnt + 1)) 884 break; 885 if (f == NULL) { 886 f = malloc(sizeof(*f)); 887 memset(f, 0, sizeof(*f)); 888 f->index.len = 2; 889 f->index.subs[0] = associd; 890 f->index.subs[1] = cnt + 1; 891 892 INSERT_OBJECT_OID(f, &filts); 893 } 894 895 switch (which) { 896 897 case 0: 898 f->offset = strdup(w); 899 break; 900 901 case 1: 902 f->delay = strdup(w); 903 break; 904 905 case 2: 906 f->dispersion = strdup(w); 907 break; 908 909 default: 910 abort(); 911 } 912 cnt++; 913 } 914 return (cnt); 915} 916 917/* 918 * Fetch the complete peer list 919 */ 920static int 921fetch_peers(void) 922{ 923 u_char *data, *pdata, *ptr; 924 size_t datalen, pdatalen; 925 int i; 926 struct peer *p; 927 struct filt *f; 928 uint16_t associd; 929 char *name, *val; 930 931 /* free the old list */ 932 while ((p = TAILQ_FIRST(&peers)) != NULL) { 933 TAILQ_REMOVE(&peers, p, link); 934 free(p->rootdelay); 935 free(p->rootdispersion); 936 free(p->refid); 937 free(p->offset); 938 free(p->delay); 939 free(p->dispersion); 940 free(p); 941 } 942 while ((f = TAILQ_FIRST(&filts)) != NULL) { 943 TAILQ_REMOVE(&filts, f, link); 944 free(f->offset); 945 free(f->delay); 946 free(f->dispersion); 947 free(f); 948 } 949 950 /* fetch the list of associations */ 951 if (ntpd_dialog(NTPC_OP_READSTAT, 0, NULL, &data, &datalen)) 952 return (-1); 953 954 for (i = 0; i < (int)(datalen / 4); i++) { 955 associd = data[4 * i + 0] << 8; 956 associd |= data[4 * i + 1] << 0; 957 958 /* ask for the association variables */ 959 if (ntpd_dialog(NTPC_OP_READVAR, associd, 960 "config,srcadr,srcport,dstadr,dstport,leap,hmode,stratum," 961 "hpoll,ppoll,precision,rootdelay,rootdispersion,refid," 962 "reftime,org,rec,xmt,reach,timer,offset,delay,dispersion," 963 "filtdelay,filtoffset,filtdisp", 964 &pdata, &pdatalen)) { 965 free(data); 966 return (-1); 967 } 968 969 /* now save and parse the data */ 970 p = malloc(sizeof(*p)); 971 if (p == NULL) { 972 free(data); 973 syslog(LOG_ERR, "%m"); 974 return (-1); 975 } 976 memset(p, 0, sizeof(*p)); 977 p->index = associd; 978 INSERT_OBJECT_INT(p, &peers); 979 980 ptr = pdata; 981 while (ntpd_parse(&ptr, &pdatalen, &name, &val)) { 982 if (ntp_debug & DBG_DUMP_VARS) 983 syslog(LOG_DEBUG, "%s: '%s'='%s'", 984 __func__, name, val); 985 if (strcmp(name, "config") == 0 || 986 strcmp(name, "peer.config") == 0) { 987 val_parse_int32(val, &p->config, 0, 1, 0); 988 989 } else if (strcmp(name, "srcadr") == 0 || 990 strcmp(name, "peer.srcadr") == 0) { 991 val_parse_ip(val, p->srcadr); 992 993 } else if (strcmp(name, "srcport") == 0 || 994 strcmp(name, "peer.srcport") == 0) { 995 val_parse_uint32(val, &p->srcport, 996 1, 65535, 0); 997 998 } else if (strcmp(name, "dstadr") == 0 || 999 strcmp(name, "peer.dstadr") == 0) { 1000 val_parse_ip(val, p->dstadr); 1001 1002 } else if (strcmp(name, "dstport") == 0 || 1003 strcmp(name, "peer.dstport") == 0) { 1004 val_parse_uint32(val, &p->dstport, 1005 1, 65535, 0); 1006 1007 } else if (strcmp(name, "leap") == 0 || 1008 strcmp(name, "peer.leap") == 0) { 1009 val_parse_int32(val, &p->leap, 0, 3, 2); 1010 1011 } else if (strcmp(name, "hmode") == 0 || 1012 strcmp(name, "peer.hmode") == 0) { 1013 val_parse_int32(val, &p->hmode, 0, 7, 0); 1014 1015 } else if (strcmp(name, "stratum") == 0 || 1016 strcmp(name, "peer.stratum") == 0) { 1017 val_parse_int32(val, &p->stratum, 0, 255, 0); 1018 1019 } else if (strcmp(name, "ppoll") == 0 || 1020 strcmp(name, "peer.ppoll") == 0) { 1021 val_parse_int32(val, &p->ppoll, 1022 INT32_MIN, INT32_MAX, 0); 1023 1024 } else if (strcmp(name, "hpoll") == 0 || 1025 strcmp(name, "peer.hpoll") == 0) { 1026 val_parse_int32(val, &p->hpoll, 1027 INT32_MIN, INT32_MAX, 0); 1028 1029 } else if (strcmp(name, "precision") == 0 || 1030 strcmp(name, "peer.precision") == 0) { 1031 val_parse_int32(val, &p->hpoll, 1032 INT32_MIN, INT32_MAX, 0); 1033 1034 } else if (strcmp(name, "rootdelay") == 0 || 1035 strcmp(name, "peer.rootdelay") == 0) { 1036 p->rootdelay = strdup(val); 1037 1038 } else if (strcmp(name, "rootdispersion") == 0 || 1039 strcmp(name, "peer.rootdispersion") == 0) { 1040 p->rootdispersion = strdup(val); 1041 1042 } else if (strcmp(name, "refid") == 0 || 1043 strcmp(name, "peer.refid") == 0) { 1044 p->refid = strdup(val); 1045 1046 } else if (strcmp(name, "reftime") == 0 || 1047 strcmp(name, "sys.reftime") == 0) { 1048 val_parse_ts(val, p->reftime); 1049 1050 } else if (strcmp(name, "org") == 0 || 1051 strcmp(name, "sys.org") == 0) { 1052 val_parse_ts(val, p->orgtime); 1053 1054 } else if (strcmp(name, "rec") == 0 || 1055 strcmp(name, "sys.rec") == 0) { 1056 val_parse_ts(val, p->rcvtime); 1057 1058 } else if (strcmp(name, "xmt") == 0 || 1059 strcmp(name, "sys.xmt") == 0) { 1060 val_parse_ts(val, p->xmttime); 1061 1062 } else if (strcmp(name, "reach") == 0 || 1063 strcmp(name, "peer.reach") == 0) { 1064 val_parse_uint32(val, &p->reach, 1065 0, 65535, 0); 1066 1067 } else if (strcmp(name, "timer") == 0 || 1068 strcmp(name, "peer.timer") == 0) { 1069 val_parse_int32(val, &p->timer, 1070 INT32_MIN, INT32_MAX, 0); 1071 1072 } else if (strcmp(name, "offset") == 0 || 1073 strcmp(name, "peer.offset") == 0) { 1074 p->offset = strdup(val); 1075 1076 } else if (strcmp(name, "delay") == 0 || 1077 strcmp(name, "peer.delay") == 0) { 1078 p->delay = strdup(val); 1079 1080 } else if (strcmp(name, "dispersion") == 0 || 1081 strcmp(name, "peer.dispersion") == 0) { 1082 p->dispersion = strdup(val); 1083 1084 } else if (strcmp(name, "filtdelay") == 0 || 1085 strcmp(name, "peer.filtdelay") == 0) { 1086 p->filt_entries = parse_filt(val, associd, 0); 1087 1088 } else if (strcmp(name, "filtoffset") == 0 || 1089 strcmp(name, "peer.filtoffset") == 0) { 1090 p->filt_entries = parse_filt(val, associd, 1); 1091 1092 } else if (strcmp(name, "filtdisp") == 0 || 1093 strcmp(name, "peer.filtdisp") == 0) { 1094 p->filt_entries = parse_filt(val, associd, 2); 1095 } 1096 } 1097 free(pdata); 1098 } 1099 1100 free(data); 1101 return (0); 1102} 1103 1104/* 1105 * System variables - read-only scalars only. 1106 */ 1107int 1108op_ntpSystem(struct snmp_context *ctx __unused, struct snmp_value *value, 1109 u_int sub, u_int iidx __unused, enum snmp_op op) 1110{ 1111 asn_subid_t which = value->var.subs[sub - 1]; 1112 1113 switch (op) { 1114 1115 case SNMP_OP_GETNEXT: 1116 abort(); 1117 1118 case SNMP_OP_GET: 1119 if (this_tick > sysinfo_tick) { 1120 if (fetch_sysinfo() == -1) 1121 return (SNMP_ERR_GENERR); 1122 sysinfo_tick = this_tick; 1123 } 1124 1125 switch (which) { 1126 1127 case LEAF_ntpSysLeap: 1128 if (!sysb_leap) 1129 return (SNMP_ERR_NOSUCHNAME); 1130 value->v.integer = sys_leap; 1131 break; 1132 1133 case LEAF_ntpSysStratum: 1134 if (!sysb_stratum) 1135 return (SNMP_ERR_NOSUCHNAME); 1136 value->v.integer = sys_stratum; 1137 break; 1138 1139 case LEAF_ntpSysPrecision: 1140 if (!sysb_precision) 1141 return (SNMP_ERR_NOSUCHNAME); 1142 value->v.integer = sys_precision; 1143 break; 1144 1145 case LEAF_ntpSysRootDelay: 1146 if (sys_rootdelay == NULL) 1147 return (SNMP_ERR_NOSUCHNAME); 1148 return (string_get(value, sys_rootdelay, -1)); 1149 1150 case LEAF_ntpSysRootDispersion: 1151 if (sys_rootdispersion == NULL) 1152 return (SNMP_ERR_NOSUCHNAME); 1153 return (string_get(value, sys_rootdispersion, -1)); 1154 1155 case LEAF_ntpSysRefId: 1156 if (sys_refid == NULL) 1157 return (SNMP_ERR_NOSUCHNAME); 1158 return (string_get(value, sys_refid, -1)); 1159 1160 case LEAF_ntpSysRefTime: 1161 if (sysb_reftime == 0) 1162 return (SNMP_ERR_NOSUCHNAME); 1163 return (string_get(value, sys_reftime, 8)); 1164 1165 case LEAF_ntpSysPoll: 1166 if (sysb_poll == 0) 1167 return (SNMP_ERR_NOSUCHNAME); 1168 value->v.integer = sys_poll; 1169 break; 1170 1171 case LEAF_ntpSysPeer: 1172 if (sysb_peer == 0) 1173 return (SNMP_ERR_NOSUCHNAME); 1174 value->v.uint32 = sys_peer; 1175 break; 1176 1177 case LEAF_ntpSysClock: 1178 if (sysb_clock == 0) 1179 return (SNMP_ERR_NOSUCHNAME); 1180 return (string_get(value, sys_clock, 8)); 1181 1182 case LEAF_ntpSysSystem: 1183 if (sys_system == NULL) 1184 return (SNMP_ERR_NOSUCHNAME); 1185 return (string_get(value, sys_system, -1)); 1186 1187 case LEAF_ntpSysProcessor: 1188 if (sys_processor == NULL) 1189 return (SNMP_ERR_NOSUCHNAME); 1190 return (string_get(value, sys_processor, -1)); 1191 1192 default: 1193 abort(); 1194 } 1195 return (SNMP_ERR_NOERROR); 1196 1197 case SNMP_OP_SET: 1198 return (SNMP_ERR_NOT_WRITEABLE); 1199 1200 case SNMP_OP_COMMIT: 1201 case SNMP_OP_ROLLBACK: 1202 abort(); 1203 } 1204 abort(); 1205} 1206 1207int 1208op_ntpPeersVarTable(struct snmp_context *ctx __unused, struct snmp_value *value, 1209 u_int sub, u_int iidx, enum snmp_op op) 1210{ 1211 asn_subid_t which = value->var.subs[sub - 1]; 1212 uint32_t peer; 1213 struct peer *t; 1214 1215 if (this_tick > peers_tick) { 1216 if (fetch_peers() == -1) 1217 return (SNMP_ERR_GENERR); 1218 peers_tick = this_tick; 1219 } 1220 1221 switch (op) { 1222 1223 case SNMP_OP_GETNEXT: 1224 t = NEXT_OBJECT_INT(&peers, &value->var, sub); 1225 if (t == NULL) 1226 return (SNMP_ERR_NOSUCHNAME); 1227 value->var.len = sub + 1; 1228 value->var.subs[sub] = t->index; 1229 break; 1230 1231 case SNMP_OP_GET: 1232 t = FIND_OBJECT_INT(&peers, &value->var, sub); 1233 if (t == NULL) 1234 return (SNMP_ERR_NOSUCHNAME); 1235 break; 1236 1237 case SNMP_OP_SET: 1238 if (index_decode(&value->var, sub, iidx, &peer)) 1239 return (SNMP_ERR_NO_CREATION); 1240 t = FIND_OBJECT_INT(&peers, &value->var, sub); 1241 if (t != NULL) 1242 return (SNMP_ERR_NOT_WRITEABLE); 1243 return (SNMP_ERR_NO_CREATION); 1244 1245 case SNMP_OP_COMMIT: 1246 case SNMP_OP_ROLLBACK: 1247 default: 1248 abort(); 1249 } 1250 1251 /* 1252 * Come here for GET and COMMIT 1253 */ 1254 switch (which) { 1255 1256 case LEAF_ntpPeersConfigured: 1257 value->v.integer = t->config; 1258 break; 1259 1260 case LEAF_ntpPeersPeerAddress: 1261 return (ip_get(value, t->srcadr)); 1262 1263 case LEAF_ntpPeersPeerPort: 1264 value->v.uint32 = t->srcport; 1265 break; 1266 1267 case LEAF_ntpPeersHostAddress: 1268 return (ip_get(value, t->dstadr)); 1269 1270 case LEAF_ntpPeersHostPort: 1271 value->v.uint32 = t->dstport; 1272 break; 1273 1274 case LEAF_ntpPeersLeap: 1275 value->v.integer = t->leap; 1276 break; 1277 1278 case LEAF_ntpPeersMode: 1279 value->v.integer = t->hmode; 1280 break; 1281 1282 case LEAF_ntpPeersStratum: 1283 value->v.integer = t->stratum; 1284 break; 1285 1286 case LEAF_ntpPeersPeerPoll: 1287 value->v.integer = t->ppoll; 1288 break; 1289 1290 case LEAF_ntpPeersHostPoll: 1291 value->v.integer = t->hpoll; 1292 break; 1293 1294 case LEAF_ntpPeersPrecision: 1295 value->v.integer = t->precision; 1296 break; 1297 1298 case LEAF_ntpPeersRootDelay: 1299 return (string_get(value, t->rootdelay, -1)); 1300 1301 case LEAF_ntpPeersRootDispersion: 1302 return (string_get(value, t->rootdispersion, -1)); 1303 1304 case LEAF_ntpPeersRefId: 1305 return (string_get(value, t->refid, -1)); 1306 1307 case LEAF_ntpPeersRefTime: 1308 return (string_get(value, t->reftime, 8)); 1309 1310 case LEAF_ntpPeersOrgTime: 1311 return (string_get(value, t->orgtime, 8)); 1312 1313 case LEAF_ntpPeersReceiveTime: 1314 return (string_get(value, t->rcvtime, 8)); 1315 1316 case LEAF_ntpPeersTransmitTime: 1317 return (string_get(value, t->xmttime, 8)); 1318 1319 case LEAF_ntpPeersReach: 1320 value->v.uint32 = t->reach; 1321 break; 1322 1323 case LEAF_ntpPeersTimer: 1324 value->v.uint32 = t->timer; 1325 break; 1326 1327 case LEAF_ntpPeersOffset: 1328 return (string_get(value, t->offset, -1)); 1329 1330 case LEAF_ntpPeersDelay: 1331 return (string_get(value, t->delay, -1)); 1332 1333 case LEAF_ntpPeersDispersion: 1334 return (string_get(value, t->dispersion, -1)); 1335 1336 default: 1337 abort(); 1338 } 1339 return (SNMP_ERR_NOERROR); 1340} 1341 1342 1343int 1344op_ntpFilterPeersVarTable(struct snmp_context *ctx __unused, 1345 struct snmp_value *value, u_int sub, u_int iidx, enum snmp_op op) 1346{ 1347 asn_subid_t which = value->var.subs[sub - 1]; 1348 uint32_t peer; 1349 struct peer *t; 1350 1351 if (this_tick > peers_tick) { 1352 if (fetch_peers() == -1) 1353 return (SNMP_ERR_GENERR); 1354 peers_tick = this_tick; 1355 } 1356 1357 switch (op) { 1358 1359 case SNMP_OP_GETNEXT: 1360 t = NEXT_OBJECT_INT(&peers, &value->var, sub); 1361 if (t == NULL) 1362 return (SNMP_ERR_NOSUCHNAME); 1363 value->var.len = sub + 1; 1364 value->var.subs[sub] = t->index; 1365 break; 1366 1367 case SNMP_OP_GET: 1368 t = FIND_OBJECT_INT(&peers, &value->var, sub); 1369 if (t == NULL) 1370 return (SNMP_ERR_NOSUCHNAME); 1371 break; 1372 1373 case SNMP_OP_SET: 1374 if (index_decode(&value->var, sub, iidx, &peer)) 1375 return (SNMP_ERR_NO_CREATION); 1376 t = FIND_OBJECT_INT(&peers, &value->var, sub); 1377 if (t != NULL) 1378 return (SNMP_ERR_NOT_WRITEABLE); 1379 return (SNMP_ERR_NO_CREATION); 1380 1381 case SNMP_OP_COMMIT: 1382 case SNMP_OP_ROLLBACK: 1383 default: 1384 abort(); 1385 } 1386 1387 /* 1388 * Come here for GET and COMMIT 1389 */ 1390 switch (which) { 1391 1392 case LEAF_ntpFilterValidEntries: 1393 value->v.integer = t->filt_entries; 1394 break; 1395 1396 default: 1397 abort(); 1398 } 1399 return (SNMP_ERR_NOERROR); 1400} 1401 1402int 1403op_ntpFilterRegisterTable(struct snmp_context *ctx __unused, struct snmp_value *value __unused, 1404 u_int sub __unused, u_int iidx __unused, enum snmp_op op __unused) 1405{ 1406 asn_subid_t which = value->var.subs[sub - 1]; 1407 uint32_t peer; 1408 uint32_t filt; 1409 struct filt *t; 1410 1411 if (this_tick > peers_tick) { 1412 if (fetch_peers() == -1) 1413 return (SNMP_ERR_GENERR); 1414 peers_tick = this_tick; 1415 } 1416 1417 switch (op) { 1418 1419 case SNMP_OP_GETNEXT: 1420 t = NEXT_OBJECT_OID(&filts, &value->var, sub); 1421 if (t == NULL) 1422 return (SNMP_ERR_NOSUCHNAME); 1423 index_append(&value->var, sub, &t->index); 1424 break; 1425 1426 case SNMP_OP_GET: 1427 t = FIND_OBJECT_OID(&filts, &value->var, sub); 1428 if (t == NULL) 1429 return (SNMP_ERR_NOSUCHNAME); 1430 break; 1431 1432 case SNMP_OP_SET: 1433 if (index_decode(&value->var, sub, iidx, &peer, &filt)) 1434 return (SNMP_ERR_NO_CREATION); 1435 t = FIND_OBJECT_OID(&filts, &value->var, sub); 1436 if (t != NULL) 1437 return (SNMP_ERR_NOT_WRITEABLE); 1438 return (SNMP_ERR_NO_CREATION); 1439 1440 case SNMP_OP_COMMIT: 1441 case SNMP_OP_ROLLBACK: 1442 default: 1443 abort(); 1444 } 1445 1446 /* 1447 * Come here for GET and COMMIT 1448 */ 1449 switch (which) { 1450 1451 case LEAF_ntpFilterPeersOffset: 1452 return (string_get(value, t->offset, -1)); 1453 1454 case LEAF_ntpFilterPeersDelay: 1455 return (string_get(value, t->delay, -1)); 1456 1457 case LEAF_ntpFilterPeersDispersion: 1458 return (string_get(value, t->dispersion, -1)); 1459 1460 default: 1461 abort(); 1462 } 1463 return (SNMP_ERR_NOERROR); 1464} 1465 1466/* 1467 * System variables - read-only scalars only. 1468 */ 1469int 1470op_begemot_ntp(struct snmp_context *ctx __unused, struct snmp_value *value, 1471 u_int sub, u_int iidx __unused, enum snmp_op op) 1472{ 1473 asn_subid_t which = value->var.subs[sub - 1]; 1474 int ret; 1475 1476 switch (op) { 1477 1478 case SNMP_OP_GETNEXT: 1479 abort(); 1480 1481 case SNMP_OP_GET: 1482 switch (which) { 1483 1484 case LEAF_begemotNtpHost: 1485 return (string_get(value, ntp_host, -1)); 1486 1487 case LEAF_begemotNtpPort: 1488 return (string_get(value, ntp_port, -1)); 1489 1490 case LEAF_begemotNtpTimeout: 1491 value->v.uint32 = ntp_timeout; 1492 return (SNMP_ERR_NOERROR); 1493 1494 case LEAF_begemotNtpDebug: 1495 value->v.uint32 = ntp_debug; 1496 return (SNMP_ERR_NOERROR); 1497 1498 case LEAF_begemotNtpJitter: 1499 if (this_tick > sysinfo_tick) { 1500 if (fetch_sysinfo() == -1) 1501 return (SNMP_ERR_GENERR); 1502 sysinfo_tick = this_tick; 1503 } 1504 if (!sysb_jitter) 1505 return (SNMP_ERR_NOSUCHNAME); 1506 value->v.counter64 = sys_jitter / 1000 * (1ULL << 32); 1507 return (SNMP_ERR_NOERROR); 1508 1509 case LEAF_begemotNtpStability: 1510 if (this_tick > sysinfo_tick) { 1511 if (fetch_sysinfo() == -1) 1512 return (SNMP_ERR_GENERR); 1513 sysinfo_tick = this_tick; 1514 } 1515 if (!sysb_stability) 1516 return (SNMP_ERR_NOSUCHNAME); 1517 value->v.counter64 = sys_stability * (1ULL << 32); 1518 return (SNMP_ERR_NOERROR); 1519 } 1520 abort(); 1521 1522 case SNMP_OP_SET: 1523 switch (which) { 1524 1525 case LEAF_begemotNtpHost: 1526 /* only at initialization */ 1527 if (community != COMM_INITIALIZE) 1528 return (SNMP_ERR_NOT_WRITEABLE); 1529 1530 if ((ret = string_save(value, ctx, -1, &ntp_host)) 1531 != SNMP_ERR_NOERROR) 1532 return (ret); 1533 return (SNMP_ERR_NOERROR); 1534 1535 case LEAF_begemotNtpPort: 1536 /* only at initialization */ 1537 if (community != COMM_INITIALIZE) 1538 return (SNMP_ERR_NOT_WRITEABLE); 1539 1540 if ((ret = string_save(value, ctx, -1, &ntp_port)) 1541 != SNMP_ERR_NOERROR) 1542 return (ret); 1543 return (SNMP_ERR_NOERROR); 1544 1545 case LEAF_begemotNtpTimeout: 1546 ctx->scratch->int1 = ntp_timeout; 1547 if (value->v.uint32 < 1) 1548 return (SNMP_ERR_WRONG_VALUE); 1549 ntp_timeout = value->v.integer; 1550 return (SNMP_ERR_NOERROR); 1551 1552 case LEAF_begemotNtpDebug: 1553 ctx->scratch->int1 = ntp_debug; 1554 ntp_debug = value->v.integer; 1555 return (SNMP_ERR_NOERROR); 1556 } 1557 abort(); 1558 1559 case SNMP_OP_ROLLBACK: 1560 switch (which) { 1561 1562 case LEAF_begemotNtpHost: 1563 string_rollback(ctx, &ntp_host); 1564 return (SNMP_ERR_NOERROR); 1565 1566 case LEAF_begemotNtpPort: 1567 string_rollback(ctx, &ntp_port); 1568 return (SNMP_ERR_NOERROR); 1569 1570 case LEAF_begemotNtpTimeout: 1571 ntp_timeout = ctx->scratch->int1; 1572 return (SNMP_ERR_NOERROR); 1573 1574 case LEAF_begemotNtpDebug: 1575 ntp_debug = ctx->scratch->int1; 1576 return (SNMP_ERR_NOERROR); 1577 } 1578 abort(); 1579 1580 case SNMP_OP_COMMIT: 1581 switch (which) { 1582 1583 case LEAF_begemotNtpHost: 1584 string_commit(ctx); 1585 return (SNMP_ERR_NOERROR); 1586 1587 case LEAF_begemotNtpPort: 1588 string_commit(ctx); 1589 return (SNMP_ERR_NOERROR); 1590 1591 case LEAF_begemotNtpTimeout: 1592 case LEAF_begemotNtpDebug: 1593 return (SNMP_ERR_NOERROR); 1594 } 1595 abort(); 1596 } 1597 abort(); 1598} 1599