[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.1 and 1.1.1.2

version 1.1.1.1, 2013/07/29 19:37:40 version 1.1.1.2, 2014/06/15 16:31:38
Line 1 Line 1
/* dnsmasq is Copyright (c) 2000-2013 Simon Kelley/* dnsmasq is Copyright (c) 2000-2014 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 108  static void remove_watch(DBusWatch *watch, void *data) Line 108  static void remove_watch(DBusWatch *watch, void *data)
   w = data; /* no warning */    w = data; /* no warning */
 }  }
   
 static void add_update_server(union mysockaddr *addr,  
                               union mysockaddr *source_addr,  
                               const char *interface,  
                               const char *domain)  
 {  
   struct server *serv;  
   
   /* See if there is a suitable candidate, and unmark */  
   for (serv = daemon->servers; serv; serv = serv->next)  
     if ((serv->flags & SERV_FROM_DBUS) &&  
        (serv->flags & SERV_MARK))  
       {  
         if (domain)  
           {  
             if (!(serv->flags & SERV_HAS_DOMAIN) || !hostname_isequal(domain, serv->domain))  
               continue;  
           }  
         else  
           {  
             if (serv->flags & SERV_HAS_DOMAIN)  
               continue;  
           }  
           
         serv->flags &= ~SERV_MARK;  
   
         break;  
       }  
     
   if (!serv && (serv = whine_malloc(sizeof (struct server))))  
     {  
       /* Not found, create a new one. */  
       memset(serv, 0, sizeof(struct server));  
         
       if (domain && !(serv->domain = whine_malloc(strlen(domain)+1)))  
         {  
           free(serv);  
           serv = NULL;  
         }  
       else  
         {  
           serv->next = daemon->servers;  
           daemon->servers = serv;  
           serv->flags = SERV_FROM_DBUS;  
           if (domain)  
             {  
               strcpy(serv->domain, domain);  
               serv->flags |= SERV_HAS_DOMAIN;  
             }  
         }  
     }  
     
   if (serv)  
     {  
       if (interface)  
         strcpy(serv->interface, interface);  
       else  
         serv->interface[0] = 0;  
               
       if (source_addr->in.sin_family == AF_INET &&  
           addr->in.sin_addr.s_addr == 0 &&  
           serv->domain)  
         serv->flags |= SERV_NO_ADDR;  
       else  
         {  
           serv->flags &= ~SERV_NO_ADDR;  
           serv->addr = *addr;  
           serv->source_addr = *source_addr;  
         }  
     }  
 }  
   
 static void mark_dbus(void)  
 {  
   struct server *serv;  
   
   /* mark everything from DBUS */  
   for (serv = daemon->servers; serv; serv = serv->next)  
     if (serv->flags & SERV_FROM_DBUS)  
       serv->flags |= SERV_MARK;  
 }  
   
 static void cleanup_dbus()  
 {  
   struct server *serv, *tmp, **up;  
   
   /* unlink and free anything still marked. */  
   for (serv = daemon->servers, up = &daemon->servers; serv; serv = tmp)   
     {  
       tmp = serv->next;  
       if (serv->flags & SERV_MARK)  
        {  
          server_gone(serv);  
          *up = serv->next;  
          if (serv->domain)  
            free(serv->domain);  
          free(serv);  
        }  
       else   
        up = &serv->next;  
     }  
 }  
   
 static void dbus_read_servers(DBusMessage *message)  static void dbus_read_servers(DBusMessage *message)
 {  {
   DBusMessageIter iter;    DBusMessageIter iter;
Line 218  static void dbus_read_servers(DBusMessage *message) Line 116  static void dbus_read_servers(DBusMessage *message)
       
   dbus_message_iter_init(message, &iter);    dbus_message_iter_init(message, &iter);
   
  mark_dbus();  mark_servers(SERV_FROM_DBUS);
  
   while (1)    while (1)
     {      {
       int skip = 0;        int skip = 0;
Line 289  static void dbus_read_servers(DBusMessage *message) Line 187  static void dbus_read_servers(DBusMessage *message)
           domain = NULL;            domain = NULL;
                   
         if (!skip)          if (!skip)
          add_update_server(&addr, &source_addr, NULL, domain);          add_update_server(SERV_FROM_DBUS, &addr, &source_addr, NULL, domain);
             
       } 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_dbus();  cleanup_servers();
 }  }
   
 static DBusMessage* dbus_read_servers_ex(DBusMessage *message, int strings)  static DBusMessage* dbus_read_servers_ex(DBusMessage *message, int strings)
Line 305  static DBusMessage* dbus_read_servers_ex(DBusMessage * Line 203  static DBusMessage* dbus_read_servers_ex(DBusMessage *
   const char *addr_err;    const char *addr_err;
   char *dup = NULL;    char *dup = NULL;
       
   my_syslog(LOG_INFO, _("setting upstream servers from DBus"));  
     
   if (!dbus_message_iter_init(message, &iter))    if (!dbus_message_iter_init(message, &iter))
     {      {
       return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,        return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
Line 321  static DBusMessage* dbus_read_servers_ex(DBusMessage * Line 217  static DBusMessage* dbus_read_servers_ex(DBusMessage *
                                     strings ? "Expected array of string" : "Expected array of string arrays");                                      strings ? "Expected array of string" : "Expected array of string arrays");
      }       }
     
  mark_dbus();  mark_servers(SERV_FROM_DBUS);
   
   /* array_iter points to each "as" element in the outer array */    /* array_iter points to each "as" element in the outer array */
   dbus_message_iter_recurse(&iter, &array_iter);    dbus_message_iter_recurse(&iter, &array_iter);
Line 329  static DBusMessage* dbus_read_servers_ex(DBusMessage * Line 225  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;
       char interface[IF_NAMESIZE];        char interface[IF_NAMESIZE];
       char *str_addr, *str_domain = NULL;        char *str_addr, *str_domain = NULL;
   
Line 418  static DBusMessage* dbus_read_servers_ex(DBusMessage * Line 315  static DBusMessage* dbus_read_servers_ex(DBusMessage *
       memset(&interface, 0, sizeof(interface));        memset(&interface, 0, sizeof(interface));
   
       /* parse the IP address */        /* parse the IP address */
      addr_err = parse_server(str_addr, &addr, &source_addr, (char *) &interface, NULL);      if ((addr_err = parse_server(str_addr, &addr, &source_addr, (char *) &interface, &flags)))
        {
      if (addr_err) 
        { 
           error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,            error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
                                                 "Invalid IP address '%s': %s",                                                  "Invalid IP address '%s': %s",
                                                 str, addr_err);                                                  str, addr_err);
           break;            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 441  static DBusMessage* dbus_read_servers_ex(DBusMessage * Line 341  static DBusMessage* dbus_read_servers_ex(DBusMessage *
             else               else 
               p = NULL;                p = NULL;
                           
            add_update_server(&addr, &source_addr, interface, str_domain);            add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain);
           } while ((str_domain = p));            } while ((str_domain = p));
         }          }
       else        else
Line 456  static DBusMessage* dbus_read_servers_ex(DBusMessage * Line 356  static DBusMessage* dbus_read_servers_ex(DBusMessage *
               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);
                           
            add_update_server(&addr, &source_addr, interface, str);            add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str);
           } while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);            } while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
         }          }
                     
