LCOV - code coverage report
Current view: top level - src/plugins/quickdump - readv1.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 43 98 43.9 %
Date: 2019-09-12 12:28:41 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Source for quickdump plugin
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10           2 : static int readVersion1 (FILE * file, KeySet * returned, Key * parentKey)
      11             : {
      12             :         char c;
      13          20 :         while ((c = fgetc (file)) != EOF)
      14             :         {
      15          16 :                 ungetc (c, file);
      16             : 
      17          16 :                 char * name = readString (file, parentKey);
      18          16 :                 if (name == NULL)
      19             :                 {
      20           0 :                         elektraFree (name);
      21           0 :                         fclose (file);
      22           0 :                         return ELEKTRA_PLUGIN_STATUS_ERROR;
      23             :                 }
      24             : 
      25          16 :                 char type = fgetc (file);
      26          16 :                 if (type == EOF)
      27             :                 {
      28           0 :                         elektraFree (name);
      29           0 :                         fclose (file);
      30           0 :                         return ELEKTRA_PLUGIN_STATUS_ERROR;
      31             :                 }
      32             : 
      33             :                 Key * k;
      34             : 
      35          16 :                 switch (type)
      36             :                 {
      37             :                 case 'b':
      38             :                 {
      39             :                         // binary key value
      40             :                         kdb_unsigned_long_long_t valueSize;
      41           2 :                         if (!readUInt64 (file, &valueSize, parentKey))
      42             :                         {
      43           0 :                                 elektraFree (name);
      44           0 :                                 fclose (file);
      45           0 :                                 return ELEKTRA_PLUGIN_STATUS_ERROR;
      46             :                         }
      47             : 
      48           2 :                         if (valueSize == 0)
      49             :                         {
      50           2 :                                 k = keyNew (name, KEY_BINARY, KEY_SIZE, valueSize, KEY_END);
      51           2 :                                 elektraFree (name);
      52             :                         }
      53             :                         else
      54             :                         {
      55           0 :                                 void * value = elektraMalloc (valueSize);
      56           0 :                                 if (fread (value, sizeof (char), valueSize, file) < valueSize)
      57             :                                 {
      58           0 :                                         elektraFree (name);
      59           0 :                                         fclose (file);
      60           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
      61             :                                 }
      62           0 :                                 k = keyNew (name, KEY_BINARY, KEY_SIZE, (size_t) valueSize, KEY_VALUE, value, KEY_END);
      63           0 :                                 elektraFree (name);
      64           0 :                                 elektraFree (value);
      65             :                         }
      66           2 :                         break;
      67             :                 }
      68             :                 case 's':
      69             :                 {
      70             :                         // string key value
      71          14 :                         char * value = readString (file, parentKey);
      72          14 :                         if (value == NULL)
      73             :                         {
      74           0 :                                 elektraFree (name);
      75           0 :                                 fclose (file);
      76           0 :                                 return ELEKTRA_PLUGIN_STATUS_ERROR;
      77             :                         }
      78          14 :                         k = keyNew (name, KEY_VALUE, value, KEY_END);
      79          14 :                         elektraFree (name);
      80          14 :                         elektraFree (value);
      81          14 :                         break;
      82             :                 }
      83             :                 default:
      84           0 :                         elektraFree (name);
      85           0 :                         fclose (file);
      86           0 :                         return ELEKTRA_PLUGIN_STATUS_ERROR;
      87             :                 }
      88             : 
      89          30 :                 while ((c = fgetc (file)) != 0)
      90             :                 {
      91          14 :                         if (c == EOF)
      92             :                         {
      93           0 :                                 keyDel (k);
      94           0 :                                 fclose (file);
      95           0 :                                 return ELEKTRA_PLUGIN_STATUS_ERROR;
      96             :                         }
      97             : 
      98          14 :                         switch (c)
      99             :                         {
     100             :                         case 'm':
     101             :                         {
     102             :                                 // meta key
     103          12 :                                 char * metaName = readString (file, parentKey);
     104          12 :                                 if (metaName == NULL)
     105             :                                 {
     106           0 :                                         keyDel (k);
     107           0 :                                         fclose (file);
     108           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     109             :                                 }
     110             : 
     111          12 :                                 char * metaValue = readString (file, parentKey);
     112          12 :                                 if (metaValue == NULL)
     113             :                                 {
     114           0 :                                         keyDel (k);
     115           0 :                                         elektraFree (metaName);
     116           0 :                                         fclose (file);
     117           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     118             :                                 }
     119             : 
     120          12 :                                 keySetMeta (k, metaName, metaValue);
     121          12 :                                 elektraFree (metaName);
     122          12 :                                 elektraFree (metaValue);
     123          12 :                                 break;
     124             :                         }
     125             :                         case 'c':
     126             :                         {
     127             :                                 // copy meta
     128           2 :                                 char * keyName = readString (file, parentKey);
     129           2 :                                 if (keyName == NULL)
     130             :                                 {
     131           0 :                                         keyDel (k);
     132           0 :                                         fclose (file);
     133           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     134             :                                 }
     135             : 
     136           2 :                                 char * metaName = readString (file, parentKey);
     137           2 :                                 if (metaName == NULL)
     138             :                                 {
     139           0 :                                         keyDel (k);
     140           0 :                                         elektraFree (keyName);
     141           0 :                                         fclose (file);
     142           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     143             :                                 }
     144             : 
     145           2 :                                 const Key * sourceKey = ksLookupByName (returned, keyName, 0);
     146           2 :                                 if (sourceKey == NULL)
     147             :                                 {
     148           0 :                                         ELEKTRA_SET_RESOURCE_ERRORF (parentKey, "Could not copy meta data from key '%s': Key not found",
     149             :                                                                      keyName);
     150           0 :                                         keyDel (k);
     151           0 :                                         elektraFree (keyName);
     152           0 :                                         elektraFree (metaName);
     153           0 :                                         fclose (file);
     154           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     155             :                                 }
     156             : 
     157           2 :                                 if (keyCopyMeta (k, sourceKey, metaName) != 1)
     158             :                                 {
     159           0 :                                         ELEKTRA_SET_INTERNAL_ERRORF (parentKey, "Could not copy meta data from key '%s': Error during copy",
     160             :                                                                      keyName);
     161           0 :                                         keyDel (k);
     162           0 :                                         elektraFree (keyName);
     163           0 :                                         elektraFree (metaName);
     164           0 :                                         fclose (file);
     165           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     166             :                                 }
     167             : 
     168           2 :                                 elektraFree (keyName);
     169           2 :                                 elektraFree (metaName);
     170           2 :                                 break;
     171             :                         }
     172             :                         default:
     173           0 :                                 keyDel (k);
     174           0 :                                 fclose (file);
     175           0 :                                 return ELEKTRA_PLUGIN_STATUS_ERROR;
     176             :                         }
     177             :                 }
     178             : 
     179          16 :                 ksAppendKey (returned, k);
     180             :         }
     181             : 
     182           2 :         fclose (file);
     183             : 
     184           2 :         return ELEKTRA_PLUGIN_STATUS_SUCCESS;
     185             : }

Generated by: LCOV version 1.13