LCOV - code coverage report
Current view: top level - src/plugins/timeofday - timeofday.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 53 87 60.9 %
Date: 2019-09-12 12:28:41 Functions: 6 9 66.7 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  */
       8             : 
       9             : #include <kdbhelper.h>
      10             : 
      11             : #include "timeofday.h"
      12             : 
      13             : #include <string.h>
      14             : 
      15             : #define ARRAY_LENGTH 25
      16             : 
      17           8 : static inline void timeofday (char * t, struct timeval * start, struct timeval * now)
      18             : {
      19             :         struct timeval tv;
      20             : 
      21           8 :         tv.tv_sec = now->tv_sec - start->tv_sec;
      22           8 :         if ((tv.tv_usec = now->tv_usec - start->tv_usec) < 0)
      23             :         {
      24           0 :                 tv.tv_sec--;
      25           0 :                 tv.tv_usec += 1000000;
      26             :         }
      27             : 
      28          56 :         for (int i = 9; i >= 4; --i)
      29             :         {
      30          48 :                 t[i] = tv.tv_usec % 10 + '0';
      31          48 :                 tv.tv_usec /= 10;
      32             :         }
      33          32 :         for (int i = 3; i >= 0; --i)
      34             :         {
      35          32 :                 t[i] = tv.tv_sec % 10 + '0';
      36          32 :                 tv.tv_sec /= 10;
      37             :         }
      38           8 :         t[10] = 0;
      39           8 : }
      40             : 
      41           4 : const char * elektraTimeofdayHelper (char * t, TimeofdayInfo * ti)
      42             : {
      43             :         struct timeval now;
      44           4 :         gettimeofday (&now, 0);
      45           4 :         timeofday (t, &ti->start, &now);
      46           4 :         t[10] = '\t';
      47           4 :         t[11] = 'd';
      48           4 :         t[12] = 'i';
      49           4 :         t[13] = '\t';
      50           4 :         timeofday (&t[14], &ti->last, &now);
      51           4 :         ti->last = now;
      52             : 
      53           4 :         return t;
      54             : }
      55             : 
      56          19 : int elektraTimeofdayOpen (Plugin * handle, Key * parentKey ELEKTRA_UNUSED)
      57             : {
      58          19 :         TimeofdayInfo * ti = calloc (1, sizeof (TimeofdayInfo));
      59             :         char t[ARRAY_LENGTH];
      60             : 
      61          19 :         elektraPluginSetData (handle, ti);
      62             : 
      63             :         // init time
      64          19 :         gettimeofday (&ti->start, 0);
      65          19 :         ti->last = ti->start;
      66             : 
      67          19 :         KeySet * config = elektraPluginGetConfig (handle);
      68          19 :         if (ksLookupByName (config, "/module", 0))
      69             :         {
      70          17 :                 if (ksLookupByName (config, "/logmodule", 0))
      71             :                 {
      72           0 :                         fprintf (stderr, "open (module)\t%s\n", elektraTimeofdayHelper (t, ti));
      73             :                 }
      74             :         }
      75             :         else
      76             :         {
      77           2 :                 fprintf (stderr, "open\t%s\n", elektraTimeofdayHelper (t, ti));
      78             :         }
      79             : 
      80          19 :         return 0; /* success */
      81             : }
      82             : 
      83          19 : int elektraTimeofdayClose (Plugin * handle, Key * parentKey ELEKTRA_UNUSED)
      84             : {
      85             :         char t[ARRAY_LENGTH];
      86          19 :         TimeofdayInfo * ti = elektraPluginGetData (handle);
      87             : 
      88          19 :         KeySet * config = elektraPluginGetConfig (handle);
      89          19 :         if (ksLookupByName (config, "/module", 0))
      90             :         {
      91          17 :                 if (ksLookupByName (config, "/logmodule", 0))
      92             :                 {
      93           0 :                         fprintf (stderr, "close (module)\t%s\n", elektraTimeofdayHelper (t, ti));
      94             :                 }
      95             :         }
      96             :         else
      97             :         {
      98           2 :                 fprintf (stderr, "close\t%s\n", elektraTimeofdayHelper (t, ti));
      99             :         }
     100             : 
     101          19 :         elektraFree (ti);
     102             : 
     103          19 :         return 0; /* success */
     104             : }
     105             : 
     106          19 : int elektraTimeofdayGet (Plugin * handle, KeySet * returned, Key * parentKey)
     107             : {
     108             :         char t[ARRAY_LENGTH];
     109          19 :         TimeofdayInfo * ti = elektraPluginGetData (handle);
     110          19 :         const char * position = "get";
     111             : 
     112          19 :         ti->nrset = 0;
     113          19 :         ++ti->nrget;
     114          19 :         if (ti->nrget == 1)
     115             :                 position = "pregetstorage";
     116           0 :         else if (ti->nrget == 2)
     117             :         {
     118           0 :                 ti->nrget = 0;
     119           0 :                 position = "postgetstorage";
     120             :         }
     121             : 
     122          19 :         if (!strcmp (keyName (parentKey), "system/elektra/modules/timeofday"))
     123             :         {
     124          19 :                 KeySet * pluginConfig = ksNew (
     125             :                         30, keyNew ("system/elektra/modules/timeofday", KEY_VALUE, "timeofday plugin waits for your orders", KEY_END),
     126             :                         keyNew ("system/elektra/modules/timeofday/exports", KEY_END),
     127             :                         keyNew ("system/elektra/modules/timeofday/exports/open", KEY_FUNC, elektraTimeofdayOpen, KEY_END),
     128             :                         keyNew ("system/elektra/modules/timeofday/exports/close", KEY_FUNC, elektraTimeofdayClose, KEY_END),
     129             :                         keyNew ("system/elektra/modules/timeofday/exports/get", KEY_FUNC, elektraTimeofdayGet, KEY_END),
     130             :                         keyNew ("system/elektra/modules/timeofday/exports/set", KEY_FUNC, elektraTimeofdaySet, KEY_END),
     131             :                         keyNew ("system/elektra/modules/timeofday/exports/error", KEY_FUNC, elektraTimeofdayError, KEY_END),
     132             : #include "readme_timeofday.c"
     133             :                         keyNew ("system/elektra/modules/timeofday/infos/version", KEY_VALUE, PLUGINVERSION, KEY_END), KS_END);
     134          19 :                 ksAppend (returned, pluginConfig);
     135          19 :                 ksDel (pluginConfig);
     136             : 
     137          19 :                 KeySet * config = elektraPluginGetConfig (handle);
     138          19 :                 if (ksLookupByName (config, "/logmodule", 0))
     139             :                 {
     140           0 :                         fprintf (stderr, "get\t%s\tpos\t%s\n", elektraTimeofdayHelper (t, ti), "postmodulesconf");
     141             :                 }
     142             : 
     143             :                 return 1;
     144             :         }
     145             : 
     146           0 :         fprintf (stderr, "get\t%s\tpos\t%s\n", elektraTimeofdayHelper (t, ti), position);
     147             : 
     148           0 :         return 1;
     149             : }
     150             : 
     151           0 : int elektraTimeofdaySet (Plugin * handle, KeySet * returned ELEKTRA_UNUSED, Key * parentKey ELEKTRA_UNUSED)
     152             : {
     153             :         char t[ARRAY_LENGTH];
     154           0 :         TimeofdayInfo * ti = elektraPluginGetData (handle);
     155           0 :         const char * position = "set";
     156             : 
     157           0 :         ti->nrget = 0;
     158           0 :         ++ti->nrset;
     159           0 :         if (ti->nrset == 1)
     160             :                 position = "presetstorage";
     161           0 :         else if (ti->nrset == 2)
     162             :                 position = "precommit";
     163           0 :         else if (ti->nrset == 3)
     164             :         {
     165           0 :                 ti->nrset = 0;
     166           0 :                 position = "postcommit";
     167             :         }
     168             : 
     169           0 :         fprintf (stderr, "set\t%s\tpos\t%s\n", elektraTimeofdayHelper (t, ti), position);
     170             : 
     171           0 :         return 1;
     172             : }
     173             : 
     174           0 : int elektraTimeofdayError (Plugin * handle, KeySet * returned ELEKTRA_UNUSED, Key * parentKey ELEKTRA_UNUSED)
     175             : {
     176             :         char t[ARRAY_LENGTH];
     177           0 :         TimeofdayInfo * ti = elektraPluginGetData (handle);
     178           0 :         const char * position = "error";
     179             : 
     180           0 :         ti->nrset = 0;
     181           0 :         ti->nrget = 0;
     182           0 :         ++ti->nrerr;
     183           0 :         if (ti->nrerr == 1)
     184             :                 position = "prerollback";
     185           0 :         else if (ti->nrerr == 2)
     186             :         {
     187           0 :                 ti->nrerr = 0;
     188           0 :                 position = "postrollback";
     189             :         }
     190             : 
     191           0 :         fprintf (stderr, "err\t%s\tpos\t%s\n", elektraTimeofdayHelper (t, ti), position);
     192             : 
     193           0 :         return 1;
     194             : }
     195             : 
     196          19 : Plugin * ELEKTRA_PLUGIN_EXPORT
     197             : {
     198             :         // clang-format off
     199          19 :         return elektraPluginExport(BACKENDNAME,
     200             :                 ELEKTRA_PLUGIN_OPEN,    &elektraTimeofdayOpen,
     201             :                 ELEKTRA_PLUGIN_CLOSE,   &elektraTimeofdayClose,
     202             :                 ELEKTRA_PLUGIN_GET,     &elektraTimeofdayGet,
     203             :                 ELEKTRA_PLUGIN_SET,     &elektraTimeofdaySet,
     204             :                 ELEKTRA_PLUGIN_ERROR,   &elektraTimeofdayError,
     205             :                 ELEKTRA_PLUGIN_END);
     206             : }
     207             : 

Generated by: LCOV version 1.13