[BACK]Return to dbus.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dnsmasq / src

Diff for /embedaddon/dnsmasq/src/dbus.c between versions 1.1.1.3 and 1.1.1.5

version 1.1.1.3, 2016/11/02 09:57:01 version 1.1.1.5, 2023/09/27 11:02:07
Line 1 Line 1
/* dnsmasq is Copyright (c) 2000-2016 Simon Kelley/* dnsmasq is Copyright (c) 2000-2022 Simon Kelley
   
    This program is free software; you can redistribute it and/or modify     This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by     it under the terms of the GNU General Public License as published by
Line 52  const char* introspection_xml_template = Line 52  const char* introspection_xml_template =
 "    <method name=\"SetFilterWin2KOption\">\n"  "    <method name=\"SetFilterWin2KOption\">\n"
 "      <arg name=\"filterwin2k\" direction=\"in\" type=\"b\"/>\n"  "      <arg name=\"filterwin2k\" direction=\"in\" type=\"b\"/>\n"
 "    </method>\n"  "    </method>\n"
   "    <method name=\"SetLocaliseQueriesOption\">\n"
   "      <arg name=\"localise-queries\" direction=\"in\" type=\"b\"/>\n"
   "    </method>\n"
 "    <method name=\"SetBogusPrivOption\">\n"  "    <method name=\"SetBogusPrivOption\">\n"
 "      <arg name=\"boguspriv\" direction=\"in\" type=\"b\"/>\n"  "      <arg name=\"boguspriv\" direction=\"in\" type=\"b\"/>\n"
 "    </method>\n"  "    </method>\n"
Line 85  const char* introspection_xml_template = Line 88  const char* introspection_xml_template =
 "       <arg name=\"success\" type=\"b\" direction=\"out\"/>\n"  "       <arg name=\"success\" type=\"b\" direction=\"out\"/>\n"
 "    </method>\n"  "    </method>\n"
 #endif  #endif
   "    <method name=\"GetMetrics\">\n"
   "      <arg name=\"metrics\" direction=\"out\" type=\"a{su}\"/>\n"
   "    </method>\n"
   "    <method name=\"GetServerMetrics\">\n"
   "      <arg name=\"metrics\" direction=\"out\" type=\"a{ss}\"/>\n"
   "    </method>\n"
   "    <method name=\"ClearMetrics\">\n"
   "    </method>\n"
 "  </interface>\n"  "  </interface>\n"
 "</node>\n";  "</node>\n";
   
Line 111  static dbus_bool_t add_watch(DBusWatch *watch, void *d Line 122  static dbus_bool_t add_watch(DBusWatch *watch, void *d
   w->next = daemon->watches;    w->next = daemon->watches;
   daemon->watches = w;    daemon->watches = w;
   
  w = data; /* no warning */  (void)data; /* no warning */
   return TRUE;    return TRUE;
 }  }
   
Line 131  static void remove_watch(DBusWatch *watch, void *data) Line 142  static void remove_watch(DBusWatch *watch, void *data)
         up = &(w->next);          up = &(w->next);
     }      }
   
  w = data; /* no warning */  (void)data; /* no warning */
 }  }
   
static void dbus_read_servers(DBusMessage *message)static DBusMessage* dbus_read_servers(DBusMessage *message)
 {  {
   DBusMessageIter iter;    DBusMessageIter iter;
   union  mysockaddr addr, source_addr;    union  mysockaddr addr, source_addr;
   char *domain;    char *domain;
       
  dbus_message_iter_init(message, &iter);  if (!dbus_message_iter_init(message, &iter))
     {
       return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
                                     "Failed to initialize dbus message iter");
     }
   
   mark_servers(SERV_FROM_DBUS);    mark_servers(SERV_FROM_DBUS);
       
Line 182  static void dbus_read_servers(DBusMessage *message) Line 197  static void dbus_read_servers(DBusMessage *message)
                 }                  }
             }              }
   
 #ifndef HAVE_IPV6  
           my_syslog(LOG_WARNING, _("attempt to set an IPv6 server address via DBus - no IPv6 support"));  
 #else  
           if (i == sizeof(struct in6_addr))            if (i == sizeof(struct in6_addr))
             {              {
               memcpy(&addr.in6.sin6_addr, p, sizeof(struct in6_addr));                memcpy(&addr.in6.sin6_addr, p, sizeof(struct in6_addr));
Line 199  static void dbus_read_servers(DBusMessage *message) Line 211  static void dbus_read_servers(DBusMessage *message)
               source_addr.in6.sin6_port = htons(daemon->query_port);                source_addr.in6.sin6_port = htons(daemon->query_port);
               skip = 0;                skip = 0;
             }              }
 #endif  
         }          }
       else        else
         /* At the end */          /* At the end */
