diff --git a/src/UsefulBuf.c b/src/UsefulBuf.c
index 282b6ad..4213ab2 100644
--- a/src/UsefulBuf.c
+++ b/src/UsefulBuf.c
@@ -2,7 +2,7 @@
  Copyright (c) 2016-2018, The Linux Foundation.
  Copyright (c) 2018, Laurence Lundblade.
  All rights reserved.
- 
+
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:
@@ -16,7 +16,7 @@
       contributors, nor the name "Laurence Lundblade" may be used to
       endorse or promote products derived from this software without
       specific prior written permission.
- 
+
 THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
@@ -32,17 +32,17 @@
 
 /*===================================================================================
  FILE:  UsefulBuf.c
- 
+
  DESCRIPTION:  General purpose input and output buffers
- 
+
  EDIT HISTORY FOR FILE:
- 
+
  This section contains comments describing changes made to the module.
  Notice that changes are listed in reverse chronological order.
- 
+
  when               who             what, where, why
  --------           ----            ---------------------------------------------------
- 09/07/17           llundbla        Fix critical bug in UsefulBuf_Find() -- a read off 
+ 09/07/17           llundbla        Fix critical bug in UsefulBuf_Find() -- a read off
                                     the end of memory when the bytes to find is longer
                                     than the bytes to search.
  06/27/17           llundbla        Fix UsefulBuf_Compare() bug. Only affected comparison
@@ -50,7 +50,7 @@
                                     UsefulBuf_Set() function.
  05/30/17           llundbla        Functions for NULL UsefulBufs and const / unconst
  11/13/16           llundbla        Initial Version.
- 
+
  =====================================================================================*/
 
 #include "UsefulBuf.h"
@@ -67,9 +67,9 @@
    if(uOffset > Dest.len || Src.len > Dest.len - uOffset) { // uOffset + Src.len > Dest.len
       return NULLUsefulBufC;
    }
-    
+
    memcpy((uint8_t *)Dest.ptr + uOffset, Src.ptr, Src.len);
-    
+
    return (UsefulBufC){Dest.ptr, Src.len + uOffset};
 }
 
@@ -86,7 +86,7 @@
    } else if (UB1.len > UB2.len) {
       return 1;
    } // else UB1.len == UB2.len
-   
+
    return memcmp(UB1.ptr, UB2.ptr, UB1.len);
 }
 
@@ -100,20 +100,20 @@
    if(BytesToSearch.len < BytesToFind.len) {
       return SIZE_MAX;
    }
-   
+
    for(size_t uPos = 0; uPos <= BytesToSearch.len - BytesToFind.len; uPos++) {
       if(!UsefulBuf_Compare((UsefulBufC){((uint8_t *)BytesToSearch.ptr) + uPos, BytesToFind.len}, BytesToFind)) {
          return uPos;
       }
    }
-   
+
    return SIZE_MAX;
 }
 
 
 /*
  Public function -- see UsefulBuf.h
- 
+
  Code Reviewers: THIS FUNCTION DOES POINTER MATH
  */
 void UsefulOutBuf_Init(UsefulOutBuf *me, UsefulBuf Storage)
@@ -121,10 +121,10 @@
     me->magic  = USEFUL_OUT_BUF_MAGIC;
     UsefulOutBuf_Reset(me);
     me->UB     = Storage;
-    
+
 #if 0
    // This check is off by default.
-   
+
    // The following check fails on ThreadX
 
     // Sanity check on the pointer and size to be sure we are not
@@ -142,37 +142,37 @@
 
 /*
  Public function -- see UsefulBuf.h
- 
+
  The core of UsefulOutBuf -- put some bytes in the buffer without writing off the end of it.
- 
+
  Code Reviewers: THIS FUNCTION DOES POINTER MATH
- 
+
  This function inserts the source buffer, NewData, into the destination buffer, me->UB.ptr.
- 
+
  Destination is represented as:
    me->UB.ptr -- start of the buffer
    me->UB.len -- size of the buffer UB.ptr
    me->data_len -- length of value data in UB
- 
+
  Source is data:
    NewData.ptr -- start of source buffer
    NewData.len -- length of source buffer
- 
+
  Insertion point:
    uInsertionPos.
- 
+
  Steps:
- 
+
  0. Corruption checks on UsefulOutBuf
- 
+
  1. Figure out if the new data will fit or not
- 
+
  2. Is insertion position in the range of valid data?
- 
+
  3. If insertion point is not at the end, slide data to the right of the insertion point to the right
- 
+
  4. Put the new data in at the insertion position.
- 
+
  */
 void UsefulOutBuf_InsertUsefulBuf(UsefulOutBuf *me, UsefulBufC NewData, size_t uInsertionPos)
 {
@@ -180,7 +180,7 @@
       // Already in error state.
       return;
    }
