/* -*- mode: C; c-file-style: "gnu" -*- */

 /* expirelist.c  List of items that expire

  *

  * Copyright (C) 2003  Red Hat, Inc.

  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

  * Licensed under the Academic Free License version 2.1

  *

  * 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

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  *

  */

 #include "expirelist.h"

 #include "test.h"

 #ifndef __SYMBIAN32__

 #include <dbus/dbus-internals.h>

 #include <dbus/dbus-mainloop.h>

 #include <dbus/dbus-timeout.h>

 #else

 #include "dbus-internals.h"

 #include "dbus-mainloop.h"

 #include "dbus-timeout.h"

 #endif //__SYMBIAN32__

 static dbus_bool_t expire_timeout_handler (void *data);

 static void

 call_timeout_callback (DBusTimeout   *timeout,

                        void          *data)

 {

   /* can return FALSE on OOM but we just let it fire again later */

   dbus_timeout_handle (timeout);

 }

 BusExpireList*

 bus_expire_list_new (DBusLoop      *loop,

                      int            expire_after,

                      BusExpireFunc  expire_func,

                      void          *data)

 {

   BusExpireList *list;

   list = dbus_new0 (BusExpireList, 1);

   if (list == NULL)

     return NULL;

   list->expire_func = expire_func;

   list->data = data;

   list->loop = loop;

   list->expire_after = expire_after;

   list->timeout = _dbus_timeout_new (100, /* irrelevant */

                                      expire_timeout_handler,

                                      list, NULL);

   if (list->timeout == NULL)

     goto failed;

   _dbus_timeout_set_enabled (list->timeout, FALSE);

   if (!_dbus_loop_add_timeout (list->loop,

                                list->timeout,

                                call_timeout_callback, NULL, NULL))

     goto failed;

   return list;

  failed:

   if (list->timeout)

     _dbus_timeout_unref (list->timeout);

   dbus_free (list);

   return NULL;

 }

 void

 bus_expire_list_free (BusExpireList *list)

 {

   _dbus_assert (list->items == NULL);

   _dbus_loop_remove_timeout (list->loop, list->timeout,

                              call_timeout_callback, NULL);

   _dbus_timeout_unref (list->timeout);

   dbus_free (list);

 }

 void

 bus_expire_timeout_set_interval (DBusTimeout *timeout,

                                  int          next_interval)

 {

   if (next_interval >= 0)

     {

       _dbus_timeout_set_interval (timeout,

                                   next_interval);

       _dbus_timeout_set_enabled (timeout, TRUE);

       _dbus_verbose ("Enabled expire timeout with interval %d\n",

                      next_interval);

     }

   else if (dbus_timeout_get_enabled (timeout))

     {

       _dbus_timeout_set_enabled (timeout, FALSE);

       _dbus_verbose ("Disabled expire timeout\n");

     }

   else

     _dbus_verbose ("No need to disable expire timeout\n");

 }

 static int

 do_expiration_with_current_time (BusExpireList *list,

                                  long           tv_sec,

                                  long           tv_usec)

 {

   DBusList *link;

   int next_interval;

   next_interval = -1;

   link = _dbus_list_get_first_link (&list->items);

   while (link != NULL)

     {

       DBusList *next = _dbus_list_get_next_link (&list->items, link);

       double elapsed;

       BusExpireItem *item;

       item = link->data;

       elapsed = ELAPSED_MILLISECONDS_SINCE (item->added_tv_sec,

                                             item->added_tv_usec,

                                             tv_sec, tv_usec);

       if (elapsed >= (double) list->expire_after)

         {

           _dbus_verbose ("Expiring an item %p\n", item);

           /* If the expire function fails, we just end up expiring

            * this item next time we walk through the list. This would

            * be an indeterminate time normally, so we set up the

            * next_interval to be "shortly" (just enough to avoid

            * a busy loop)

            */

           if (!(* list->expire_func) (list, link, list->data))

             {

               next_interval = _dbus_get_oom_wait ();

               break;

             }

         }

       else

         {

           /* We can end the loop, since the connections are in oldest-first order */

           next_interval = ((double)list->expire_after) - elapsed;

           _dbus_verbose ("Item %p expires in %d milliseconds\n",

                          item, next_interval);

           break;

         }

       link = next;

     }

   return next_interval;

 }

 static void

 bus_expirelist_expire (BusExpireList *list)

 {

   int next_interval;

   next_interval = -1;

   if (list->items != NULL)

     {

       long tv_sec, tv_usec;

       _dbus_get_current_time (&tv_sec, &tv_usec);

       next_interval = do_expiration_with_current_time (list, tv_sec, tv_usec);

     }

   bus_expire_timeout_set_interval (list->timeout, next_interval);

 }

 static dbus_bool_t

 expire_timeout_handler (void *data)

 {

   BusExpireList *list = data;

   _dbus_verbose ("Running %s\n", _DBUS_FUNCTION_NAME);

   /* note that this may remove the timeout */

   bus_expirelist_expire (list);

   return TRUE;

 }

 #ifdef DBUS_BUILD_TESTS

 typedef struct

 {

   BusExpireItem item;

   int expire_count;

 } TestExpireItem;

 static dbus_bool_t

 test_expire_func (BusExpireList *list,

                   DBusList      *link,

                   void          *data)

 {

   TestExpireItem *t;

   t = (TestExpireItem*) link->data;

   t->expire_count += 1;

   return TRUE;

 }

 static void

 time_add_milliseconds (long *tv_sec,

                        long *tv_usec,

                        int   milliseconds)

 {

   *tv_sec = *tv_sec + milliseconds / 1000;

   *tv_usec = *tv_usec + milliseconds * 1000;

   if (*tv_usec >= 1000000)

     {

       *tv_usec -= 1000000;

       *tv_sec += 1;

     }

 }

 dbus_bool_t

 bus_expire_list_test (const DBusString *test_data_dir)

 {

   DBusLoop *loop;

   BusExpireList *list;

   long tv_sec, tv_usec;

   long tv_sec_not_expired, tv_usec_not_expired;

   long tv_sec_expired, tv_usec_expired;

   long tv_sec_past, tv_usec_past;

   TestExpireItem *item;

   int next_interval;

   dbus_bool_t result = FALSE;

   loop = _dbus_loop_new ();

   _dbus_assert (loop != NULL);

 #define EXPIRE_AFTER 100

   list = bus_expire_list_new (loop, EXPIRE_AFTER,

                               test_expire_func, NULL);

   _dbus_assert (list != NULL);

   _dbus_get_current_time (&tv_sec, &tv_usec);

   tv_sec_not_expired = tv_sec;

   tv_usec_not_expired = tv_usec;

   time_add_milliseconds (&tv_sec_not_expired,

                          &tv_usec_not_expired, EXPIRE_AFTER - 1);

   tv_sec_expired = tv_sec;

   tv_usec_expired = tv_usec;

   time_add_milliseconds (&tv_sec_expired,

                          &tv_usec_expired, EXPIRE_AFTER);

   tv_sec_past = tv_sec - 1;

   tv_usec_past = tv_usec;

   item = dbus_new0 (TestExpireItem, 1);

   if (item == NULL)

     goto oom;

   item->item.added_tv_sec = tv_sec;

   item->item.added_tv_usec = tv_usec;

   if (!_dbus_list_append (&list->items, item))

     _dbus_assert_not_reached ("out of memory");

   next_interval =

     do_expiration_with_current_time (list, tv_sec_not_expired,

                                      tv_usec_not_expired);

   _dbus_assert (item->expire_count == 0);

   _dbus_verbose ("next_interval = %d\n", next_interval);

   _dbus_assert (next_interval == 1);

   next_interval =

     do_expiration_with_current_time (list, tv_sec_expired,

                                      tv_usec_expired);

   _dbus_assert (item->expire_count == 1);

   _dbus_verbose ("next_interval = %d\n", next_interval);

   _dbus_assert (next_interval == -1);

   next_interval =

     do_expiration_with_current_time (list, tv_sec_past,

                                      tv_usec_past);

   _dbus_assert (item->expire_count == 1);

   _dbus_verbose ("next_interval = %d\n", next_interval);

   _dbus_assert (next_interval == 1000 + EXPIRE_AFTER);

   _dbus_list_clear (&list->items);

   dbus_free (item);

   bus_expire_list_free (list);

   _dbus_loop_unref (loop);

   result = TRUE;

  oom:

   return result;

 }

 #endif /* DBUS_BUILD_TESTS */