Line 216  static void dbus_read_servers(DBusMessage *message) Line 227  static void dbus_read_servers(DBusMessage *message)
           domain = NULL;            domain = NULL;
                   
         if (!skip)          if (!skip)
          add_update_server(SERV_FROM_DBUS, &addr, &source_addr, NULL, domain);          add_update_server(SERV_FROM_DBUS, &addr, &source_addr, NULL, domain, NULL);
             
       } while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING);         } while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING); 
     }      }
         
   /* unlink and free anything still marked. */    /* unlink and free anything still marked. */
   cleanup_servers();    cleanup_servers();
     return NULL;
 }  }
   
 #ifdef HAVE_LOOP  #ifdef HAVE_LOOP
Line 238  static DBusMessage *dbus_reply_server_loop(DBusMessage Line 250  static DBusMessage *dbus_reply_server_loop(DBusMessage
   for (serv = daemon->servers; serv; serv = serv->next)    for (serv = daemon->servers; serv; serv = serv->next)
     if (serv->flags & SERV_LOOP)      if (serv->flags & SERV_LOOP)
       {        {
        prettyprint_addr(&serv->addr, daemon->addrbuff);        (void)prettyprint_addr(&serv->addr, daemon->addrbuff);
         dbus_message_iter_append_basic (&args_iter, DBUS_TYPE_STRING, &daemon->addrbuff);          dbus_message_iter_append_basic (&args_iter, DBUS_TYPE_STRING, &daemon->addrbuff);
       }        }
       
Line 277  static DBusMessage* dbus_read_servers_ex(DBusMessage * Line 289  static DBusMessage* dbus_read_servers_ex(DBusMessage *
     {      {
       const char *str = NULL;        const char *str = NULL;
       union  mysockaddr addr, source_addr;        union  mysockaddr addr, source_addr;
      int flags = 0;      u16 flags = 0;
       char interface[IF_NAMESIZE];        char interface[IF_NAMESIZE];
       char *str_addr, *str_domain = NULL;        char *str_addr, *str_domain = NULL;
         struct server_details sdetails = { 0 };
         sdetails.addr = &addr;
         sdetails.source_addr = &source_addr;
         sdetails.interface = interface;
         sdetails.flags = &flags;
   
       if (strings)        if (strings)
         {          {
Line 362  static DBusMessage* dbus_read_servers_ex(DBusMessage * Line 379  static DBusMessage* dbus_read_servers_ex(DBusMessage *
           strcpy(str_addr, str);            strcpy(str_addr, str);
         }          }
   
       memset(&addr, 0, sizeof(addr));  
       memset(&source_addr, 0, sizeof(source_addr));  
       memset(&interface, 0, sizeof(interface));  
   
       /* parse the IP address */  
       if ((addr_err = parse_server(str_addr, &addr, &source_addr, (char *) &interface, &flags)))  
         {  
           error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,  
                                                 "Invalid IP address '%s': %s",  
                                                 str, addr_err);  
           break;  
         }  
         
       /* 0.0.0.0 for server address == NULL, for Dbus */  
       if (addr.in.sin_family == AF_INET &&  
           addr.in.sin_addr.s_addr == 0)  
         flags |= SERV_NO_ADDR;  
         
       if (strings)        if (strings)
         {          {
           char *p;            char *p;
Line 393  static DBusMessage* dbus_read_servers_ex(DBusMessage * Line 392  static DBusMessage* dbus_read_servers_ex(DBusMessage *
             else               else 
               p = NULL;                p = NULL;
                           
            add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain);             if (strings && strlen(str_addr) == 0)
                add_update_server(SERV_LITERAL_ADDRESS | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain, NULL);
              else
                {
                  if ((addr_err = parse_server(str_addr, &sdetails)))
                    {
                      error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
                                                            "Invalid IP address '%s': %s",
                                                            str, addr_err);
                      break;
                    }
                  
                  while (parse_server_next(&sdetails))
                    {
                      if ((addr_err = parse_server_addr(&sdetails)))
                        {
                          error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
                                                                "Invalid IP address '%s': %s",
                                                                str, addr_err);
                          break;
                        }
                      
                      add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain, NULL);
                    }
                }
           } while ((str_domain = p));            } while ((str_domain = p));
         }          }
       else        else
Line 407  static DBusMessage* dbus_read_servers_ex(DBusMessage * Line 430  static DBusMessage* dbus_read_servers_ex(DBusMessage *
             if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)              if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)
               dbus_message_iter_get_basic(&string_iter, &str);                dbus_message_iter_get_basic(&string_iter, &str);
             dbus_message_iter_next (&string_iter);              dbus_message_iter_next (&string_iter);
   
               if ((addr_err = parse_server(str_addr, &sdetails)))
                 {
                   error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
                                                         "Invalid IP address '%s': %s",
                                                         str, addr_err);
                   break;
                 }
                           
            add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str);            while (parse_server_next(&sdetails))
               {
                 if ((addr_err = parse_server_addr(&sdetails)))
                   {
                     error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
                                                           "Invalid IP address '%s': %s",
                                                           str, addr_err);
                     break;
                   }
                 
                 /* 0.0.0.0 for server address == NULL, for Dbus */
                 if (addr.in.sin_family == AF_INET &&
                     addr.in.sin_addr.s_addr == 0)
                   flags |= SERV_LITERAL_ADDRESS;
                 else
                   flags &= ~SERV_LITERAL_ADDRESS;
                 
                 add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str, NULL);
               }
           } while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);            } while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
         }          }
               
       if (sdetails.orig_hostinfo)
         freeaddrinfo(sdetails.orig_hostinfo);
       
       /* jump to next element in outer array */        /* jump to next element in outer array */
       dbus_message_iter_next(&array_iter);        dbus_message_iter_next(&array_iter);
     }      }
   
   cleanup_servers();    cleanup_servers();
    
   if (dup)    if (dup)
     free(dup);      free(dup);
   