Line 464  static DBusMessage* dbus_read_servers_ex(DBusMessage * Line 364  static DBusMessage* dbus_read_servers_ex(DBusMessage *
       dbus_message_iter_next(&array_iter);        dbus_message_iter_next(&array_iter);
     }      }
   
  cleanup_dbus();  cleanup_servers();
   
   if (dup)    if (dup)
     free(dup);      free(dup);
Line 478  DBusHandlerResult message_handler(DBusConnection *conn Line 378  DBusHandlerResult message_handler(DBusConnection *conn
 {  {
   char *method = (char *)dbus_message_get_member(message);    char *method = (char *)dbus_message_get_member(message);
   DBusMessage *reply = NULL;    DBusMessage *reply = NULL;
     int clear_cache = 0, new_servers = 0;
           
   if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))    if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
     {      {
Line 501  DBusHandlerResult message_handler(DBusConnection *conn Line 402  DBusHandlerResult message_handler(DBusConnection *conn
     }      }
   else if (strcmp(method, "SetServers") == 0)    else if (strcmp(method, "SetServers") == 0)
     {      {
       my_syslog(LOG_INFO, _("setting upstream servers from DBus"));  
       dbus_read_servers(message);        dbus_read_servers(message);
      check_servers();      new_servers = 1;
     }      }
   else if (strcmp(method, "SetServersEx") == 0)    else if (strcmp(method, "SetServersEx") == 0)
     {      {
       reply = dbus_read_servers_ex(message, 0);        reply = dbus_read_servers_ex(message, 0);
      check_servers();      new_servers = 1;
     }      }
   else if (strcmp(method, "SetDomainServers") == 0)    else if (strcmp(method, "SetDomainServers") == 0)
     {      {
       reply = dbus_read_servers_ex(message, 1);        reply = dbus_read_servers_ex(message, 1);
      check_servers();      new_servers = 1;
     }      }
   else if (strcmp(method, "ClearCache") == 0)    else if (strcmp(method, "ClearCache") == 0)
    clear_cache_and_reload(dnsmasq_time());    clear_cache = 1;
   else    else
     return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED);      return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
      
     if (new_servers)
       {
         my_syslog(LOG_INFO, _("setting upstream servers from DBus"));
         check_servers();
         if (option_bool(OPT_RELOAD))
           clear_cache = 1;
       }
   
     if (clear_cache)
       clear_cache_and_reload(dnsmasq_time());
       
   method = user_data; /* no warning */    method = user_data; /* no warning */
   
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.2

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