LCOV - code coverage report
Current view: top level - src/plugins/ni - ni.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 45 52 86.5 %
Date: 2019-09-12 12:28:41 Functions: 4 5 80.0 %

          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 "ni.h"
      10             : 
      11             : #ifndef HAVE_KDBCONFIG
      12             : #include "kdbconfig.h"
      13             : #endif
      14             : 
      15             : #include <kdbease.h>
      16             : #include <kdberrors.h>
      17             : 
      18             : #include <errno.h>
      19             : #include <string.h>
      20             : 
      21         376 : int elektraNiGet (Plugin * handle ELEKTRA_UNUSED, KeySet * returned, Key * parentKey)
      22             : {
      23             :         /* get all keys */
      24             : 
      25         376 :         if (!strcmp (keyName (parentKey), "system/elektra/modules/ni"))
      26             :         {
      27         275 :                 KeySet * moduleConfig =
      28         275 :                         ksNew (30, keyNew ("system/elektra/modules/ni", KEY_VALUE, "ni plugin waits for your orders", KEY_END),
      29             :                                keyNew ("system/elektra/modules/ni/exports", KEY_END),
      30             :                                keyNew ("system/elektra/modules/ni/exports/get", KEY_FUNC, elektraNiGet, KEY_END),
      31             :                                keyNew ("system/elektra/modules/ni/exports/set", KEY_FUNC, elektraNiSet, KEY_END),
      32             : #include "readme_ni.c"
      33             :                                keyNew ("system/elektra/modules/ni/infos/version", KEY_VALUE, PLUGINVERSION, KEY_END), KS_END);
      34         275 :                 ksAppend (returned, moduleConfig);
      35         275 :                 ksDel (moduleConfig);
      36         275 :                 return 1;
      37             :         }
      38             : 
      39         101 :         elektraNi_node root = elektraNi_New ();
      40         101 :         int errnosave = errno;
      41         101 :         int error = elektraNi_ReadFile (root, keyString (parentKey), 0);
      42         101 :         if (error == 0)
      43             :         {
      44           0 :                 elektraNi_Free (root);
      45           0 :                 ELEKTRA_SET_ERROR_GET (parentKey);
      46           0 :                 errno = errnosave;
      47           0 :                 return -1;
      48             :         }
      49             : 
      50             :         elektraNi_node current = NULL;
      51         488 :         while ((current = elektraNi_GetNextChild (root, current)) != NULL)
      52             :         {
      53         387 :                 Key * k = keyNew (keyName (parentKey), KEY_END);
      54         387 :                 keyAddName (k, elektraNi_GetName (current, NULL));
      55         387 :                 keySetString (k, elektraNi_GetValue (current, NULL));
      56         387 :                 elektraNi_node mcur = NULL;
      57        1690 :                 while ((mcur = elektraNi_GetNextChild (current, mcur)) != NULL)
      58             :                 {
      59         916 :                         keySetMeta (k, elektraNi_GetName (mcur, NULL), elektraNi_GetValue (mcur, NULL));
      60             :                         // printf("get meta %s %s from %s\n", elektraNi_GetName(mcur, NULL), elektraNi_GetValue (mcur, NULL), keyName(k));
      61             :                 }
      62         387 :                 ksAppendKey (returned, k);
      63             :         }
      64             : 
      65         101 :         elektraNi_Free (root);
      66             : 
      67         101 :         return 1; /* success */
      68             : }
      69             : 
      70         179 : static void keyMetaToNi (elektraNi_node add, Key * cur)
      71             : {
      72         179 :         elektraNi_SetValue (add, keyString (cur), keyGetValueSize (cur) - 1);
      73             : 
      74             :         const Key * m;
      75         179 :         keyRewindMeta (cur);
      76         690 :         while ((m = keyNextMeta (cur)) != 0)
      77             :         {
      78             :                 // printf("set meta %s %s from %s\n", keyName(m), keyString(m), keyName(cur));
      79         332 :                 elektraNi_node madd = elektraNi_GetChild (add, keyName (m), keyGetNameSize (m) - 1, 1, 0);
      80         332 :                 elektraNi_SetValue (madd, keyString (m), keyGetValueSize (m) - 1);
      81             :         }
      82         179 : }
      83             : 
      84          69 : int elektraNiSet (Plugin * handle ELEKTRA_UNUSED, KeySet * returned, Key * parentKey)
      85             : {
      86             :         /* set all keys */
      87             : 
      88          69 :         elektraNi_node root = elektraNi_New ();
      89             : 
      90             :         Key * cur;
      91          69 :         ksRewind (returned);
      92             : 
      93          69 :         if (keyCmp (ksHead (returned), parentKey) == 0)
      94             :         {
      95             :                 // printf ("found parentkey");
      96          13 :                 elektraNi_node add = elektraNi_GetChild (root, NULL, 0, 1, 0);
      97          13 :                 keyMetaToNi (add, ksHead (returned));
      98          13 :                 ksNext (returned); // do not process parent in loop again
      99             :         }
     100             : 
     101         235 :         while ((cur = ksNext (returned)) != 0)
     102             :         {
     103         166 :                 const char * name = elektraKeyGetRelativeName (cur, parentKey);
     104         166 :                 elektraNi_node add = elektraNi_GetChild (root, name, strlen (name), 1, 0);
     105         166 :                 keyMetaToNi (add, cur);
     106             :         }
     107             : 
     108          69 :         int errnosave = errno;
     109          69 :         int error = elektraNi_WriteFile (root, keyString (parentKey), 0);
     110          69 :         elektraNi_Free (root);
     111             : 
     112          69 :         if (error == 0)
     113             :         {
     114           0 :                 ELEKTRA_SET_ERROR_SET (parentKey);
     115           0 :                 errno = errnosave;
     116           0 :                 return -1;
     117             :         }
     118             : 
     119             :         return 1; /* success */
     120             : }
     121             : 
     122        1429 : Plugin * ELEKTRA_PLUGIN_EXPORT
     123             : {
     124             :         // clang-format off
     125        1429 :         return elektraPluginExport("ni",
     126             :                 ELEKTRA_PLUGIN_GET,     &elektraNiGet,
     127             :                 ELEKTRA_PLUGIN_SET,     &elektraNiSet,
     128             :                 ELEKTRA_PLUGIN_END);
     129             : }
     130             : 

Generated by: LCOV version 1.13