From f5ef6aa9965fec34c8de9fe2635b0e5c5b8a0ab9 Mon Sep 17 00:00:00 2001

From: Tomas Halman <thalman@redhat.com>

Date: Fri, 19 Jul 2019 15:59:32 +0200

Subject: [PATCH 47/48] BE: Convert be_ptask params to flags

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

The be_ptask_create call has a lot of parameters.

Some of them can be converted to flags to simplify

the declaration.

Reviewed-by: Pavel Březina <pbrezina@redhat.com>

---

 src/providers/ad/ad_dyndns.c             |   9 +-

 src/providers/ad/ad_machine_pw_renewal.c |  10 +-

 src/providers/ad/ad_subdomains.c         |  11 +-

 src/providers/be_ptask.c                 |  74 ++++++---

 src/providers/be_ptask.h                 |  39 ++---

 src/providers/be_ptask_private.h         |   2 -

 src/providers/be_refresh.c               |   9 +-

 src/providers/data_provider_be.c         |   4 +-

 src/providers/ipa/ipa_dyndns.c           |   7 +-

 src/providers/ipa/ipa_subdomains.c       |   7 +-

 src/providers/ldap/ldap_id_cleanup.c     |   5 +-

 src/providers/ldap/ldap_id_enum.c        |   6 +-

 src/providers/ldap/sdap_sudo_shared.c    |  16 +-

 src/tests/cmocka/test_be_ptask.c         | 194 ++++++++++++++++-------

 14 files changed, 251 insertions(+), 142 deletions(-)

diff --git a/src/providers/ad/ad_dyndns.c b/src/providers/ad/ad_dyndns.c

index af765b581..c9763d449 100644

--- a/src/providers/ad/ad_dyndns.c

+++ b/src/providers/ad/ad_dyndns.c

@@ -98,10 +98,13 @@ errno_t ad_dyndns_init(struct be_ctx *be_ctx,

         return EINVAL;

     }

