usr/src/cmd/smbsrv/smbd/smbd_nicmon.c

   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  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24
  25 /*
  26  * smbd NIC monitor.
  27  */
  28
  29 #include <sys/types.h>
  30 #include <stdlib.h>
  31 #include <errno.h>
  32 #include <string.h>
  33 #include <unistd.h>
  34 #include <signal.h>
  35 #include <stdio.h>
  36 #include <net/if.h>
  37 #include <net/route.h>
  38 #include <sys/sockio.h>
  39 #include <sys/socket.h>
  40 #include <netinet/in.h>
  41 #include <arpa/inet.h>
  42 #include <fcntl.h>
  43 #include <pthread.h>
  44 #include <syslog.h>
  45 #include <smbsrv/libsmb.h>
  46 #include "smbd.h"
  47
  48 #define SMBD_NICMON_ENABLE      "nicmon_enable"
  49 #define SMBD_NICMON_THROTTLE    100
  50 #define SMBD_NICMON_DEBOUNCE    2
  51
  52 extern smbd_t smbd;
  53
  54 static boolean_t smbd_nicmon_enabled = B_TRUE;
  55
  56 /* Use this to stop monitoring */
  57 static int eventpipe_write = -1;
  58
  59 /* Use this to refresh service instance */
  60 static char *smbd_nicmon_caller_fmri = NULL;
  61
  62 static void smbd_nicmon_run_check(void);
  63 static int smbd_nicmon_setup_rtsock(int);
  64 static int smbd_nicmon_needscan(int);
  65 static int smbd_nicmon_setup_eventpipe(int *, int *);
  66 static void *smbd_nicmon_daemon(void *);
  67
  68 /*
  69  * Start the nic monitor thread.
  70  */
  71 int
  72 smbd_nicmon_start(const char *svc_fmri)
  73 {
  74         pthread_t       smbd_nicmon_tid;
  75         int             rc;
  76
  77         if (smb_nic_init() != SMB_NIC_SUCCESS)
  78                 return (-1);
  79
  80         rc = pthread_create(&smbd_nicmon_tid, NULL, smbd_nicmon_daemon, NULL);
  81         if (rc != 0)
  82                 return (-1);
  83
  84         if (svc_fmri)
  85                 smbd_nicmon_caller_fmri = (char *)svc_fmri;
  86
  87         smbd_nicmon_run_check();
  88         return (0);
  89 }
  90
  91 void
  92 smbd_nicmon_stop(void)
  93 {
  94         uchar_t buf = 1;
  95
  96         if (eventpipe_write < 0)
  97                 return;
  98
  99         (void) write(eventpipe_write, &buf, sizeof (buf));
 100         smbd_nicmon_caller_fmri = NULL;
 101         smb_nic_fini();
 102 }
 103
 104 int
 105 smbd_nicmon_refresh(void)
 106 {
 107         if (smb_nic_init() != SMB_NIC_SUCCESS)
 108                 return (-1);
 109
 110         smbd_nicmon_run_check();
 111         return (0);
 112 }
 113
 114 /*
 115  * The monitor is enabled unless it is explicitly
 116  * disabled by setting smbd/nicmon_enable to false.
 117  * smbd/nicmon_enable is not defined by default.
 118  */
 119 static void
 120 smbd_nicmon_run_check(void)
 121 {
 122         smb_scfhandle_t *hd;
 123         uint8_t         status;
 124         int             rc;
 125
 126         smbd_nicmon_enabled = B_TRUE;
 127
 128         if ((hd = smb_smf_scf_init(SMBD_FMRI_PREFIX)) == NULL) {
 129                 syslog(LOG_DEBUG,
 130                     "smbd_nicmon: smb_smf_scf_init failed");
 131                 return;
 132         }
 133
 134         rc = smb_smf_create_service_pgroup(hd, SMBD_PG_NAME);
 135         if (rc != SMBD_SMF_OK) {
 136                 smb_smf_scf_fini(hd);
 137                 syslog(LOG_DEBUG,
 138                     "smbd_nicmon: smb_smf_create_service_pgroup failed");
 139                 return;
 140         }
 141
 142         rc = smb_smf_get_boolean_property(hd, SMBD_NICMON_ENABLE, &status);
 143         if (rc == SMBD_SMF_OK && status == 0)
 144                 smbd_nicmon_enabled = B_FALSE;
 145
 146         smb_smf_scf_fini(hd);
 147 }
 148
 149 /*
 150  * Setup routing socket for getting RTM messages.
 151  */
 152 static int
 153 smbd_nicmon_setup_rtsock(int af)
 154 {
 155         int sd;
 156         int flags;
 157
 158         if ((sd = socket(PF_ROUTE, SOCK_RAW, af)) == -1) {
 159                 syslog(LOG_ERR,
 160                     "smbd_nicmon: routing socket failed: %d", errno);
 161                 return (-1);
 162         }
 163
 164         if ((flags = fcntl(sd, F_GETFL, 0)) < 0) {
 165                 syslog(LOG_ERR,
 166                     "smbd_nicmon: fcntl F_GETFL failed: %d", errno);
 167                 (void) close(sd);
 168                 return (-1);
 169         }
 170
 171         if ((fcntl(sd, F_SETFL, flags | O_NONBLOCK)) < 0) {
 172                 syslog(LOG_ERR,
 173                     "smbd_nicmon: fcntl F_SETFL failed: %d", errno);
 174                 (void) close(sd);
 175                 return (-1);
 176         }
 177
 178         return (sd);
 179 }
 180
 181 static int
 182 smbd_nicmon_needscan(int sock)
 183 {
 184         static uint32_t         throttle;
 185         struct rt_msghdr        *rtm;
 186         int64_t                 msg[2048 / 8];
 187         int                     need_if_scan = 0;
 188         int                     nbytes;
 189
 190         /* Read as many messages as possible and try to empty the sockets */
 191         for (;;) {
 192                 nbytes = read(sock, msg, sizeof (msg));
 193                 if (nbytes <= 0)
 194                         break;
 195
 196                 rtm = (struct rt_msghdr *)msg;
 197                 if (rtm->rtm_version != RTM_VERSION)
 198                         continue;
 199
 200                 if (nbytes < rtm->rtm_msglen) {
 201                         if ((throttle % SMBD_NICMON_THROTTLE) == 0) {
 202                                 syslog(LOG_DEBUG,
 203                                     "smbd_nicmon: short read: %d of %d",
 204                                     nbytes, rtm->rtm_msglen);
 205                         }
 206                         ++throttle;
 207                         continue;
 208                 }
 209
 210                 switch (rtm->rtm_type) {
 211                 case RTM_NEWADDR:
 212                 case RTM_DELADDR:
 213                 case RTM_IFINFO:
 214                         need_if_scan = 1;
 215                         break;
 216                 default:
 217                         break;
 218                 }
 219         }
 220
 221         return (need_if_scan);
 222 }
 223
 224 /*
 225  * Create pipe for signal delivery and set up signal handlers.
 226  */
 227 static int
 228 smbd_nicmon_setup_eventpipe(int *read_pipe, int *write_pipe)
 229 {
 230         int fds[2];
 231
 232         if ((pipe(fds)) < 0) {
 233                 syslog(LOG_ERR,
 234                     "smbd_nicmon: event pipe failed: %d", errno);
 235                 return (-1);
 236         }
 237
 238         *read_pipe = fds[0];
 239         *write_pipe = fds[1];
 240         return (0);
 241 }
 242
 243 /*
 244  * Create the global routing socket to monitor changes in NIC interfaces.
 245  * We are only interested in new inerface addition/deletion and changes
 246  * in UP/DOWN status.
 247  *
 248  * Note: only supports AF_INET routing socket.  Need to add AF_INET6 to
 249  * support IPv6.
 250  */
 251 /*ARGSUSED*/
 252 static void *
 253 smbd_nicmon_daemon(void *arg)
 254 {
 255         static uint32_t throttle;
 256         static int      rtsock_v4;
 257         static int      eventpipe_read = -1;
 258         struct pollfd   pollfds[2];
 259         int             pollfd_num = 2;
 260         int             i, nic_changed;
 261         int             rc;
 262
 263         if ((rtsock_v4 = smbd_nicmon_setup_rtsock(AF_INET)) == -1)
 264                 return (NULL);
 265
 266         rc = smbd_nicmon_setup_eventpipe(&eventpipe_read, &eventpipe_write);
 267         if (rc != 0)
 268                 return (NULL);
 269
 270         /*
 271          * Listen for activity on any of the sockets.
 272          * The delay before checking the rtsock will hopefully
 273          * smooth things out when there is a lot of activity.
 274          */
 275         for (;;) {
 276                 errno = 0;
 277                 nic_changed = 0;
 278                 pollfds[0].fd = rtsock_v4;
 279                 pollfds[0].events = POLLIN;
 280                 pollfds[1].fd = eventpipe_read;
 281                 pollfds[1].events = POLLIN;
 282
 283                 if (poll(pollfds, pollfd_num, -1) < 0) {
 284                         if (errno == EINTR)
 285                                 continue;
 286                         if ((throttle % SMBD_NICMON_THROTTLE) == 0)
 287                                 syslog(LOG_DEBUG,
 288                                     "smbd_nicmon: poll failed: %d", errno);
 289                         ++throttle;
 290                         break;
 291                 }
 292
 293                 for (i = 0; i < pollfd_num; i++) {
 294                         if ((pollfds[i].fd < 0) ||
 295                             !(pollfds[i].revents & POLLIN))
 296                                 continue;
 297                         if (pollfds[i].fd == rtsock_v4) {
 298                                 (void) sleep(SMBD_NICMON_DEBOUNCE);
 299                                 nic_changed = smbd_nicmon_needscan(rtsock_v4);
 300                         }
 301                         if (pollfds[i].fd == eventpipe_read)
 302                                 goto done;
 303                 }
 304
 305                 /*
 306                  * If the monitor is enabled and something has changed,
 307                  * refresh the registered SMF service.
 308                  */
 309                 if (smbd_nicmon_enabled && nic_changed &&
 310                     smbd_nicmon_caller_fmri) {
 311                         if (smf_refresh_instance(smbd_nicmon_caller_fmri) != 0)
 312                                 syslog(LOG_ERR,
 313                                     "smbd_nicmon: %s refresh failed",
 314                                     smbd_nicmon_caller_fmri);
 315                 }
 316         }
 317 done:
 318         (void) close(rtsock_v4);
 319         (void) close(eventpipe_read);
 320         (void) close(eventpipe_write);
 321         eventpipe_write = -1;
 322         return (NULL);
 323 }