secchan/discovery.c

   1 /*
   2  * Copyright (c) 2008, 2009 Nicira Networks.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <config.h>
  18 #include "discovery.h"
  19 #include <errno.h>
  20 #include <inttypes.h>
  21 #include <net/if.h>
  22 #include <regex.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include "dhcp-client.h"
  26 #include "dhcp.h"
  27 #include "dpif.h"
  28 #include "netdev.h"
  29 #include "openflow/openflow.h"
  30 #include "packets.h"
  31 #include "status.h"
  32 #include "vconn-ssl.h"
  33
  34 #define THIS_MODULE VLM_discovery
  35 #include "vlog.h"
  36
  37 struct discovery {
  38     char *re;
  39     bool update_resolv_conf;
  40     regex_t *regex;
  41     struct dhclient *dhcp;
  42     int n_changes;
  43     struct status_category *ss_cat;
  44 };
  45
  46 static void modify_dhcp_request(struct dhcp_msg *, void *aux);
  47 static bool validate_dhcp_offer(const struct dhcp_msg *, void *aux);
  48
  49 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(60, 60);
  50
  51 static void
  52 discovery_status_cb(struct status_reply *sr, void *d_)
  53 {
  54     struct discovery *d = d_;
  55
  56     status_reply_put(sr, "accept-remote=%s", d->re);
  57     status_reply_put(sr, "n-changes=%d", d->n_changes);
  58     if (d->dhcp) {
  59         status_reply_put(sr, "state=%s", dhclient_get_state(d->dhcp));
  60         status_reply_put(sr, "state-elapsed=%u",
  61                          dhclient_get_state_elapsed(d->dhcp));
  62         if (dhclient_is_bound(d->dhcp)) {
  63             uint32_t ip = dhclient_get_ip(d->dhcp);
  64             uint32_t netmask = dhclient_get_netmask(d->dhcp);
  65             uint32_t router = dhclient_get_router(d->dhcp);
  66
  67             const struct dhcp_msg *cfg = dhclient_get_config(d->dhcp);
  68             uint32_t dns_server;
  69             char *domain_name;
  70             int i;
  71
  72             status_reply_put(sr, "ip="IP_FMT, IP_ARGS(&ip));
  73             status_reply_put(sr, "netmask="IP_FMT, IP_ARGS(&netmask));
  74             if (router) {
  75                 status_reply_put(sr, "router="IP_FMT, IP_ARGS(&router));
  76             }
  77
  78             for (i = 0; dhcp_msg_get_ip(cfg, DHCP_CODE_DNS_SERVER, i,
  79                                         &dns_server);
  80                  i++) {
  81                 status_reply_put(sr, "dns%d="IP_FMT, i, IP_ARGS(&dns_server));
  82             }
  83
  84             domain_name = dhcp_msg_get_string(cfg, DHCP_CODE_DOMAIN_NAME);
  85             if (domain_name) {
  86                 status_reply_put(sr, "domain=%s", domain_name);
  87                 free(domain_name);
  88             }
  89
  90             status_reply_put(sr, "lease-remaining=%u",
  91                              dhclient_get_lease_remaining(d->dhcp));
  92         }
  93     }
  94 }
  95
  96 int
  97 discovery_create(const char *re, bool update_resolv_conf,
  98                  struct dpif *dpif, struct switch_status *ss,
  99                  struct discovery **discoveryp)
 100 {
 101     struct discovery *d;
 102     char local_name[IF_NAMESIZE];
 103     int error;
 104
 105     d = xcalloc(1, sizeof *d);
 106
 107     /* Controller regular expression. */
 108     error = discovery_set_accept_controller_re(d, re);
 109     if (error) {
 110         goto error_free;
 111     }
 112     d->update_resolv_conf = update_resolv_conf;
 113
 114     /* Initialize DHCP client. */
 115     error = dpif_get_name(dpif, local_name, sizeof local_name);
 116     if (error) {
 117         VLOG_ERR("failed to query datapath local port: %s", strerror(error));
 118         goto error_regfree;
 119     }
 120     error = dhclient_create(local_name, modify_dhcp_request,
 121                             validate_dhcp_offer, d, &d->dhcp);
 122     if (error) {
 123         VLOG_ERR("failed to initialize DHCP client: %s", strerror(error));
 124         goto error_regfree;
 125     }
 126     dhclient_set_max_timeout(d->dhcp, 3);
 127     dhclient_init(d->dhcp, 0);
 128
 129     d->ss_cat = switch_status_register(ss, "discovery",
 130                                        discovery_status_cb, d);
 131
 132     *discoveryp = d;
 133     return 0;
 134
 135 error_regfree:
 136     regfree(d->regex);
 137     free(d->regex);
 138 error_free:
 139     free(d);
 140     *discoveryp = 0;
 141     return error;
 142 }
 143
 144 void
 145 discovery_destroy(struct discovery *d)
 146 {
 147     if (d) {
 148         free(d->re);
 149         regfree(d->regex);
 150         free(d->regex);
 151         dhclient_destroy(d->dhcp);
 152         switch_status_unregister(d->ss_cat);
 153         free(d);
 154     }
 155 }
 156
 157 void
 158 discovery_set_update_resolv_conf(struct discovery *d,
 159                                  bool update_resolv_conf)
 160 {
 161     d->update_resolv_conf = update_resolv_conf;
 162 }
 163
 164 int
 165 discovery_set_accept_controller_re(struct discovery *d, const char *re_)
 166 {
 167     regex_t *regex;
 168     int error;
 169     char *re;
 170
 171     re = (!re_ ? xstrdup(vconn_ssl_is_configured() ? "^ssl:.*" : ".*")
 172           : re_[0] == '^' ? xstrdup(re_) : xasprintf("^%s", re_));
 173     regex = xmalloc(sizeof *regex);
 174     error = regcomp(regex, re, REG_NOSUB | REG_EXTENDED);
 175     if (error) {
 176         size_t length = regerror(error, regex, NULL, 0);
 177         char *buffer = xmalloc(length);
 178         regerror(error, regex, buffer, length);
 179         VLOG_WARN("%s: %s", re, buffer);
 180         free(regex);
 181         free(re);
 182         return EINVAL;
 183     } else {
 184         if (d->regex) {
 185             regfree(d->regex);
 186             free(d->regex);
 187         }
 188         free(d->re);
 189
 190         d->regex = regex;
 191         d->re = re;
 192         return 0;
 193     }
 194 }
 195
 196 void
 197 discovery_question_connectivity(struct discovery *d)
 198 {
 199     if (d->dhcp) {
 200         dhclient_force_renew(d->dhcp, 15);
 201     }
 202 }
 203
 204 bool
 205 discovery_run(struct discovery *d, char **controller_name)
 206 {
 207     if (!d->dhcp) {
 208         *controller_name = NULL;
 209         return true;
 210     }
 211
 212     dhclient_run(d->dhcp);
 213     if (!dhclient_changed(d->dhcp)) {
 214         return false;
 215     }
 216
 217     dhclient_configure_netdev(d->dhcp);
 218     if (d->update_resolv_conf) {
 219         dhclient_update_resolv_conf(d->dhcp);
 220     }
 221
 222     if (dhclient_is_bound(d->dhcp)) {
 223         *controller_name = dhcp_msg_get_string(dhclient_get_config(d->dhcp),
 224                                                DHCP_CODE_OFP_CONTROLLER_VCONN);
 225         VLOG_INFO("%s: discovered controller", *controller_name);
 226         d->n_changes++;
 227     } else {
 228         *controller_name = NULL;
 229         if (d->n_changes) {
 230             VLOG_INFO("discovered controller no longer available");
 231             d->n_changes++;
 232         }
 233     }
 234     return true;
 235 }
 236
 237 void
 238 discovery_wait(struct discovery *d)
 239 {
 240     if (d->dhcp) {
 241         dhclient_wait(d->dhcp);
 242     }
 243 }
 244
 245 static void
 246 modify_dhcp_request(struct dhcp_msg *msg, void *aux UNUSED)
 247 {
 248     dhcp_msg_put_string(msg, DHCP_CODE_VENDOR_CLASS, "OpenFlow");
 249 }
 250
 251 static bool
 252 validate_dhcp_offer(const struct dhcp_msg *msg, void *d_)
 253 {
 254     const struct discovery *d = d_;
 255     char *vconn_name;
 256     bool accept;
 257
 258     vconn_name = dhcp_msg_get_string(msg, DHCP_CODE_OFP_CONTROLLER_VCONN);
 259     if (!vconn_name) {
 260         VLOG_WARN_RL(&rl, "rejecting DHCP offer missing controller vconn");
 261         return false;
 262     }
 263     accept = !regexec(d->regex, vconn_name, 0, NULL, 0);
 264     if (!accept) {
 265         VLOG_WARN_RL(&rl, "rejecting controller vconn that fails to match %s",
 266                      d->re);
 267     }
 268     free(vconn_name);
 269     return accept;
 270 }