-    ret = be_ptask_create(ad_opts, be_ctx, period, ptask_first_delay, 0, 0, period,

-                          BE_PTASK_OFFLINE_DISABLE, BE_PTASK_SCHEDULE_FROM_LAST, 0,

+    ret = be_ptask_create(ad_opts, be_ctx, period, ptask_first_delay, 0, 0,

+                          period, 0,

                           ad_dyndns_update_send, ad_dyndns_update_recv, ad_opts,

-                          "Dyndns update", 0, NULL);

+                          "Dyndns update",

+                          BE_PTASK_OFFLINE_DISABLE |

+                          BE_PTASK_SCHEDULE_FROM_LAST,

+                          NULL);

     if (ret != EOK) {

         DEBUG(SSSDBG_CRIT_FAILURE, "Unable to setup ptask "

diff --git a/src/providers/ad/ad_machine_pw_renewal.c b/src/providers/ad/ad_machine_pw_renewal.c

index 67802c04a..9dc36247a 100644

--- a/src/providers/ad/ad_machine_pw_renewal.c

+++ b/src/providers/ad/ad_machine_pw_renewal.c

@@ -381,14 +381,14 @@ errno_t ad_machine_account_password_renewal_init(struct be_ctx *be_ctx,

         goto done;

     }

-    ret = be_ptask_create(be_ctx, be_ctx, period, initial_delay, 0, 0, 60,

-                          BE_PTASK_OFFLINE_DISABLE,

-                          BE_PTASK_SCHEDULE_FROM_LAST,

-                          0,

+    ret = be_ptask_create(be_ctx, be_ctx, period, initial_delay, 0, 0, 60, 0,

                           ad_machine_account_password_renewal_send,

                           ad_machine_account_password_renewal_recv,

                           renewal_data,

-                          "AD machine account password renewal", 0, NULL);

+                          "AD machine account password renewal",

+                          BE_PTASK_OFFLINE_DISABLE |

+                          BE_PTASK_SCHEDULE_FROM_LAST,

+                          NULL);

     if (ret != EOK) {

         DEBUG(SSSDBG_OP_FAILURE, "be_ptask_create failed.\n");

         goto done;

diff --git a/src/providers/ad/ad_subdomains.c b/src/providers/ad/ad_subdomains.c

index 0f46b46ad..d934e70d6 100644

--- a/src/providers/ad/ad_subdomains.c

+++ b/src/providers/ad/ad_subdomains.c

@@ -2065,12 +2065,13 @@ errno_t ad_subdomains_init(TALLOC_CTX *mem_ctx,

                   struct ad_subdomains_ctx, struct dp_subdomains_data, struct dp_reply_std);

     period = be_ctx->domain->subdomain_refresh_interval;

-    ret = be_ptask_create(sd_ctx, be_ctx, period, 0, 0, 0, period,

-                          BE_PTASK_OFFLINE_DISABLE,

+    ret = be_ptask_create(sd_ctx, be_ctx, period, 0, 0, 0, period, 0,

+                          ad_subdomains_ptask_send, ad_subdomains_ptask_recv,

+                          sd_ctx,

+                          "Subdomains Refresh",

+                          BE_PTASK_OFFLINE_DISABLE |

                           BE_PTASK_SCHEDULE_FROM_LAST,

-                          0,

-                          ad_subdomains_ptask_send, ad_subdomains_ptask_recv, sd_ctx,

-                          "Subdomains Refresh", 0, NULL);

+                          NULL);

     if (ret != EOK) {

         DEBUG(SSSDBG_CRIT_FAILURE, "Unable to setup ptask "

               "[%d]: %s\n", ret, sss_strerror(ret));

diff --git a/src/providers/be_ptask.c b/src/providers/be_ptask.c

index 56c9c82fe..9a432c948 100644

--- a/src/providers/be_ptask.c

+++ b/src/providers/be_ptask.c

@@ -38,7 +38,7 @@ enum be_ptask_delay {

 static void be_ptask_schedule(struct be_ptask *task,

                               enum be_ptask_delay delay_type,

-                              enum be_ptask_schedule from);

+                              uint32_t from);

 static int be_ptask_destructor(void *pvt)

 {

@@ -107,21 +107,20 @@ static void be_ptask_execute(struct tevent_context *ev,

     if (be_is_offline(task->be_ctx)) {

         DEBUG(SSSDBG_TRACE_FUNC, "Back end is offline\n");

-        switch (task->offline) {

-        case BE_PTASK_OFFLINE_SKIP:

+        if (task->flags & BE_PTASK_OFFLINE_SKIP) {

             be_ptask_schedule(task, BE_PTASK_PERIOD,

                               BE_PTASK_SCHEDULE_FROM_NOW);

             return;

-        case BE_PTASK_OFFLINE_DISABLE:

+        }

+        else if(task->flags & BE_PTASK_OFFLINE_DISABLE) {

             /* This case is normally handled by offline callback but we

              * should handle it here as well since we can get here in some

              * special cases for example unit tests or tevent events order. */

             be_ptask_disable(task);

             return;

-        case BE_PTASK_OFFLINE_EXECUTE:

-            /* continue */

-            break;

         }

+        /* BE_PTASK_OFFLINE_EXECUTE */

+        /* continue */

     }

     DEBUG(SSSDBG_TRACE_FUNC, "Task [%s]: executing task, timeout %lu "

@@ -177,7 +176,7 @@ static void be_ptask_done(struct tevent_req *req)

         DEBUG(SSSDBG_TRACE_FUNC, "Task [%s]: finished successfully\n",

                                   task->name);

-        be_ptask_schedule(task, BE_PTASK_PERIOD, task->success_schedule_type);

+        be_ptask_schedule(task, BE_PTASK_PERIOD, task->flags);

         break;

     default:

         DEBUG(SSSDBG_OP_FAILURE, "Task [%s]: failed with [%d]: %s\n",

@@ -190,7 +189,7 @@ static void be_ptask_done(struct tevent_req *req)

 static void be_ptask_schedule(struct be_ptask *task,

                               enum be_ptask_delay delay_type,

-                              enum be_ptask_schedule from)

+                              uint32_t from)

 {

     struct timeval tv = { 0, };

     time_t delay = 0;

@@ -228,20 +227,18 @@ static void be_ptask_schedule(struct be_ptask *task,

         delay = delay + (rand_r(&task->ro_seed) % task->random_offset);

     }

-    switch (from) {

-    case BE_PTASK_SCHEDULE_FROM_NOW:

+    if(from | BE_PTASK_SCHEDULE_FROM_NOW) {

         tv = tevent_timeval_current_ofs(delay, 0);

         DEBUG(SSSDBG_TRACE_FUNC, "Task [%s]: scheduling task %lu seconds "

               "from now [%lu]\n", task->name, delay, tv.tv_sec);

-        break;

-    case BE_PTASK_SCHEDULE_FROM_LAST:

+    }

+    else if (from | BE_PTASK_SCHEDULE_FROM_LAST) {

         tv = tevent_timeval_set(task->last_execution + delay, 0);

         DEBUG(SSSDBG_TRACE_FUNC, "Task [%s]: scheduling task %lu seconds "

                                   "from last execution time [%lu]\n",

                                   task->name, delay, tv.tv_sec);

-        break;

     }

     if (task->timer != NULL) {

@@ -261,6 +258,36 @@ static void be_ptask_schedule(struct be_ptask *task,

     task->next_execution = tv.tv_sec;

 }

+static unsigned int be_ptask_flag_bits(uint32_t flags)

+{

+    unsigned int cnt = 0;

+    while (flags != 0) {

+        cnt += flags & 1;

+        flags >>= 1;

+    }

+    return cnt;

+}

+

+static int be_ptask_flag_check(uint32_t flags)

+{

+    uint32_t tmpflags;

+

+    tmpflags = flags & (BE_PTASK_SCHEDULE_FROM_LAST |

+                        BE_PTASK_SCHEDULE_FROM_NOW);

+    if (be_ptask_flag_bits(tmpflags) != 1) {

+        return EINVAL;

+    }

+

+    tmpflags = flags & (BE_PTASK_OFFLINE_SKIP |

+                        BE_PTASK_OFFLINE_DISABLE |

+                        BE_PTASK_OFFLINE_EXECUTE);

+    if (be_ptask_flag_bits(tmpflags) != 1) {

+        return EINVAL;

+    }

+

+    return EOK;

+}

+

 errno_t be_ptask_create(TALLOC_CTX *mem_ctx,

                         struct be_ctx *be_ctx,

                         time_t period,

@@ -268,8 +295,6 @@ errno_t be_ptask_create(TALLOC_CTX *mem_ctx,

                         time_t enabled_delay,

                         time_t random_offset,

                         time_t timeout,

-                        enum be_ptask_offline offline,

-                        enum be_ptask_schedule success_schedule_type,

                         time_t max_backoff,

                         be_ptask_send_t send_fn,

                         be_ptask_recv_t recv_fn,

@@ -290,6 +315,12 @@ errno_t be_ptask_create(TALLOC_CTX *mem_ctx,

         return EINVAL;

     }

+    /* check flags, some of them are exclusive, some must be present */

+    ret = be_ptask_flag_check(flags);

+    if (ret != EOK) {

+        return ret;

+    }

+

     task = talloc_zero(mem_ctx, struct be_ptask);

     if (task == NULL) {

         ret = ENOMEM;

@@ -306,8 +337,6 @@ errno_t be_ptask_create(TALLOC_CTX *mem_ctx,

     task->ro_seed = time(NULL) * getpid();

     task->max_backoff = max_backoff;

     task->timeout = timeout;

-    task->offline = offline;

-    task->success_schedule_type = success_schedule_type;

     task->send_fn = send_fn;

     task->recv_fn = recv_fn;

     task->pvt = pvt;

@@ -322,7 +351,7 @@ errno_t be_ptask_create(TALLOC_CTX *mem_ctx,

     talloc_set_destructor((TALLOC_CTX*)task, be_ptask_destructor);

-    if (offline == BE_PTASK_OFFLINE_DISABLE) {

+    if (flags & BE_PTASK_OFFLINE_DISABLE) {

         /* install offline and online callbacks */

         ret = be_add_online_cb(task, be_ctx, be_ptask_online_cb, task, NULL);

         if (ret != EOK) {

@@ -458,7 +487,6 @@ errno_t be_ptask_create_sync(TALLOC_CTX *mem_ctx,

                              time_t enabled_delay,

                              time_t random_offset,

                              time_t timeout,

-                             enum be_ptask_offline offline,

                              time_t max_backoff,

                              be_ptask_sync_t fn,

                              void *pvt,

@@ -479,10 +507,10 @@ errno_t be_ptask_create_sync(TALLOC_CTX *mem_ctx,

     ctx->pvt = pvt;

     ret = be_ptask_create(mem_ctx, be_ctx, period, first_delay,

-                          enabled_delay, random_offset, timeout, offline,

-                          BE_PTASK_SCHEDULE_FROM_LAST,

+                          enabled_delay, random_offset, timeout,

                           max_backoff, be_ptask_sync_send, be_ptask_sync_recv,

-                          ctx, name, flags, _task);

+                          ctx, name, flags | BE_PTASK_SCHEDULE_FROM_LAST,

+                          _task);

     if (ret != EOK) {

         goto done;

     }

diff --git a/src/providers/be_ptask.h b/src/providers/be_ptask.h

index a33443965..640c8570a 100644

--- a/src/providers/be_ptask.h

+++ b/src/providers/be_ptask.h

@@ -39,33 +39,23 @@ struct be_ptask;

 #define BE_PTASK_NO_PERIODIC         0x0001

 /**

- * Defines how should task behave when back end is offline.

+ * Flags defining the starting point for scheduling a task

  */

-enum be_ptask_offline {

-    /* current request will be skipped and rescheduled to 'now + period' */

-    BE_PTASK_OFFLINE_SKIP,

-

-    /* An offline and online callback is registered. The task is disabled

-     * immediately when back end goes offline and then enabled again

-     * when back end goes back online */

-    BE_PTASK_OFFLINE_DISABLE,

-

-    /* current request will be executed as planned */

-    BE_PTASK_OFFLINE_EXECUTE

-};

+/* Schedule starting from now, typically this is used when scheduling

+ * relative to the finish time */

+#define BE_PTASK_SCHEDULE_FROM_NOW   0x0002

+/* Schedule relative to the start time of the task */

+#define BE_PTASK_SCHEDULE_FROM_LAST  0x0004

 /**

- * Defines the starting point for scheduling a task

+ * Flags defining how should task behave when back end is offline.

  */

-enum be_ptask_schedule {

-    /* Schedule starting from now, typically this is used when scheduling

-     * relative to the finish time

-     */

-    BE_PTASK_SCHEDULE_FROM_NOW,

-    /* Schedule relative to the start time of the task

-     */

-    BE_PTASK_SCHEDULE_FROM_LAST

-};

+/* current request will be skipped and rescheduled to 'now + period' */

+#define BE_PTASK_OFFLINE_SKIP        0x0008

+/* An offline and online callback is registered. The task is disabled */

+#define BE_PTASK_OFFLINE_DISABLE     0x0010

+/* current request will be executed as planned */

+#define BE_PTASK_OFFLINE_EXECUTE     0x0020

 typedef struct tevent_req *

 (*be_ptask_send_t)(TALLOC_CTX *mem_ctx,

@@ -128,8 +118,6 @@ errno_t be_ptask_create(TALLOC_CTX *mem_ctx,

                         time_t enabled_delay,

                         time_t random_offset,

                         time_t timeout,

-                        enum be_ptask_offline offline,

-                        enum be_ptask_schedule success_schedule_type,

                         time_t max_backoff,

                         be_ptask_send_t send_fn,

                         be_ptask_recv_t recv_fn,

@@ -145,7 +133,6 @@ errno_t be_ptask_create_sync(TALLOC_CTX *mem_ctx,

                              time_t enabled_delay,

                              time_t random_offset,

                              time_t timeout,

-                             enum be_ptask_offline offline,

                              time_t max_backoff,

                              be_ptask_sync_t fn,

                              void *pvt,

diff --git a/src/providers/be_ptask_private.h b/src/providers/be_ptask_private.h

index 496a2f9ae..f3e5beec7 100644

--- a/src/providers/be_ptask_private.h

+++ b/src/providers/be_ptask_private.h

@@ -31,8 +31,6 @@ struct be_ptask {

     unsigned int ro_seed;

     time_t timeout;

     time_t max_backoff;

-    enum be_ptask_offline offline;

-    enum be_ptask_schedule success_schedule_type;

     be_ptask_send_t send_fn;

     be_ptask_recv_t recv_fn;

     void *pvt;

diff --git a/src/providers/be_refresh.c b/src/providers/be_refresh.c

index 687d3f022..6cce38390 100644

--- a/src/providers/be_refresh.c

+++ b/src/providers/be_refresh.c

@@ -173,11 +173,12 @@ static errno_t be_refresh_ctx_init(struct be_ctx *be_ctx,

     refresh_interval = be_ctx->domain->refresh_expired_interval;

     if (refresh_interval > 0) {

         ret = be_ptask_create(be_ctx, be_ctx, refresh_interval, 30, 5, 0,

-                              refresh_interval, BE_PTASK_OFFLINE_SKIP,

-                              BE_PTASK_SCHEDULE_FROM_NOW,

-                              0,

+                              refresh_interval, 0,

                               be_refresh_send, be_refresh_recv,

-                              ctx, "Refresh Records", 0, NULL);

+                              ctx, "Refresh Records",

+                              BE_PTASK_OFFLINE_SKIP |

+                              BE_PTASK_SCHEDULE_FROM_NOW,

+                              NULL);

         if (ret != EOK) {

             DEBUG(SSSDBG_FATAL_FAILURE,

                   "Unable to initialize refresh periodic task [%d]: %s\n",

diff --git a/src/providers/data_provider_be.c b/src/providers/data_provider_be.c

index f21669b8c..ce00231ff 100644

--- a/src/providers/data_provider_be.c

+++ b/src/providers/data_provider_be.c

@@ -130,10 +130,10 @@ void be_mark_offline(struct be_ctx *ctx)

         ret = be_ptask_create_sync(ctx, ctx,

                                    offline_timeout, offline_timeout,

                                    offline_timeout, 30, offline_timeout,

-                                   BE_PTASK_OFFLINE_EXECUTE,

                                    3600 /* max_backoff */,

                                    try_to_go_online,

-                                   ctx, "Check if online (periodic)", 0,

+                                   ctx, "Check if online (periodic)",

+                                   BE_PTASK_OFFLINE_EXECUTE,

                                    &ctx->check_if_online_ptask);

         if (ret != EOK) {

             DEBUG(SSSDBG_FATAL_FAILURE,

diff --git a/src/providers/ipa/ipa_dyndns.c b/src/providers/ipa/ipa_dyndns.c

index 27852c2e2..f8831287a 100644

--- a/src/providers/ipa/ipa_dyndns.c

+++ b/src/providers/ipa/ipa_dyndns.c

@@ -74,11 +74,12 @@ errno_t ipa_dyndns_init(struct be_ctx *be_ctx,

     }

     ret = be_ptask_create(ctx, be_ctx, period, ptask_first_delay, 0, 0, period,

-                          BE_PTASK_OFFLINE_DISABLE,

-                          BE_PTASK_SCHEDULE_FROM_LAST,

                           0,

                           ipa_dyndns_update_send, ipa_dyndns_update_recv, ctx,

-                          "Dyndns update", 0, NULL);

+                          "Dyndns update",

+                          BE_PTASK_OFFLINE_DISABLE |

+                          BE_PTASK_SCHEDULE_FROM_LAST,

+                          NULL);

     if (ret != EOK) {

         DEBUG(SSSDBG_CRIT_FAILURE, "Unable to setup ptask "

               "[%d]: %s\n", ret, sss_strerror(ret));

diff --git a/src/providers/ipa/ipa_subdomains.c b/src/providers/ipa/ipa_subdomains.c

index 13e49c5c0..d000f1230 100644

--- a/src/providers/ipa/ipa_subdomains.c

+++ b/src/providers/ipa/ipa_subdomains.c

@@ -3134,11 +3134,12 @@ errno_t ipa_subdomains_init(TALLOC_CTX *mem_ctx,

     period = be_ctx->domain->subdomain_refresh_interval;

     ret = be_ptask_create(sd_ctx, be_ctx, period, ptask_first_delay, 0, 0, period,

-                          BE_PTASK_OFFLINE_DISABLE,

-                          BE_PTASK_SCHEDULE_FROM_LAST,

                           0,

                           ipa_subdomains_ptask_send, ipa_subdomains_ptask_recv, sd_ctx,

-                          "Subdomains Refresh", 0, NULL);

+                          "Subdomains Refresh",

+                          BE_PTASK_OFFLINE_DISABLE |

+                          BE_PTASK_SCHEDULE_FROM_LAST,

+                          NULL);

     if (ret != EOK) {

         DEBUG(SSSDBG_CRIT_FAILURE, "Unable to setup ptask "

               "[%d]: %s\n", ret, sss_strerror(ret));

diff --git a/src/providers/ldap/ldap_id_cleanup.c b/src/providers/ldap/ldap_id_cleanup.c

index df56f4da4..a62060337 100644

--- a/src/providers/ldap/ldap_id_cleanup.c

+++ b/src/providers/ldap/ldap_id_cleanup.c

@@ -87,8 +87,9 @@ errno_t ldap_setup_cleanup(struct sdap_id_ctx *id_ctx,

     ret = be_ptask_create_sync(sdom, id_ctx->be, period, first_delay,

                                5 /* enabled delay */, 0 /* random offset */,

-                               period /* timeout */, BE_PTASK_OFFLINE_SKIP, 0,

-                               ldap_cleanup_task, cleanup_ctx, name, 0,

+                               period /* timeout */, 0,

+                               ldap_cleanup_task, cleanup_ctx, name,

+                               BE_PTASK_OFFLINE_SKIP,

                                &sdom->cleanup_task);

     if (ret != EOK) {

         DEBUG(SSSDBG_FATAL_FAILURE, "Unable to initialize cleanup periodic "

diff --git a/src/providers/ldap/ldap_id_enum.c b/src/providers/ldap/ldap_id_enum.c

index 2137f6821..009d9d275 100644

--- a/src/providers/ldap/ldap_id_enum.c

+++ b/src/providers/ldap/ldap_id_enum.c

@@ -98,11 +98,11 @@ errno_t ldap_setup_enumeration(struct be_ctx *be_ctx,

                           5,                        /* enabled delay */

                           0,                        /* random offset */

                           period,                   /* timeout */

-                          BE_PTASK_OFFLINE_SKIP,

-                          BE_PTASK_SCHEDULE_FROM_LAST,

                           0,                        /* max_backoff */

                           send_fn, recv_fn,

-                          ectx, "enumeration", 0, &sdom->enum_task);

+                          ectx, "enumeration",

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &sdom->enum_task);

     if (ret != EOK) {

         DEBUG(SSSDBG_FATAL_FAILURE,

               "Unable to initialize enumeration periodic task\n");

diff --git a/src/providers/ldap/sdap_sudo_shared.c b/src/providers/ldap/sdap_sudo_shared.c

index 59356bd44..062a95ab6 100644

--- a/src/providers/ldap/sdap_sudo_shared.c

+++ b/src/providers/ldap/sdap_sudo_shared.c

@@ -90,11 +90,12 @@ sdap_sudo_ptask_setup_generic(struct be_ctx *be_ctx,

      * when offline. */

     if (full > 0) {

         ret = be_ptask_create(be_ctx, be_ctx, full, delay, 0, 0, full,

-                              BE_PTASK_OFFLINE_DISABLE,

-                              BE_PTASK_SCHEDULE_FROM_LAST,

                               0,

                               full_send_fn, full_recv_fn, pvt,

-                              "SUDO Full Refresh", 0, NULL);

+                              "SUDO Full Refresh",

+                              BE_PTASK_OFFLINE_DISABLE |

+                              BE_PTASK_SCHEDULE_FROM_LAST,

+                              NULL);

         if (ret != EOK) {

             DEBUG(SSSDBG_CRIT_FAILURE, "Unable to setup full refresh ptask "

                   "[%d]: %s\n", ret, sss_strerror(ret));

@@ -109,11 +110,12 @@ sdap_sudo_ptask_setup_generic(struct be_ctx *be_ctx,

      * when offline. */

     if (smart > 0) {

         ret = be_ptask_create(be_ctx, be_ctx, smart, delay + smart, smart, 0,

-                              smart, BE_PTASK_OFFLINE_DISABLE,

-                              BE_PTASK_SCHEDULE_FROM_LAST,

-                              0,

+                              smart,                              0,

                               smart_send_fn, smart_recv_fn, pvt,

-                              "SUDO Smart Refresh", 0, NULL);

+                              "SUDO Smart Refresh",

+                              BE_PTASK_OFFLINE_DISABLE |

+                              BE_PTASK_SCHEDULE_FROM_LAST,

+                              NULL);

         if (ret != EOK) {

             DEBUG(SSSDBG_CRIT_FAILURE, "Unable to setup smart refresh ptask "

                   "[%d]: %s\n", ret, sss_strerror(ret));

diff --git a/src/tests/cmocka/test_be_ptask.c b/src/tests/cmocka/test_be_ptask.c

index ac8c0767f..b30775306 100644

--- a/src/tests/cmocka/test_be_ptask.c

+++ b/src/tests/cmocka/test_be_ptask.c

@@ -304,9 +304,10 @@ void test_be_ptask_create_einval_be(void **state)

     errno_t ret;

     ret = be_ptask_create(test_ctx, NULL, PERIOD, 0, 0, 0, 0,

-                          BE_PTASK_OFFLINE_SKIP, BE_PTASK_SCHEDULE_FROM_LAST,

                           0, test_be_ptask_send,

-                          test_be_ptask_recv, NULL, "Test ptask", 0, &ptask);

+                          test_be_ptask_recv, NULL, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &ptask);

     assert_int_equal(ret, EINVAL);

     assert_null(ptask);

 }

@@ -318,9 +319,10 @@ void test_be_ptask_create_einval_period(void **state)

     errno_t ret;

     ret = be_ptask_create(test_ctx, test_ctx->be_ctx, 0, 0, 0, 0, 0,

-                          BE_PTASK_OFFLINE_SKIP, BE_PTASK_SCHEDULE_FROM_LAST,

                           0, test_be_ptask_send,

-                          test_be_ptask_recv, NULL, "Test ptask", 0, &ptask);

+                          test_be_ptask_recv, NULL, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &ptask);

     assert_int_equal(ret, EINVAL);

     assert_null(ptask);

 }

@@ -332,9 +334,10 @@ void test_be_ptask_create_einval_send(void **state)

     errno_t ret;

     ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

-                          BE_PTASK_OFFLINE_SKIP, BE_PTASK_SCHEDULE_FROM_LAST,

                           0, NULL,

-                          test_be_ptask_recv, NULL, "Test ptask", 0, &ptask);

+                          test_be_ptask_recv, NULL, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &ptask);

     assert_int_equal(ret, EINVAL);

     assert_null(ptask);

 }

@@ -346,9 +349,10 @@ void test_be_ptask_create_einval_recv(void **state)

     errno_t ret;

     ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

-                          BE_PTASK_OFFLINE_SKIP, BE_PTASK_SCHEDULE_FROM_LAST,

                           0, test_be_ptask_send,

-                          NULL, NULL, "Test ptask", 0, &ptask);

+                          NULL, NULL, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &ptask);

     assert_int_equal(ret, EINVAL);

     assert_null(ptask);

 }

@@ -360,9 +364,72 @@ void test_be_ptask_create_einval_name(void **state)

     errno_t ret;

     ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

-                          BE_PTASK_OFFLINE_SKIP, BE_PTASK_SCHEDULE_FROM_LAST,

                           0, test_be_ptask_send,

-                          test_be_ptask_recv, NULL, NULL, 0, &ptask);

+                          test_be_ptask_recv, NULL, NULL,

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &ptask);

+    assert_int_equal(ret, EINVAL);

+    assert_null(ptask);

+}

+

+void test_be_ptask_mixed_from_flags_einval(void **state)

+{

+    struct test_ctx *test_ctx = (struct test_ctx *)(*state);

+    struct be_ptask *ptask = NULL;

+    errno_t ret;

+

+    ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

+                          0, test_be_ptask_send,

+                          test_be_ptask_recv, NULL, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP |

+                          BE_PTASK_SCHEDULE_FROM_LAST |

+                          BE_PTASK_SCHEDULE_FROM_NOW,

+                          &ptask);

+    assert_int_equal(ret, EINVAL);

+    assert_null(ptask);

+}

+

+void test_be_ptask_no_from_flags_einval(void **state)

+{

+    struct test_ctx *test_ctx = (struct test_ctx *)(*state);

+    struct be_ptask *ptask = NULL;

+    errno_t ret;

+

+    ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

+                          0, test_be_ptask_send,

+                          test_be_ptask_recv, NULL, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP,

+                          &ptask);

+    assert_int_equal(ret, EINVAL);

+    assert_null(ptask);

+}

+void test_be_ptask_mixed_offline_flags_einval(void **state)

+{

+    struct test_ctx *test_ctx = (struct test_ctx *)(*state);

+    struct be_ptask *ptask = NULL;

+    errno_t ret;

+

+    ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

+                          0, test_be_ptask_send,

+                          test_be_ptask_recv, NULL, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP |

+                          BE_PTASK_OFFLINE_DISABLE |

+                          BE_PTASK_SCHEDULE_FROM_NOW,

+                          &ptask);

+    assert_int_equal(ret, EINVAL);

+    assert_null(ptask);

+}

+void test_be_ptask_no_offline_flags_einval(void **state)

+{

+    struct test_ctx *test_ctx = (struct test_ctx *)(*state);

+    struct be_ptask *ptask = NULL;

+    errno_t ret;

+

+    ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

+                          0, test_be_ptask_send,

+                          test_be_ptask_recv, NULL, "Test ptask",

+                          BE_PTASK_SCHEDULE_FROM_NOW,

+                          &ptask);

     assert_int_equal(ret, EINVAL);

     assert_null(ptask);

 }

@@ -376,9 +443,10 @@ void test_be_ptask_create_no_delay(void **state)

     now = get_current_time();

     ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

-                          BE_PTASK_OFFLINE_SKIP, BE_PTASK_SCHEDULE_FROM_LAST,

                           0, test_be_ptask_send,

-                          test_be_ptask_recv, test_ctx, "Test ptask", 0, &ptask);

+                          test_be_ptask_recv, test_ctx, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &ptask);

     assert_int_equal(ret, ERR_OK);

     assert_non_null(ptask);

     assert_non_null(ptask->timer);

@@ -404,9 +472,10 @@ void test_be_ptask_create_first_delay(void **state)

     now = get_current_time();

     ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, DELAY, 0, 0, 0,

-                          BE_PTASK_OFFLINE_SKIP, BE_PTASK_SCHEDULE_FROM_LAST,

                           0, test_be_ptask_send,

-                          test_be_ptask_recv, test_ctx, "Test ptask", 0, &ptask);

+                          test_be_ptask_recv, test_ctx, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &ptask);

     assert_int_equal(ret, ERR_OK);

     assert_non_null(ptask);

     assert_non_null(ptask->timer);

@@ -430,9 +499,10 @@ void test_be_ptask_disable(void **state)

     errno_t ret;

     ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

-                          BE_PTASK_OFFLINE_SKIP, BE_PTASK_SCHEDULE_FROM_LAST,

                           0, test_be_ptask_send,

-                          test_be_ptask_recv, test_ctx, "Test ptask", 0, &ptask);

+                          test_be_ptask_recv, test_ctx, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &ptask);

     assert_int_equal(ret, ERR_OK);

     assert_non_null(ptask);

     assert_non_null(ptask->timer);

@@ -455,9 +525,10 @@ void test_be_ptask_enable(void **state)

     now = get_current_time();

     ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

-                          BE_PTASK_OFFLINE_SKIP, BE_PTASK_SCHEDULE_FROM_LAST,

                           0, test_be_ptask_send,

-                          test_be_ptask_recv, test_ctx, "Test ptask", 0, &ptask);

+                          test_be_ptask_recv, test_ctx, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &ptask);

     assert_int_equal(ret, ERR_OK);

     assert_non_null(ptask);

     assert_non_null(ptask->timer);

@@ -488,9 +559,10 @@ void test_be_ptask_enable_delay(void **state)

     errno_t ret;

     ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, DELAY, 0, 0,

-                          BE_PTASK_OFFLINE_SKIP, BE_PTASK_SCHEDULE_FROM_LAST,

                           0, test_be_ptask_send,

-                          test_be_ptask_recv, test_ctx, "Test ptask", 0, &ptask);

+                          test_be_ptask_recv, test_ctx, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &ptask);

     assert_int_equal(ret, ERR_OK);

     assert_non_null(ptask);

     assert_non_null(ptask->timer);

@@ -528,9 +600,10 @@ void test_be_ptask_offline_skip(void **state)

     now = get_current_time();

     ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

-                          BE_PTASK_OFFLINE_SKIP, BE_PTASK_SCHEDULE_FROM_LAST,

                           0, test_be_ptask_send,

-                          test_be_ptask_recv, test_ctx, "Test ptask", 0, &ptask);

+                          test_be_ptask_recv, test_ctx, "Test ptask",

+                          BE_PTASK_OFFLINE_SKIP | BE_PTASK_SCHEDULE_FROM_LAST,

+                          &ptask);

     assert_int_equal(ret, ERR_OK);

     assert_non_null(ptask);

     assert_non_null(ptask->timer);