Line 457  static DBusMessage *dbus_add_lease(DBusMessage* messag Line 509  static DBusMessage *dbus_add_lease(DBusMessage* messag
   int clid_len, hostname_len, hw_len, hw_type;    int clid_len, hostname_len, hw_len, hw_type;
   dbus_uint32_t expires, ia_id;    dbus_uint32_t expires, ia_id;
   dbus_bool_t is_temporary;    dbus_bool_t is_temporary;
  struct all_addr addr;  union all_addr addr;
   time_t now = dnsmasq_time();    time_t now = dnsmasq_time();
   unsigned char dhcp_chaddr[DHCP_CHADDR_MAX];    unsigned char dhcp_chaddr[DHCP_CHADDR_MAX];
   
Line 527  static DBusMessage *dbus_add_lease(DBusMessage* messag Line 579  static DBusMessage *dbus_add_lease(DBusMessage* messag
   
   dbus_message_iter_get_basic(&iter, &is_temporary);    dbus_message_iter_get_basic(&iter, &is_temporary);
   
  if (inet_pton(AF_INET, ipaddr, &addr.addr.addr4))  if (inet_pton(AF_INET, ipaddr, &addr.addr4))
     {      {
       if (ia_id != 0 || is_temporary)        if (ia_id != 0 || is_temporary)
         return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,          return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
                                       "ia_id and is_temporary must be zero for IPv4 lease");                                        "ia_id and is_temporary must be zero for IPv4 lease");
               
      if (!(lease = lease_find_by_addr(addr.addr.addr4)))      if (!(lease = lease_find_by_addr(addr.addr4)))
        lease = lease4_allocate(addr.addr.addr4);        lease = lease4_allocate(addr.addr4);
     }      }
 #ifdef HAVE_DHCP6  #ifdef HAVE_DHCP6
  else if (inet_pton(AF_INET6, ipaddr, &addr.addr.addr6))  else if (inet_pton(AF_INET6, ipaddr, &addr.addr6))
     {      {
      if (!(lease = lease6_find_by_addr(&addr.addr.addr6, 128, 0)))      if (!(lease = lease6_find_by_addr(&addr.addr6, 128, 0)))
        lease = lease6_allocate(&addr.addr.addr6,        lease = lease6_allocate(&addr.addr6,
                                 is_temporary ? LEASE_TA : LEASE_NA);                                  is_temporary ? LEASE_TA : LEASE_NA);
       lease_set_iaid(lease, ia_id);        lease_set_iaid(lease, ia_id);
     }      }
Line 549  static DBusMessage *dbus_add_lease(DBusMessage* messag Line 601  static DBusMessage *dbus_add_lease(DBusMessage* messag
     return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,      return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
                                          "Invalid IP address '%s'", ipaddr);                                           "Invalid IP address '%s'", ipaddr);
         
  hw_len = parse_hex((char*)hwaddr, dhcp_chaddr, DHCP_CHADDR_MAX, NULL,  hw_len = parse_hex((char*)hwaddr, dhcp_chaddr, DHCP_CHADDR_MAX, NULL, &hw_type);
                     &hw_type);  if (hw_len < 0)
     return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
                                          "Invalid HW address '%s'", hwaddr);
 
   if (hw_type == 0 && hw_len != 0)    if (hw_type == 0 && hw_len != 0)
     hw_type = ARPHRD_ETHER;      hw_type = ARPHRD_ETHER;
  
    lease_set_hwaddr(lease, dhcp_chaddr, clid, hw_len, hw_type,  lease_set_hwaddr(lease, dhcp_chaddr, clid, hw_len, hw_type,
                    clid_len, now, 0);                     clid_len, now, 0);
   lease_set_expires(lease, expires, now);    lease_set_expires(lease, expires, now);
   if (hostname_len != 0)    if (hostname_len != 0)
     lease_set_hostname(lease, hostname, 0, get_domain(lease->addr), NULL);      lease_set_hostname(lease, hostname, 0, get_domain(lease->addr), NULL);
      
   lease_update_file(now);    lease_update_file(now);
   lease_update_dns(0);    lease_update_dns(0);
   
Line 572  static DBusMessage *dbus_del_lease(DBusMessage* messag Line 627  static DBusMessage *dbus_del_lease(DBusMessage* messag
   DBusMessageIter iter;    DBusMessageIter iter;
   const char *ipaddr;    const char *ipaddr;
   DBusMessage *reply;    DBusMessage *reply;
  struct all_addr addr;  union all_addr addr;
   dbus_bool_t ret = 1;    dbus_bool_t ret = 1;
   time_t now = dnsmasq_time();    time_t now = dnsmasq_time();
   
Line 586  static DBusMessage *dbus_del_lease(DBusMessage* messag Line 641  static DBusMessage *dbus_del_lease(DBusMessage* messag
         
   dbus_message_iter_get_basic(&iter, &ipaddr);    dbus_message_iter_get_basic(&iter, &ipaddr);
   
  if (inet_pton(AF_INET, ipaddr, &addr.addr.addr4))  if (inet_pton(AF_INET, ipaddr, &addr.addr4))
    lease = lease_find_by_addr(addr.addr.addr4);    lease = lease_find_by_addr(addr.addr4);
 #ifdef HAVE_DHCP6  #ifdef HAVE_DHCP6
  else if (inet_pton(AF_INET6, ipaddr, &addr.addr.addr6))  else if (inet_pton(AF_INET6, ipaddr, &addr.addr6))
    lease = lease6_find_by_addr(&addr.addr.addr6, 128, 0);    lease = lease6_find_by_addr(&addr.addr6, 128, 0);
 #endif  #endif
   else    else
     return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,      return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
Line 614  static DBusMessage *dbus_del_lease(DBusMessage* messag Line 669  static DBusMessage *dbus_del_lease(DBusMessage* messag
 }  }
 #endif  #endif
   
   static DBusMessage *dbus_get_metrics(DBusMessage* message)
   {
     DBusMessage *reply = dbus_message_new_method_return(message);
     DBusMessageIter array, dict, iter;
     int i;
   
     dbus_message_iter_init_append(reply, &iter);
     dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{su}", &array);
   
     for (i = 0; i < __METRIC_MAX; i++) {
       const char *key     = get_metric_name(i);
       dbus_uint32_t value = daemon->metrics[i];
   
       dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, NULL, &dict);
       dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &key);
       dbus_message_iter_append_basic(&dict, DBUS_TYPE_UINT32, &value);
       dbus_message_iter_close_container(&array, &dict);
     }
   
     dbus_message_iter_close_container(&iter, &array);
   
     return reply;
   }
   
   static void add_dict_entry(DBusMessageIter *container, const char *key, const char *val)
   {
     DBusMessageIter dict;
   
     dbus_message_iter_open_container(container, DBUS_TYPE_DICT_ENTRY, NULL, &dict);
     dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &key);
     dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &val);
     dbus_message_iter_close_container(container, &dict);
   }
   
   static void add_dict_int(DBusMessageIter *container, const char *key, const unsigned int val)
   {
     snprintf(daemon->namebuff, MAXDNAME, "%u", val);
     
     add_dict_entry(container, key, daemon->namebuff);
   }
   
   static DBusMessage *dbus_get_server_metrics(DBusMessage* message)
   {
     DBusMessage *reply = dbus_message_new_method_return(message);
     DBusMessageIter server_array, dict_array, server_iter;
     struct server *serv;
     
     dbus_message_iter_init_append(reply, &server_iter);
     dbus_message_iter_open_container(&server_iter, DBUS_TYPE_ARRAY, "a{ss}", &server_array);
   
     /* sum counts from different records for same server */
     for (serv = daemon->servers; serv; serv = serv->next)
       serv->flags &= ~SERV_MARK;
     
     for (serv = daemon->servers; serv; serv = serv->next)
       if (!(serv->flags & SERV_MARK))
         {
           unsigned int port;
           unsigned int queries = 0, failed_queries = 0, nxdomain_replies = 0, retrys = 0;
           unsigned int sigma_latency = 0, count_latency = 0;
           
           struct server *serv1;
   
           for (serv1 = serv; serv1; serv1 = serv1->next)
             if (!(serv1->flags & SERV_MARK) && sockaddr_isequal(&serv->addr, &serv1->addr))
               {
                 serv1->flags |= SERV_MARK;
                 queries += serv1->queries;
                 failed_queries += serv1->failed_queries;
                 nxdomain_replies += serv1->nxdomain_replies;
                 retrys += serv1->retrys;
                 sigma_latency += serv1->query_latency;
                 count_latency++;
               }
           
           dbus_message_iter_open_container(&server_array, DBUS_TYPE_ARRAY, "{ss}", &dict_array);
           
           port = prettyprint_addr(&serv->addr, daemon->namebuff);
           add_dict_entry(&dict_array, "address", daemon->namebuff);
           
           add_dict_int(&dict_array, "port", port);
           add_dict_int(&dict_array, "queries", serv->queries);
           add_dict_int(&dict_array, "failed_queries", serv->failed_queries);
           add_dict_int(&dict_array, "nxdomain", serv->nxdomain_replies);
           add_dict_int(&dict_array, "retries", serv->retrys);
           add_dict_int(&dict_array, "latency", sigma_latency/count_latency);
           
           dbus_message_iter_close_container(&server_array, &dict_array);
         }
     
     dbus_message_iter_close_container(&server_iter, &server_array);
     
     return reply;
   }
   
 DBusHandlerResult message_handler(DBusConnection *connection,   DBusHandlerResult message_handler(DBusConnection *connection, 
                                   DBusMessage *message,                                     DBusMessage *message, 
                                   void *user_data)                                    void *user_data)
Line 650  DBusHandlerResult message_handler(DBusConnection *conn Line 800  DBusHandlerResult message_handler(DBusConnection *conn
 #endif  #endif
   else if (strcmp(method, "SetServers") == 0)    else if (strcmp(method, "SetServers") == 0)
     {      {
      dbus_read_servers(message);      reply = dbus_read_servers(message);
       new_servers = 1;        new_servers = 1;
     }      }
   else if (strcmp(method, "SetServersEx") == 0)    else if (strcmp(method, "SetServersEx") == 0)
Line 667  DBusHandlerResult message_handler(DBusConnection *conn Line 817  DBusHandlerResult message_handler(DBusConnection *conn
     {      {
       reply = dbus_set_bool(message, OPT_FILTER, "filterwin2k");        reply = dbus_set_bool(message, OPT_FILTER, "filterwin2k");
     }      }
     else if (strcmp(method, "SetLocaliseQueriesOption") == 0)
       {
         reply = dbus_set_bool(message, OPT_LOCALISE, "localise-queries");
       }
   else if (strcmp(method, "SetBogusPrivOption") == 0)    else if (strcmp(method, "SetBogusPrivOption") == 0)
     {      {
       reply = dbus_set_bool(message, OPT_BOGUSPRIV, "bogus-priv");        reply = dbus_set_bool(message, OPT_BOGUSPRIV, "bogus-priv");
Line 681  DBusHandlerResult message_handler(DBusConnection *conn Line 835  DBusHandlerResult message_handler(DBusConnection *conn
       reply = dbus_del_lease(message);        reply = dbus_del_lease(message);
     }      }
 #endif  #endif
     else if (strcmp(method, "GetMetrics") == 0)
       {
         reply = dbus_get_metrics(message);
       }
     else if (strcmp(method, "GetServerMetrics") == 0)
       {
         reply = dbus_get_server_metrics(message);
       }
     else if (strcmp(method, "ClearMetrics") == 0)
       {
         clear_metrics();
       }
   else if (strcmp(method, "ClearCache") == 0)    else if (strcmp(method, "ClearCache") == 0)
     clear_cache = 1;      clear_cache = 1;
   else    else
Line 689  DBusHandlerResult message_handler(DBusConnection *conn Line 855  DBusHandlerResult message_handler(DBusConnection *conn
   if (new_servers)    if (new_servers)
     {      {
       my_syslog(LOG_INFO, _("setting upstream servers from DBus"));        my_syslog(LOG_INFO, _("setting upstream servers from DBus"));
      check_servers();      check_servers(0);
       if (option_bool(OPT_RELOAD))        if (option_bool(OPT_RELOAD))
         clear_cache = 1;          clear_cache = 1;
     }      }
Line 697  DBusHandlerResult message_handler(DBusConnection *conn Line 863  DBusHandlerResult message_handler(DBusConnection *conn
   if (clear_cache)    if (clear_cache)
     clear_cache_and_reload(dnsmasq_time());      clear_cache_and_reload(dnsmasq_time());
       
  method = user_data; /* no warning */  (void)user_data; /* no warning */
   
   /* If no reply or no error, return nothing */    /* If no reply or no error, return nothing */
   if (!reply)    if (!reply)
Line 723  char *dbus_init(void) Line 889  char *dbus_init(void)
   
   dbus_error_init (&dbus_error);    dbus_error_init (&dbus_error);
   if (!(connection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbus_error)))    if (!(connection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbus_error)))
    return NULL;    {
          dbus_error_free(&dbus_error);
       return NULL;
     }
   
   dbus_connection_set_exit_on_disconnect(connection, FALSE);    dbus_connection_set_exit_on_disconnect(connection, FALSE);
   dbus_connection_set_watch_functions(connection, add_watch, remove_watch,     dbus_connection_set_watch_functions(connection, add_watch, remove_watch, 
                                       NULL, NULL, NULL);                                        NULL, NULL, NULL);
Removed from v.1.1.1.3  
changed lines
  Added in v.1.1.1.5

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>