LCOV - code coverage report
Current view: top level - src/plugins/quickdump - readv2.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 41 129 31.8 %
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 readVersion2 (FILE * file, KeySet * returned, Key * parentKey)
      11             : {
      12             :         // setup buffers
      13             :         struct stringbuffer valueBuffer;
      14           2 :         setupBuffer (&valueBuffer, 4);
      15             : 
      16             :         struct stringbuffer metaNameBuffer;
      17           2 :         setupBuffer (&metaNameBuffer, 4);
      18             : 
      19             :         // setup name buffer with parent key
      20             :         struct stringbuffer nameBuffer;
      21             : 
      22           2 :         size_t parentSize = keyGetNameSize (parentKey); // includes null terminator
      23           4 :         setupBuffer (&nameBuffer, parentSize + 4);
      24             : 
      25           2 :         keyGetName (parentKey, nameBuffer.string, parentSize);
      26           2 :         nameBuffer.string[parentSize - 1] = '/'; // replaces null terminator
      27           2 :         nameBuffer.string[parentSize] = '\0';    // set new null terminator
      28           2 :         nameBuffer.offset = parentSize;          // set offset to null terminator
      29             : 
      30             :         char c;
      31          20 :         while ((c = fgetc (file)) != EOF)
      32             :         {
      33          16 :                 ungetc (c, file);
      34             : 
      35          16 :                 if (!readStringIntoBuffer (file, &nameBuffer, parentKey))
      36             :                 {
      37           0 :                         elektraFree (nameBuffer.string);
      38           0 :                         elektraFree (metaNameBuffer.string);
      39           0 :                         elektraFree (valueBuffer.string);
      40           0 :                         fclose (file);
      41           0 :                         return ELEKTRA_PLUGIN_STATUS_ERROR;
      42             :                 }
      43             : 
      44          16 :                 char type = fgetc (file);
      45          16 :                 if (type == EOF)
      46             :                 {
      47           0 :                         elektraFree (nameBuffer.string);
      48           0 :                         elektraFree (metaNameBuffer.string);
      49           0 :                         elektraFree (valueBuffer.string);
      50           0 :                         fclose (file);
      51           0 :                         ELEKTRA_SET_RESOURCE_ERROR (parentKey, "Missing key type");
      52           0 :                         return ELEKTRA_PLUGIN_STATUS_ERROR;
      53             :                 }
      54             : 
      55             :                 Key * k;
      56             : 
      57          16 :                 switch (type)
      58             :                 {
      59             :                 case 'b':
      60             :                 {
      61             :                         // binary key value
      62             :                         kdb_unsigned_long_long_t valueSize;
      63           2 :                         if (!readUInt64 (file, &valueSize, parentKey))
      64             :                         {
      65           0 :                                 elektraFree (nameBuffer.string);
      66           0 :                                 elektraFree (metaNameBuffer.string);
      67           0 :                                 elektraFree (valueBuffer.string);
      68           0 :                                 fclose (file);
      69           0 :                                 return ELEKTRA_PLUGIN_STATUS_ERROR;
      70             :                         }
      71             : 
      72           2 :                         if (valueSize == 0)
      73             :                         {
      74           2 :                                 k = keyNew (nameBuffer.string, KEY_BINARY, KEY_SIZE, valueSize, KEY_END);
      75             :                         }
      76             :                         else
      77             :                         {
      78           0 :                                 void * value = elektraMalloc (valueSize);
      79           0 :                                 if (fread (value, sizeof (char), valueSize, file) < valueSize)
      80             :                                 {
      81           0 :                                         elektraFree (nameBuffer.string);
      82           0 :                                         elektraFree (metaNameBuffer.string);
      83           0 :                                         fclose (file);
      84           0 :                                         ELEKTRA_SET_RESOURCE_ERRORF (parentKey, "Error while reading file: Reason: %s", strerror (errno));
      85           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
      86             :                                 }
      87           0 :                                 k = keyNew (nameBuffer.string, KEY_BINARY, KEY_SIZE, (size_t) valueSize, KEY_VALUE, value, KEY_END);
      88           0 :                                 elektraFree (value);
      89             :                         }
      90           2 :                         break;
      91             :                 }
      92             :                 case 's':
      93             :                 {
      94             :                         // string key value
      95          14 :                         if (!readStringIntoBuffer (file, &valueBuffer, parentKey))
      96             :                         {
      97           0 :                                 elektraFree (nameBuffer.string);
      98           0 :                                 elektraFree (metaNameBuffer.string);
      99           0 :                                 elektraFree (valueBuffer.string);
     100           0 :                                 fclose (file);
     101           0 :                                 return ELEKTRA_PLUGIN_STATUS_ERROR;
     102             :                         }
     103          14 :                         k = keyNew (nameBuffer.string, KEY_VALUE, valueBuffer.string, KEY_END);
     104          14 :                         break;
     105             :                 }
     106             :                 default:
     107           0 :                         elektraFree (nameBuffer.string);
     108           0 :                         elektraFree (metaNameBuffer.string);
     109           0 :                         elektraFree (valueBuffer.string);
     110           0 :                         fclose (file);
     111           0 :                         ELEKTRA_SET_RESOURCE_ERRORF (parentKey, "Unknown key type %c", type);
     112           0 :                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     113             :                 }
     114             : 
     115          30 :                 while ((c = fgetc (file)) != 0)
     116             :                 {
     117          14 :                         if (c == EOF)
     118             :                         {
     119           0 :                                 keyDel (k);
     120           0 :                                 elektraFree (nameBuffer.string);
     121           0 :                                 elektraFree (metaNameBuffer.string);
     122           0 :                                 elektraFree (valueBuffer.string);
     123           0 :                                 fclose (file);
     124           0 :                                 ELEKTRA_SET_RESOURCE_ERROR (parentKey, "Missing key end");
     125           0 :                                 return ELEKTRA_PLUGIN_STATUS_ERROR;
     126             :                         }
     127             : 
     128          14 :                         switch (c)
     129             :                         {
     130             :                         case 'm':
     131             :                         {
     132             :                                 // meta key
     133          12 :                                 if (!readStringIntoBuffer (file, &metaNameBuffer, parentKey))
     134             :                                 {
     135           0 :                                         keyDel (k);
     136           0 :                                         elektraFree (nameBuffer.string);
     137           0 :                                         elektraFree (metaNameBuffer.string);
     138           0 :                                         elektraFree (valueBuffer.string);
     139           0 :                                         fclose (file);
     140           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     141             :                                 }
     142             : 
     143          12 :                                 if (!readStringIntoBuffer (file, &valueBuffer, parentKey))
     144             :                                 {
     145           0 :                                         keyDel (k);
     146           0 :                                         elektraFree (nameBuffer.string);
     147           0 :                                         elektraFree (metaNameBuffer.string);
     148           0 :                                         elektraFree (valueBuffer.string);
     149           0 :                                         fclose (file);
     150           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     151             :                                 }
     152          12 :                                 const char * metaValue = valueBuffer.string;
     153             : 
     154          12 :                                 keySetMeta (k, metaNameBuffer.string, metaValue);
     155          12 :                                 break;
     156             :                         }
     157             :                         case 'c':
     158             :                         {
     159             :                                 // copy meta
     160           2 :                                 if (!readStringIntoBuffer (file, &nameBuffer, parentKey))
     161             :                                 {
     162           0 :                                         keyDel (k);
     163           0 :                                         elektraFree (nameBuffer.string);
     164           0 :                                         elektraFree (metaNameBuffer.string);
     165           0 :                                         elektraFree (valueBuffer.string);
     166           0 :                                         fclose (file);
     167           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     168             :                                 }
     169             : 
     170           2 :                                 if (!readStringIntoBuffer (file, &metaNameBuffer, parentKey))
     171             :                                 {
     172           0 :                                         keyDel (k);
     173           0 :                                         elektraFree (nameBuffer.string);
     174           0 :                                         elektraFree (metaNameBuffer.string);
     175           0 :                                         elektraFree (valueBuffer.string);
     176           0 :                                         fclose (file);
     177           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     178             :                                 }
     179             : 
     180           2 :                                 const Key * sourceKey = ksLookupByName (returned, nameBuffer.string, 0);
     181           2 :                                 if (sourceKey == NULL)
     182             :                                 {
     183           0 :                                         ELEKTRA_SET_RESOURCE_ERRORF (parentKey, "Could not copy meta data from key '%s': Key not found",
     184             :                                                                      nameBuffer.string);
     185           0 :                                         keyDel (k);
     186           0 :                                         elektraFree (nameBuffer.string);
     187           0 :                                         elektraFree (metaNameBuffer.string);
     188           0 :                                         elektraFree (valueBuffer.string);
     189           0 :                                         fclose (file);
     190           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     191             :                                 }
     192             : 
     193           2 :                                 if (keyCopyMeta (k, sourceKey, metaNameBuffer.string) != 1)
     194             :                                 {
     195           0 :                                         ELEKTRA_SET_RESOURCE_ERRORF (parentKey, "Could not copy meta data from key '%s': Error during copy",
     196             :                                                                      &nameBuffer.string[nameBuffer.offset]);
     197           0 :                                         keyDel (k);
     198           0 :                                         elektraFree (nameBuffer.string);
     199           0 :                                         elektraFree (metaNameBuffer.string);
     200           0 :                                         elektraFree (valueBuffer.string);
     201           0 :                                         fclose (file);
     202           0 :                                         return ELEKTRA_PLUGIN_STATUS_ERROR;
     203             :                                 }
     204             :                                 break;
     205             :                         }
     206             :                         default:
     207           0 :                                 keyDel (k);
     208           0 :                                 elektraFree (nameBuffer.string);
     209           0 :                                 elektraFree (metaNameBuffer.string);
     210           0 :                                 elektraFree (valueBuffer.string);
     211           0 :                                 fclose (file);
     212           0 :                                 ELEKTRA_SET_RESOURCE_ERRORF (parentKey, "Unknown meta type %c", type);
     213           0 :                                 return ELEKTRA_PLUGIN_STATUS_ERROR;
     214             :                         }
     215             :                 }
     216             : 
     217          16 :                 ksAppendKey (returned, k);
     218             :         }
     219             : 
     220           2 :         elektraFree (nameBuffer.string);
     221           2 :         elektraFree (metaNameBuffer.string);
     222           2 :         elektraFree (valueBuffer.string);
     223             : 
     224           2 :         fclose (file);
     225             : 
     226           2 :         return ELEKTRA_PLUGIN_STATUS_SUCCESS;
     227             : }

Generated by: LCOV version 1.13