-   
+
    /* 0. Sanity check the UsefulOutBuf structure */
    // A "counter measure". If magic number is not the right number it
    // probably means me was not initialized or it was corrupted. Attackers
@@ -198,7 +198,7 @@
       me->err = 1;
       return; // Offset of valid data is off the end of the UsefulOutBuf due to uninitialization or corruption
    }
-   
+
    /* 1. Will it fit? */
    // WillItFit() is the same as: NewData.len <= (me->size - me->data_len)
    // Check #1 makes sure subtraction in RoomLeft will not wrap around
@@ -207,7 +207,7 @@
       me->err = 1;
       return;
    }
-   
+
    /* 2. Check the Insertion Position */
    // This, with Check #1, also confirms that uInsertionPos <= me->size
    if(uInsertionPos > me->data_len) { // Check #3
@@ -215,17 +215,17 @@
       me->err = 1;
       return;
    }
-   
+
    /* 3. Slide existing data to the right */
    uint8_t *pSourceOfMove       = ((uint8_t *)me->UB.ptr) + uInsertionPos; // PtrMath #1
    size_t   uNumBytesToMove     = me->data_len - uInsertionPos; // PtrMath #2
    uint8_t *pDestinationOfMove  = pSourceOfMove + NewData.len; // PtrMath #3
    size_t   uRoomInDestination  = me->UB.len - (uInsertionPos + NewData.len); // PtrMath #4
-   
+
    if(uNumBytesToMove && me->UB.ptr) {
       memmove(pDestinationOfMove, pSourceOfMove, uNumBytesToMove);
    }
-   
+
    /* 4. Put the new data in */
    uint8_t *pInsertionPoint = ((uint8_t *)me->UB.ptr) + uInsertionPos; // PtrMath #5
    uRoomInDestination       = me->UB.len - uInsertionPos; // PtrMath #6
@@ -238,25 +238,25 @@
 
 /*
  Rationale that describes why the above pointer math is safe
- 
+
  PtrMath #1 will never wrap around over because
    Check #0 in UsefulOutBuf_Init makes sure me-UB.ptr + me->size doesn't wrap
    Check #1 makes sure me->data_len is less than me->UB.len
    Check #3 makes sure uInsertionPos is less than me->data_len
- 
+
  PtrMath #2 will never wrap around under because
    Check #3 makes sure uInsertionPos is less than me->data_len
- 
+
  PtrMath #3 will never wrap around over because   todo
    PtrMath #1 is checked resulting in pStartOfDataToMove being between me->UB.ptr and a maximum valid ptr
-   
+
  PtrMath #4 will never wrap under because
     Check #3 makes sure uInsertionPos is less than me->data_len
     Check #3 allows Check #2 to be refactored as NewData.Len > (me->size - uInsertionPos)
     This algebraically rearranges to me->size > uInsertionPos + NewData.len
- 
+
  PtrMath #5 is exactly the same as PtrMath #1
- 
+
  PtrMath #6 will never wrap under because
    Check #1 makes sure me->data_len is less than me->size
    Check #3 makes sure uInsertionPos is less than me->data_len
@@ -264,26 +264,26 @@
 
 
 /*
- Public function -- see UsefulBuf.h 
+ Public function -- see UsefulBuf.h
  */
 UsefulBufC UsefulOutBuf_OutUBuf(UsefulOutBuf *me)
 {
    if(me->err) {
       return NULLUsefulBufC;
    }
-   
+
    if(me->magic != USEFUL_OUT_BUF_MAGIC) {
       me->err = 1;
       return NULLUsefulBufC;
    }
-    
+
    return (UsefulBufC){me->UB.ptr,me->data_len};
 }
 
 
 /*
  Public function -- see UsefulBuf.h
- 
+
  Copy out the data accumulated in to the output buffer.
  */
 UsefulBufC UsefulOutBuf_CopyOut(UsefulOutBuf *me, UsefulBuf pDest)
@@ -302,7 +302,7 @@
  Public function -- see UsefulBuf.h
 
  The core of UsefulInputBuf -- consume some bytes without going off the end of the buffer.
- 
+
  Code Reviewers: THIS FUNCTION DOES POINTER MATH
  */
 const void * UsefulInputBuf_GetBytes(UsefulInputBuf *me, size_t uAmount)
@@ -311,13 +311,13 @@
    if(me->err) {
       return NULL;
    }
-   
+
    if(!UsefulInputBuf_BytesAvailable(me, uAmount)) {
       // The number of bytes asked for at current position are more than available
       me->err = 1;
       return NULL;
    }
-   
+
    // This is going to succeed
    const void * const result = ((uint8_t *)me->UB.ptr) + me->cursor;
    me->cursor += uAmount; // this will not overflow because of check using UsefulInputBuf_BytesAvailable()