pem: refactor to expose pem iterator privately

This refactors pem.c to expose a new internal API, pem_next. This API will allow iteration/parsing of PEM(s). Other APIs in pem.c were updated to use pem_next.

pem_next behaves similar to pem_load_buffer, except it does not do any base64 decoding. Instead it just returns the start of the PEM as a string, and the length as an out parameter. This allows simple

PEM iteration loops. Strictly for pem.c usage we decode the base64 string in the loop, but settings.c will need this for parsing PEMs from settings files and returning the PEM as a full string, including the start/end tags.

endp was removed from pem_load_buffer as it was no longer being used.

---
  ell/pem-private.h | 32 ++++++++++++++++++++
  ell/pem.c         | 77 ++++++++++++++++++++++++++++++++---------------
  2 files changed, 85 insertions(+), 24 deletions(-)

create mode 100644 ell/pem-private.h

(quoted diff) +0 -1

-v4:
  * Added 'stict' argument to pem_next.

ell/pem-private.h new file +21 -0

new file mode 100644
index 0000000..bb0127f
@@ -0,0 +1,32 @@
+/*
+ *
+ *  Embedded Linux library
+ *
+ *  Copyright (C) 2019  Intel Corporation. All rights reserved.
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */

ell/pem-private.h new file +1 -0

+				const char **endp, bool strict);

ell/pem.c +12 -14

index c2bf7ba..79e4d07 100644
@@ -45,6 +45,7 @@
  #include "cipher.h"
  #include "cert-private.h"
  #include "missing.h"
+#include "pem-private.h"
 
  #define PEM_START_BOUNDARY	"-----BEGIN "
  #define PEM_END_BOUNDARY	"-----END "

@@ -126,15 +127,15 @@ static bool is_end_boundary(const void *buf, size_t buf_len,
  	return true;
  }
 
-static uint8_t *pem_load_buffer(const void *buf, size_t buf_len,
-				char **type_label, size_t *len,
-				const uint8_t **endp)
+const char *pem_next(const void *buf, size_t buf_len, char **type_label,
+				size_t *len, size_t *base64_len,
+				const char **endp, bool strict)
  {
  	const char *buf_ptr = buf;
  	const char *base64_data = NULL, *eol;
  	const char *label = NULL;
-	uint8_t *data;
  	size_t label_len = 0;
+	const char *start = NULL;
 
  	/*
  	 * The base64 parser uses the RFC7468 laxbase64text grammar but we

@@ -148,26 +149,28 @@ static uint8_t *pem_load_buffer(const void *buf, size_t buf_len,
  				break;
 
  		if (!base64_data) {
-			label = is_start_boundary(buf, eol - buf_ptr,
+			label = is_start_boundary(buf_ptr, eol - buf_ptr,
  							&label_len);
-
-			if (label)
+			if (label) {
+				start = label - strlen("-----BEGIN ");
  				base64_data = eol;
-		} else if (is_end_boundary(buf_ptr, eol - buf_ptr, label,
-							label_len)) {
-			data = l_base64_decode(
-					(const char *) base64_data,
-					buf_ptr - base64_data, len);
-			if (!data)
-				return NULL;
+			} else if (strict)
+				break;
+		} else if (start && is_end_boundary(buf_ptr, eol - buf_ptr,
+							label, label_len)) {

ell/pem.c +19 -5

  			if (endp)
-				*endp = (uint8_t *)eol + 1;
+				*endp = eol + 1;
 
-			return data;
+			return base64_data;
  		}
 
  		if (eol == buf_ptr + buf_len)

@@ -189,10 +192,24 @@ static uint8_t *pem_load_buffer(const void *buf, size_t buf_len,
  	return NULL;
  }
 
+static uint8_t *pem_load_buffer(const void *buf, size_t buf_len,
+				char **type_label, size_t *len)
+{
+	size_t base64_len;
+	const char *base64;
+
+	base64 = pem_next(buf, buf_len, type_label, NULL, &base64_len,
+				NULL, false);
+	if (!base64)
+		return NULL;
+
+	return l_base64_decode(base64, base64_len, len);
+}
+
  LIB_EXPORT uint8_t *l_pem_load_buffer(const void *buf, size_t buf_len,
  					char **type_label, size_t *out_len)
  {
-	return pem_load_buffer(buf, buf_len, type_label, out_len, NULL);
+	return pem_load_buffer(buf, buf_len, type_label, out_len);
  }
 
  struct pem_file_info {

@@ -242,7 +259,7 @@ LIB_EXPORT uint8_t *l_pem_load_file(const char *filename,
  		return NULL;
 
  	result = pem_load_buffer(file.data, file.st.st_size,
-					type_label, len, NULL);
+					type_label, len);
  	pem_file_close(&file);
  	return result;
  }

@@ -288,7 +305,7 @@ LIB_EXPORT struct l_certchain *l_pem_load_certificate_chain(
  LIB_EXPORT struct l_queue *l_pem_load_certificate_list_from_data(
  						const void *buf, size_t len)
  {
-	const uint8_t *ptr, *end;
+	const char *ptr, *end;
  	struct l_queue *list = NULL;
 
  	ptr = buf;

@@ -297,10 +314,22 @@ LIB_EXPORT struct l_queue *l_pem_load_certificate_list_from_data(
  	while (ptr && ptr < end) {
  		uint8_t *der;
  		size_t der_len;