Support -g option to dump value string only (no key string, no quotes).

lib/lib_vpd.c

 /*
  * Copyright (C) 2010 Google Inc.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 266 matching lines @@
   struct StringPair *found;
 
   found = findString(container, key);
   if (found) {
     free(found->key);
     free(found->value);
     fillStringPair(found, key, value, pad_len);
   } else {
     struct StringPair *new_pair = malloc(sizeof(struct StringPair));
     assert(new_pair);
+    memset(new_pair, 0, sizeof(struct StringPair));
 
     fillStringPair(new_pair, key, value, pad_len);
 
     /* append this pair to the end of list. to keep the order */
     if (found = container->first) {
       while (found->next) found = found->next;
       found->next = new_pair;
     } else {
       container->first = new_pair;
     }
@@ skipping 25 matching lines @@
                                   current->pad_len,
                                   max_buf_len,
                                   buf,
                                   generated)) {
       return VPD_FAIL;
     }
   }
   return VPD_OK;
 }
 
+int setContainerFilter(struct PairContainer *container,
+                       const uint8_t *filter) {
+  struct StringPair *str;
+
+  for (str = container->first; str; str = str->next) {
+    if (filter) {
+      /*
+       * TODO(yjlou):
+       * Now, we treat the inputing filter string as plain string.
+       * Will support regular expression syntax in future if needed.
+       */
+      if (strcmp(str->key, filter)) {
+        str->filter_out = 1;
+      }
+    } else {
+      str->filter_out = 0;
+    }
+  }
+  return VPD_OK;
+}
+
 /* Export the container content with human-readable text. */
 int exportContainer(const int export_type,
                     const struct PairContainer *container,
                     const int max_buf_len,
                     uint8_t *buf,
                     int *generated) {
   struct StringPair *str;
   int index;
 
   assert(generated);
   index = *generated;
 
   for (str = container->first; str; str = str->next) {
     int copy_len;
 
+    if (str->filter_out)
+      continue;
+
     if (export_type == VPD_EXPORT_AS_PARAMETER) {
       char pad_str[32];
       int pad_len;
 
       snprintf(pad_str, sizeof(pad_str), "-p %d -s ", str->pad_len);
       pad_len = strlen(pad_str);
       if ((index + pad_len) > max_buf_len) return VPD_FAIL;
       strcpy(&buf[index], pad_str);
       index += pad_len;
     }
 
-    /* double quote */
-    if ((index + 1 > max_buf_len)) return VPD_FAIL;
-    buf[index++] = '"';
+    if (export_type != VPD_EXPORT_VALUE) {
+      /* double quote */
+      if ((index + 1 > max_buf_len)) return VPD_FAIL;
+      buf[index++] = '"';
 
-    /* output key */
-    if ((index + strlen(str->key)) > max_buf_len) return VPD_FAIL;
-    strcpy(&buf[index], str->key);
-    index += strlen(str->key);
+      /* output key */
+      if ((index + strlen(str->key)) > max_buf_len) return VPD_FAIL;
+      strcpy(&buf[index], str->key);
+      index += strlen(str->key);
 
-    /* double quote */
-    if ((index + 1 > max_buf_len)) return VPD_FAIL;
-    buf[index++] = '"';
+      /* double quote */
+      if ((index + 1 > max_buf_len)) return VPD_FAIL;
+      buf[index++] = '"';
 
-    /* equal sign */
-    if ((index + 1 > max_buf_len)) return VPD_FAIL;
-    buf[index++] = '=';
+      /* equal sign */
+      if ((index + 1 > max_buf_len)) return VPD_FAIL;
+      buf[index++] = '=';
 
-    /* double quote */
-    if ((index + 1 > max_buf_len)) return VPD_FAIL;
-    buf[index++] = '"';
+      /* double quote */
+      if ((index + 1 > max_buf_len)) return VPD_FAIL;
+      buf[index++] = '"';
+    }
 
     /* output value */
     if (str->pad_len != VPD_AS_LONG_AS)
       copy_len = MIN(str->pad_len, strlen(str->value));
     else
       copy_len = strlen(str->value);
     if ((index + copy_len) > max_buf_len) return VPD_FAIL;
     memcpy(&buf[index], str->value, copy_len);
     index += copy_len;
 
-    /* double quote */
-    if ((index + 1 > max_buf_len)) return VPD_FAIL;
-    buf[index++] = '"';
+    if (export_type != VPD_EXPORT_VALUE) {
+      /* double quote */
+      if ((index + 1 > max_buf_len)) return VPD_FAIL;
+      buf[index++] = '"';
 
-    /* new line */
-    if ((index + 1 > max_buf_len)) return VPD_FAIL;
-    buf[index++] = '\n';
+      /* new line */
+      if ((index + 1 > max_buf_len)) return VPD_FAIL;
+      buf[index++] = '\n';
+    }
   }
 
   /* null terminator */
   if ((index + 1 > max_buf_len)) return VPD_FAIL;
   buf[index++] = '\0';
 
   *generated = index;
 
   return VPD_OK;
 }
 
 void destroyContainer(struct PairContainer *container) {
   struct StringPair *current;
 
   for (current = container->first; current;) {
     struct StringPair *next;
 
     if (current->key) free(current->key);
     if (current->value) free(current->value);
     next = current->next;
     free(current);
     current = next;
   }
 }