Tags

The Featureless Linux Library development version 0.7.0 is released.

This is a development release.
The 0.7 development code has gone too long without a formal release tag.
This development branch has seen development as far back as August 3, 2022 and much of the 0.6 includes a lot of back ported code from 0.7.
This release represents a starting point for many planned changes and updates throughout the year.

This development code has some design changes that makes the project a little more versatile and extensible but at a cost of slightly larger code.
Many of the programs now have a more consistent and modular design that allows for housing multiple related projects in the same code base.
Several of the projects have been renamed and simplified into shorter names, such as f_string_range_t now being f_range_t.
A new program called EKI, also known as Extended IKI, that handles the EKI specifications is now available.

The release packages are made like this:
  # bash build/scripts/package.sh -p -P "monolithic-" build
  # bash build/scripts/package.sh -l -P "level-" build
  # bash build/scripts/package.sh -i -P "individual-" build
  # bash build/scripts/package.sh -S all -P "stand_alone-" build

  And change into each individual package group and do the following:
  # for i in * ; do echo ; echo $i ; tar -c $i > ${i}.tar && sha256sum ${i}.tar > ${i}.tar.sha256 && gpg -bas -u 02E939B8F7EFE597 ${i}.tar && gpg --verify ${i}.tar.asc && gzip -9 ${i}.tar ; done

The Featureless Linux Library stable version 0.6.12 is released.

This release provides some significant polishing, bug fixing, and corrections (or clarifications) to the project, the standards, and the specifications.
Much of this work is done to pave the way for forward compatibility with improvements and changes introduced in the 0.7 development branches.
I try to avoid making such changes in the specifications for stables releases but I feel these specific changes are merited.

This increases the correctness of the FSS processing code, specifically with the FSS read functions.
The previous behavior only cared whether or not the tests produce equivalent results in terms of reading and writing.
I back ported the 0.7 runtime tests and found that it would be better to have consistent and correct output in regards to white space.
Doing this also exposed several bugs and mistakes in the FSS processing code.

The FSS Embedded Read, in particular, was completely forgotten about by me.
The previous releases have been marked stable but I forgot to actually verify the proper functioning of the FSS Embedded Read program.
The back porting of the runtime tests exposed significant problems with the FSS Embedded Read program.

I had not implemented the `--columns` support for FSS Embedded Read in prior releases.
The `--columns` is now properly supported and has runtime tests.

The FSS Embedded Read to include the back ported fixes from the 0.7 development branch:
  - The use of `f_memory_array_increase()` is incorrect in several cases.
  - Switch to `f_memory_array_resize()`.
  - Add two when resizing to account for the depth position but also an additional element as a minor memory allocation optimization.
  - The `--select` now also follows the more strict behavior as implemented in the 0.7 branch.
  - The `--total` to match the more strict behavior as implemented in the 0.7 branch.

The FSS Embedded Read has the following additional notable fixes thanks to the runtime tests:
  - Security issue regarding incorrect memset value (passed `sizeof(skip)` when instead `sizeof(bool)` should be used).
  - The `--line` parameter is not being correctly validated and throws an error when a value is specified.
  - Fix a bug where empty Content is being improperly handled and '}' is being returned as the Content for empty Content.
  - The `--select` is not always printing a number, so make sure a number, even if it is `0`, is always printed.
  - The comments are not being properly processed because `graph_first` is not and should be being set to 0x1 at start, resulting in the first comment is not being treated as a comment.
  - The entire Content is being displayed when `--object` is used with `--line` when instead only a single line must be printed.
  - Column counts with empty data are not being correctly handled.
  - Should not display any lines when Content is empty and Objects are not being printed.
  - Delimits are not being applied when printing in line mode.
  - Do not double-print the before spaces when both original and trim modes are in use.
  - Print the before even with original and trim are in use when the Object has no size.

The FSS-0002 and FSS-0003 standards have some unclear situations regarding the white space before and after a valid Object that need clarification.
I discovered problems and realized that the standard could be more clear according to the spaces before and after the Object.
This does not change the FSS-0002 and FSS-0003 standards in any functional way.
The simply clarifies the standard regarding the spaces to make it more clear and reduce the chances for a mistake.

The original print is now better preserved.
Printing an Object can now print the before and after Object characters (usually white space).
The trimming and original print may be used together to produce the results where the is no white space before or after the Object but everything else from the original source is preserved.
This combination of trim and original essentially ensure that the old behavior can be still produced.
This does not utilize the `closes` structure as is done in the 0.7 development branches to ensure API does not get broken.
This is mostly simulated and more proper and precise support for this requires at least the 0.7 development branch.

I did some experimentation and found that I could get this project to build and run on an Android environment.
I generally do not want OS-specific build files in the core FLL project.
This should help build more support for the Android environment and help pave the way for future projects that may help those users unfortunate enough to find themselves in an Android environment.
This Android functionality is not well tested nor is it well supported.
The Android support has been tested to build using `bootstrap.sh` and then using `fake`.

Example build and install process:
  ```
  # mkdir ~/software
  # cd fll-0.6.X/
  # ./bootstrap.sh build -m monolithic -m thread -m clang -m android && ./install.sh ~/software
  # cd ../fake-0.6.X/
  # ./bootstrap.sh build -m monolithic -m thread -m clang -m android -w ~/software && ./install.sh ~/software
  # export LD_LIBRARY_PATH=~/software/libraries/shared
  # export PATH=~/software/programs/shared
  # cd ../byte_dump-0.6.X/
  # fake -m monolithic -m thread -m clang -m android -w ~/software && ./install.sh ~/software
  ```

Example execution of `byte_dump` of `bash` program (this is a large dump).
  ```
  # byte_dump -wt 7 $(type -p bash)
  ```

The Featureless Make is intended to not be language specific since its inception.
I did not know how the languages were to work, so I mostly built this to guarantee C/C++ support.

I recently discovered that the `golang` supports some command line based compilation.
The `golang` is now supported in the most basic way, but this support is not well tested.
Use the `example_go` project as a point of reference.
I have only tested the basic build and I have not done anything advanced.

This relaxes some of the requirements in the build specification.
The `bash` is changed to `shell` to encourage more types of scripts.
The `custom` is added and used as a fallback if `build_language_path` is not used.

I found that there needs to be some additional settings in the `settings` specification.
This updates the specification and adds:
  - `build_compiler_arguments`
  - `build_compiler_arguments_library`
  - `build_compiler_arguments_library_shared`
  - `build_compiler_arguments_library_static`
  - `build_compiler_arguments_object`
  - `build_compiler_arguments_object_shared`
  - `build_compiler_arguments_object_static`
  - `build_compiler_arguments_program`
  - `build_compiler_arguments_program_shared`
  - `build_compiler_arguments_program_static`
  - `build_compiler_arguments_shared`
  - `build_compiler_arguments_static`
  - `build_language_path`

Some discovered mistakes in the language of the specification are also fixed.

The following are changes since the 0.6.11 stable release.

Exploit Fixes:
  - None.

Security Fixes:
  - Incorrect memset value (passed `sizeof(skip)` when instead `sizeof(bool)` should be used).

Features:
  - Fake settings specification updates and enable simple golang support.
  - Add support for building under Android.

Bug Fixes:
  - FSS Embedded List Read printing tabbing when using original mode and trim mode.
  - Get the FSS Embedded List Read working as expected based on runtime tests.
  - Replace `index()` with `strchr()`.
  - FSS Embedded List Read is not applying delimits when printing in line mode.
  - Empty Content lines with no Object printed should not be included for FSS Embedded List.
  - Incorrect handling of column counts with empty data for FSS Embedded List Read.
  - FSS Embedded Read is printing a single line with `--line` parameter with `--object`.
  - Invalid comment handling in FSS Embedded Read.
  - FSS Embedded Read has incomplete and incorrect code.
  - FSS Extended Read needs to only print new line if Object or Content is printed.
  - FSS Extended Read needs to properly handle `--total` when using `--select` and also `--empty`.
  - FSS Basic Read needs to properly handle `--total` when using `--select` and also `--empty`.

Refactors:
  - None.

Regressions:
  - None.

Updates:
  - The bootstrap example script now handles building using fake.
  - Refresh firewall iptables rules and relax some of the defaults.
  - Cgroup example controller script example to show running under a SystemD system.
  - Improve robustness of the `fll_control_group_prepare()` function.
  - Implement Object alignment and trim expanding in FSS Read programs and restructure the program flags.
  - The FSS Lists (FSS-0002, FSS-0003, FSS-0008, etc..) to match recent specification changes and reduce redundancy.
  - The FSS Basic List (FSS-0002) to match recent specification changes regading Objects.
  - The FSS-0002 and FSS-0003 standards, modifying the space after Object rules.
  - Clarify the FSS-0002 and FSS-0003 standards regarding the white space before and after a valid Object.
  - Always count any `--select` when using `--object` for FSS Read programs.
  - Improvements around FSS Read functions regarding correctness.
  - Back port tests for the FSS Read programs with more recent changes.

The Featureless Linux Library stable version 0.6.11 is released.

This release brings in fixes for problems exposed by more regular use of and by active development on the 0.7.x development branch. In particular, the Controller program has seen a lot of fixes and improvements.

I have been working on additional projects, such as Tacocat. This project has a different structure and has revealed some bugs or mistakes in the fakefile and settings standards for the Featureless Make program. I have already been aware of this potential problem but I had been hoping that I would not need to implement a new feature in the standard. Unfortunately, I have concluded that I do in fact need a new feature. The fakefile and settings standards now support a new Object called stage. I chose the word stage to avoid conflicts with existing build focused Object names. This new feature in the standard fixes a bug where multiple settings might conflict with each other. I opted to classify this new feature as a bug fix. This change further exposed an oversight where slashes are not supposed to be supported in the build name Object and the version Objects. The new stage Object as well as the build_name, version_major, version_major_prefix, version_minor, version_minor_prefix, version_micro, version_micro_prefix, version_nano, version_nano_prefix and version_target Objects now explicitly prohibit slashes.

I also found some notable bugs in the FSS read programs. The processing of comments is incorrect and the ranges being processed are entirely missing the necessary range checks. I back ported the runtime tests for the FSS read programs to better help catch problems and regressions.

A new feature is created for the Simple Packet (FSS-000F) standard for adding support for a magic block. A magic block provides the ability to identify the type of packet being transmitted. This has performance, firewalling, and also local storage implications. The packets can be directly saved as a file and that file can be easily identified and read. This does not define the magic identifiers themselves. This only adds the functionality to specify them. For security reasons, the presence of the magic block is optional. There is not network functionality in the 0.6 versions of the FLL project. This is only a change to the standard. The 0.7 versions and later of the FLL project implement network related functionality.

The memory consumption consumed by certain functions is now greatly reduced. The lazy allocation process works really well, except for certain key conditions. One of these conditions is when the allocation step is set to some large value, such as 128. Then, a huge amount of arrays are allocation, each with only one or two elements in the array. I found that when using fss_basic_read on a large data set that I would incur an 8 Gigabyte memory allocation cost. After the optimization that same allocation cost went down to about 500 Megabytes. The reason for this is directly because of about four or five differernt one element arrays are being allocation for maybe 2,000,000 Objects in some file. The optimization has a cost of additional logic and a few more allocations for small arrays. This is not considered too expensive because these arrays are small and the cost of re-allocating them is relatively inexpensive.

The following are changes since the 0.6.10 stable release.

Exploit Fixes:
- None.

Security Fixes:
- FLL: Console parameter single short values array is too small.
- Controller: Remove the simulate feature that actually executes a script.
- Controller: Incorrect sizeof() used in process pointers.
- Controller: Wrong sizeof() type used in allocation functions.
- FSS Read programs: Missing range checks on comment processing.

Features:
- FLL: Add "Magic Bit" to the FSS-000F (Simple Packet) format.

Bug Fixes:
- FLL: Enable missing support for grave (backtick) is IKI.
- FLL: The fl_directory_create() needs to also handle F_file_found_not.
- Controller: Stand alone build doesn't compile due to incorrect _di_f_thread_mutex_lock_timed_ config.h setting.
- Controller: Incorrect length on string CONTROLLER_rule_print_control_groups_prepare_s.
- Controller: Double creation of mutex alert lock.
- Controller: Parameter type is f_number_unsigned_t and not uint8_t.
- Controller: Incorrectly adding an extra '/' to the file name.
- Controller: Incorrect thread unlock in controller_rule_process().
- Controller: Improve error message regarding file not found..., found.
- Controller: Don't assign enabled variable on lock failure to avoid potential race condition.
- Controller: Error printing function has wrong locking.
- Controller: Replace f_signal_mask() with f_thread_signal_mask().
- Controller: New line is not being printed because sequence is missing.
- Controller: Incorrect error message describing wrong value number.
- Controller: Simulation is using error output rather than normal output in one case.
- Controller: The $ should instead be a % in the fl_print_format() call.
- Controller: Add missing 'extern' to controller_entry_settings_read_map().
- Controller: The help code is being used instead of the light code
- Fake: Add stage setting to standards to prevent build state file conflicts.
- Fake: The build_name and version numbers should not support forward or backward slashes.
- FSS Read programs: Bugfix: Incorrect runtime tests for FSS Read programs.
- FSS Read programs: Bugfix: Properly back port runtime tests for FSS Read programs.

Refactors:
- None.

Regressions:
- None.

Updates:
- FLL: Back port runtime tests for FSS Read programs.
- FLL: Apply the not operator logic to avoid needing to literally specify it.
- FLL: Greatly reduce memory consumption by implementing simple low allocation step.
- FLL: Reduce memory usage by fl_fss_basic_content_read() in some circumstances.
- FLL: Optimize away the isdigit(), isalpha(), isalnum(), and isxdigit().
- FLL: Yet another file with a copyright year that needs to be updated.
- FLL: Specifications to use grave as the common term for backtick.
- FLL: The f_iki test needs to be updated following the version update.
- Controller: Add additional protection around assignment of global.thread.enabled during Controller exit process.
- Controller: Use copy of flag to avoid possible race conditions with controller_thread_is_enabled().
- Controller: Provide fallback should the locks on exit fail to catch and update function using pointer.
- Controller: Rewrite timing logic in controller.
- Controller: Reset cache in some cases and do so after error messages.
- Controller: Add missing extern for prototype of controller_unlock_print_flush().

The Featureless Linux Library stable version 0.6.10 is released.

This release brings in fixes exposed by more regular use and by active development on the 0.7.x development branch.

Fix problems with the FSS Extended Write where the quote characters that are not selected during the write are not being quoted.
These must still be quoted.

Fix problems regarding the latest GCC release (14.1.1).

Fix problems with both the FSS Extended write and FSS Basic write where the quote character at the start of an Object or Content is always being quoted in cases where it should not be.

The build environment has seen some improvements to make it work in more systems when using the default build settings.

The recently added -D_FORTIFY_SOURCE, for example, ended up causing problems on some systems.

The following are changes since the 0.6.9 stable release.

Security:
- Controller: Potential buffer overflow on 0 length array.

Features:
- None.

Bug Fixes:
- FLL: Problematic handling of object files.
- FLL: A lone quote inside quotes should not be escaped for FSS Basic and Extended.
- Fake: Incorrect memset type used in Featureless Make.
- Fake: FSS Extended Write is not properly quoting quotes.

Refactors:
- None.

Updates:
- FLL: Switch for..loop with memcpy() for character width copies.
- FLL: FSS-000E specification, adding "salt" and "time" as suggested headers.
- FLL: Add stand alone fss_basic_list_read, fss_basic_list_write, fss_extended_list_read, and fss_extended_list_write.
- FLL: Use bitwise operation check in f_thread_cancel_state_set().
- FLL: Remove -D_FORTIFY_SOURCE because several systems automatically add this and the screen is spammed with warnings.
- FLL: Add support for disable pthread mutex prioceiling for systems that do not support it.
- FLL: The build scripts copyright to 2024.
- FLL: Add experimental ctags generation and ctags file.
- FLL: Build files to have the correct build modes.
- FLL: Man pages date in preparation for 0.6.10 release.

Regressions:
- None.

The Featureless Linux Library stable version 0.6.9 is released.

This release address newly discovered bugs and problems that have been exposed by unit tests from the 0.7 development branch and some real world use cases.

This brings in some security related problems and upgrading is recommended.

A significant amount of development in the 0.7 development code base has yielded a number of changes worth back porting into this 0.6 stable code base.

This brings in a new feature for the test scripts to make testing for integrity and security bugs easier.
This change does not break API.

The specification documentation is updated to use the word "grave" in place of "backtick" to be more consistent with the more commonly accepted terminology for that character.

The firewall program has seem some considerably review and bug fixes.

The man pages have been refreshed.
The process is partially automated and then manually cleaned up.

The Open Standard License 1.0 has been formalized (OSLv1).
This project is updated to ensure that this is in use.
The project has already been using this standard for some time but during that time the standard was considered a draft.

The following are changes since the 0.6.8 stable release.

Security:
- FLL: Conversion is not handling NULL case when base unit is an unsupported type.
- FLL: The fl_print_format_convert() is missing the check on the pointer and update the related documentation comments.

Features:
- FLL: Add -a/--analyze to test.sh script.

Bug Fixes:
- FLL: Functions private_fl_fss_basic_read() and private_fl_fss_basic_write() are missing "const".
- FLL: Incorrect stop position is calculated when FSS content ends at the start position on FSS read operations.
- FLL: FSS Extended read fails to handle non-terminated quote as per specification.
- FLL: FSS Basic List and FSS Extended List print comment at the start of the Content.
- FLL: If the first character has a width greater than one then F_utf_fragment is incorrectly returned when using quotes.
- Featureless Make: Incorrect mode display when featureless make is building settings.
- Firewall: Error message is saying "lock" when it should say "stop".
- Firewall: Firewall program is not printing error when fll_fss_extended_read() fails.
- Firewall: Firewall program if condition is setting an error flag rather than checking the value.
- Firewall: Firewall length check from range is not calculating 0 correctly.
- Firewall: The debug mode is not working in firewall.
- Firewall: De-allocation call is missing in firewall program when "firewall stop" is used.
- FSS Extended Write: Is improperly associating Content with its respective Object.

Refactors:
- FLL: The backtick into the grave, for the specifications.

Updates:
- FLL: The FSS-000E specification needs to say "one required object" and not "two required objects".
- FLL: Optimize bitwise logic regarding removing bits.
- FLL: Make the -m thread option in the example bootstrap script more easily customizable.
- FLL: Add hopefully more secure compiler flags by default.
- FLL: Make sure stand alone builds have consistent buid mode settings.
- FLL: Backport improved return code failure reporting to firewall from 0.7 development.
- FLL: Backport fixes for bootstrap-example.sh, package.sh, and test.sh scripts.
- FLL: Back port settings configurations, such as gcc and flags.
- FLL: Back port the ability to explicitly skip a program in the bootstrap example script.
- FLL: Documentation man pages.
- FLL: Make the Open Standard License 1.0 formal.
- FLL: Disable -fstrict-flex-arrays=3 flag because it doesn't work on GCC 11.
- FLL: Add missing snippet from OSLv1 license.

The Featureless Linux Library stable version 0.6.8 is released.

This release is for the start of a new year.

There are not many changes and there are no code-based bug fixes.
Only a single bug fix exists and it is in a specification.

This contains mostly specification updates, clarifications, and fixes.

The Payload and Simple Packet specifications have "type" added as a recommended Object in the header section for the Payload.
The size of units is rewritten to make more sense in the Payload and Simple Packet specifications.
The Payload specification now allows for the "payload" section to be optional.

The most notable code change is the explicit casting of uint32_t when doing bit-wise operations for left and right shifting.
The goal here is to increase the integrity of the design and not allow any opportunity for the compiler or architecture to use a different size.

The following are changes since the 0.6.7 stable release.

Security:
- None.

Features:
- None.

Bug Fixes:
- FLL: Fix incorrect wording regarding negative times and add some clarification regarding defaults (in specification).

Refactors:
- None.

Updates:
- FLL: Specifications for Payload and Simple Packet.
- FLL: The fss-000e (Payload) specification should allow for the "payload" Section to be optional.
- FLL: Explicitly cast UTF conversion to/from to a uint32_t.
- Control: Use size_t and perform explicit casts in Control program.

With this release I hope to see the 0.6.7 as a very stable release.

Only a single functional feature is added and then it is a bug fix in the guise of a feature.
The Featureless Make program has an oversight in regards to specify a custom path within the buid settings paths.
I discovered this while working on the TacocaT program in the Kevux Tools project.

A new FSS standard, FSS-0010 "Encrypted Simple Packet", is added.
This is generally going to be in the 0.7.x and greater version

There are several changes to the FSS specifications.
The FSS standards themselves now have a "version" date added.
The specifications are currently versioned by the dates rather than some arbitrary number.
Should I get to an FLL 1.0.0, I will have to decide on whether or not to use a numeric version as well.
I very likely will have the specifications at 1.0.0 at that point as well.

I discovered a regression in the 0.6.6 release and possibly earlier regarding the dependencies in the stand alone builds.
This should no longer be a problem as of 0.6.7.

Several security concerns have been discovered and fixed in this release.

The following are changes since the 0.6.6 stable release.

Security Fixes:
- FLL: The f_iki allocation functions are calling f_memory_destroy() and f_memory_delete() when the
y should not, causing memory leak.
- FLL: Add additional checks against the parameters in fll_execute_program().
- FLL: Invalid allocation size for fll_execute_arguments_add_parameter_set().

Features:
- FSS: Add specification FSS-0010 "Encrypted Simple Packet".
- Fake: Add -U/--under parameter to Featureless Make.

Bug Fixes:
- FLL: Incorrect version numbers in some of the extra projects files.
- FLL: Incorrect sizeof() values for f_thread_mutex_attribute functions and f_thread_lock functions.
- FLL: Incorrect sizeof() values for numerous type array functions.
- FLL: Add missing parameter checking to fll_program_* functions, add "const" to parameter pointers, and add missing documentation comment for parameter.
- FLL: Problems exposed by clang-13.
- FSS: Mistakes in the FSS-000f Simple Packet specification.
- Byte Dump: Program binary mode is printing wrong number of padding.
- Controller: Incorrect function name in error message.

Refactors:
- None.

Updates:
- FLL: The defines in cygwin.txt documentation are out of date
- FSS: FSS-000F (Simple Packet) Specification.
- FSS: Specifications, replacing "emphasis" with "italic".
- FSS: Specifications, adding explicit version date and change license line format.
- FSS: FSS-000F specification, adding reasoning and improve the wording.

Regressions:
- FLL: Incorrect dependencies breaking some builds, specifically the stand alone builds.

The Featureless Linux Library stable version 0.6.6 is released.

This is release is made in celebration of the Fourth of July.

Adds the following stand alone programs:
- fss_basic_read
- fss_basic_write
- fss_extended_read
- fss_extended_write

There are about 1500 additional man pages representing the functions in addition to the usual bug fixes.
The man pages were sort of generated and then manually fixed.
These man pages are considered good enough but are not great.
There will likely be a future project to assist in generating man pages that are better than the tools that I currently used.

Of particular note is that I found and fixed problems in the FSS processing code.
The comments were not always being processed correctly resulting in actual Content being missed.

The Featureless Make build program has several notable fixes and improvements.
The build system has now seen a lot more uses and more corner cases and minor details are addressed.
Problems with propogating arguments across builds is now fixed.

The following are changes since the 0.6.5 stable release.

Security Fixes:
- None.

Features:
- None.

Bug Fixes:
- FLL: The testfile needs to handle the --build parameter and improve --work parameter handling.
- FLL: Handle f_directory_not status as an invalid directory.
- FLL: Quotes in FSS read functions are not being properly handled and fix backtick handling.
- FLL: The build scripts are not handling documentation directory.
- FLL: The boostrap script should not fail if documentation directory is empty.
- Fake: Use the custom build settings name if passed when printing current setting being used.
- Fake: Use arguments passed to fake when processing build with the custom build arguments.
- FSS Basic Read: The -T/--trim parameter is not being processed.
- FSS Extended List Read: FSS Extended List Read program should print new line after Object.
- FSS Identify: Add missing 'extern' keyword for fss_identify_process_name_compare() definition.
- FSS Identify: Remove spurious 'y' character in help message.
- FSS Identify: The fss_identify_process() should have f_string_empty_s rather than f_string_ascii_minus_s.
- FSS Identify: FSS Identify should process all --name parameters and not the last.
- FSS Identify: FSS Identify stand alone requires f_string_dynamic_append_nulless.
- FSS Read Programs: Comments are being included when processing --total and --at.
- FSS Read Programs: The line and total need to support the closing brace.

Refactors:
- None.

Updates:
- FLL: The Open Standard License, adding stronger terminology and more clarification.
- FLL: Relax the requirement in the license to be less verbose.
- FLL: Change program man pages to be referred to as "Program Manual".
- FLL: Add man pages for most or all FLL functions.
- FLL: Add stand alone fss_basic_read, fss_basic_write, fss_extended_read, and fss_extended_write.

The Featureless Linux Library stable version 0.6.5 is released.

This release contains fixes and improvements discovered during daily use and several back ported fixes.

Added the following stand alone programs:
- fss_payload_read
- fss_payload_write

There are several build system improvements to make the project easier to use.
Several of the project build scripts are out of date in parameter handling and processing.
Proper Featureless Make functionality that is expected to be supported by the boostrapt script is found lacking in a few small ways.

The build setting files and fakefile files in this project should now have some more environment variables added by default.
These added environment variables are focused on locale.

The function fl_string_dynamic_partial_compare_trim() has been found to not be exposed in the header files by accident.
This means that the previous API is not consistent with the compiled ABI.
The function is now present that the API should now be consistent with the ABI.

The Featureless Make program is not as usable in the previous releases when using commands like "fake help".
This is due to an oversight where there may be no "main" section for a file that only has a "help" section.
This bug is fixed such that an error is no longer produced when missing "main" in the cases where the "main" section is not required.

Parameter expansion problems in regards to quotes in Featureless Make is now resolved.

The way threading is being used and linked to based on the default projects settings has been improved upon.
Any relevant documentation is updated accordingly.

Overall the project is proven to be rather stable and there have been very few bugs that needed to be resolved.

The following are changes since the 0.6.4 stable release.

Security Fixes:
- FLL: fl_directory_list() is not appending a NULL.
- FLL: Add the locale specific environment variables to everything by default.
- FLL: Invalid read in trim comparison functions.
- Featureless Make: fake_build_arguments_standard_add() is treating static path the same as shared.
- FSS Basic List Read: Invalid read in help output due to incorrect size assigned to static string.

Features:
- None.

Bug Fixes:
- FLL: Fix return codes and clean up package.sh.
- FLL: Incorrect return code in tests causes false failures in CI.
- FLL: Incorrect wrapping define usage.
- FLL: Invalid macro name for f_string_map_multi_t and f_utf_string_map_multi_t.
- FLL: Rebuild the disable defines file and update the readme.
- FLL: Add missing function fl_string_dynamic_partial_compare_trim().
- FLL: The fl_string parsing functions do not check buffer.used.
- FLL: Out of date repository build scripts.
- FLL: Out of date install.sh and Featureless Make helper scripts.
- Featureless Make: Stand alone build fails to compile due to missing f_string_append_nulless().
- Featureless Make: The stage files should not begin with "-".
- Featureless Make: Remove extra arguments being added.
- Featureless Make: When specifying a specific section name, do not care if there is no "main" section.
- Featureless Make: Incorrect file path in error message.

Refactors:
- None.

Updates:
- FLL: Month name to April in man pages.
- FLL: Improve thread configuration, document modes in build settings files, and update build scripts.
- FLL: Back port utf string compare unit tests.
- FLL: Back port utf string compare code from 0.7.x.
- FLL: Back port unit tests from 0.7.x development.
- FLL: Add the locale specific environment variables to everything by default.
- Featureless Make: Use f_string_append_nulless() instead of f_string_append() just in case.
- Featureless Make: Don't call f_file_exists() until after child status is checked.
- FSS Payload Read/Write: Add stand alone build for fss_payload_read and fss_payload_write.

The Featureless Linux Library stable version 0.6.4 is released.

This release contains numerous bug fixes and code clean ups.
There are also some features implemented as either a solution to a bug or to accommodate changes to a specification.
This change also revisits some of the copyrights and further clarifies them.

Added the following stand alone programs:
- controller
- fss_identify
- iki_read
- iki_write

Copyrights are now displayed when the programs are passed the +C/++copyright standardized parameter.

The build and package scripts are improved to better automate stand alone package building.

This preemptively adds Kevux specific path global support to easy the package build process for Turtle Kevux.
This is done in a non-API and a non-ABI breaking manner.

The IKI standard is found to be slightly lacking.
There is a strong need for IKI variables immediately after word-characters that are not part of the variable name.
The IKI standard and specification is now updated to utilize open bracket '[' (U+005B) and close bracket ']' (U+005D), commonly referred to as "wrap" or "wrapping".
Such an IKI variable looks like [vocabulary]:"content" (as opposed to vocabulary:"content").
New functionality is provided to keep this project compliant with the recent changes to the IKI standard and specifications.

A major behavioral bug has been found in the Controller program regarding the "program" operation mode.
Solving this the simple way would then break other behavior.
To avoid this, a new feature is implemented, called the "helper" operation mode.
The "helper" operation mode provides an alternative to "program" operation mode to allow for starting tasks.

The recent work involving Featureless Make in the 0.7.x development branches has exposed a number of problems whose fixes have been back ported.

The Controller program has now be successfully tested and run under a SystemD system using "cgroups".
A quick and simple SystemD "cgroup" example Controller is now provided.

The following are changes since the 0.6.3 stable release.

Security Fixes:
- Featureless Make: Invalid read or write while expanding operations.
- Featureless Make: Add extra check range checks in Featureless Make build skeleton.
- Multiple Programs: NULL pointer dereference in writer due to pipe function result handling.

Features:
- FLL: Provide program parameter for displaying copyright.
- FLL: Enable support for stand_alone packaging with 'all'.
- FLL: Implement wrap support for IKI standard to be compliant with recent changes.
- Controller: The content action cache, comments, and delimits are not being properly cleared.
- Controller: Add support for 'helper' mode to compliment the 'program' mode.

Bug Fixes:
- FLL: Status Code stand alone has incorrect files added.
- FLL: Stand alone build file problems and bad define macros.
- FLL: Incorrect dependencies for individual build modes.
- FLL: Fix unterminated quote handling issue addressed by specifications clarification.
- FLL: Miscellaneous problems in file functions and Featureless Make related code.
- FLL: Control group function is partially outdated and uses incorrect integer.
- FLL: The bootstrap script "-d/--define" command does not match the Fake command.
- FLL: Short console arguments should not match when a single invalid exists.
- Controller: The control read only option is not being loaded.
- Controller: Remove out of place single quote in print.
- Controller: The Entry is not printing on simulate and validate combined mode.
- Controller: Multiple cancellations may occur, use mutex lock to prevent.
- Controller: Consistently use the same color context for the entry name.
- Featureless Make: Dead code in return status handling.
- Featureless Make: Number too large error should be returned as an error.
- Featureless Make: Add missing "extern" to functions in header.
- Featureless Make: Return result lost in Featureless Make for f_string_dynamic_append_nulless() call.
- Featureless Make: Set error status when link target is an empty string.
- Featureless Make: Printed error message is not utilize verbosity quite mode.
- Featureless Make: Print message is missing the percent before the 'Q' causing invalid printing.
- Featureless Make: Argument variable passed is a pointer, print the value not the pointer.
- Featureless Make: Fix typo in 'original' word.
- Featureless Make: Multiple single-valued Objects should used last instead of first Object.
- Featureless Make: Incorrect and confusing warning message in Featureless Make.
- Featureless Make: Invalid defines, incorrect comments, missing flags, and missing dependencies.
- Featureless Make: The build settings 'path_sources' is incorrectly added.
- Featureless Make: The -S/--sources parameter is not being correctly used.
- Featureless Make: Incorrect documentation in fakefile.txt.
- Featureless Make: Fakefile processing with color context is producing extra spaces when unquoted.
- Featureless Make: Incorrect stream used when printing output in verbose directory recursion.
- Featureless Make: The stream is locked again rather than unlocked after being locked.
- Multiple Programs: FSS Write programs don't correctly handle multi-Content per Object situations.

Refactors:
- None.

Updates:
- FLL: Add unit tests for fll_path.
- FLL: Further clarify quoting in FSS specifications.
- FLL: Clarify FSS specifications in regards to quote behavior.
- FLL: Style guide documentation.
- FLL: Program man pages, adding copyright, fixing help, and adding missing period.
- FLL: Open Standard License to be 1.0 or later rather than just 1.0.
- FLL: Fakefile specification.
- FLL: Add fanalyzer build mode.
- FLL: Add locale environment variable support, install, and help support in fakefiles.
- FLL: Add new standard global type, "_g".
- Controller: Man page for controller specification changes regarding "helper" mode.
- Controller: Add example controller script for running under SystemD using cgroups.
- Controller: Add stand alone controller build.
- Controller: Controller and Control man page documentation.
- Featureless Make: Further Fakefile processing with IKI replacement space problems.
- Featureless Make: Use the signal check counter more consistently in Featureless Make.
- Featureless Make: Print message rather than an error when termination signal is received.
- Featureless Make: Allocate extra space for the terminating NULL.
- Featureless Make: Use f_string_dynamic_append_nulless() instead of f_string_dynamic_append().
- Featureless Make: Featureless Make stand alone build now needs f_file_stream_read instead of f_file_read.
- Featureless Make: Use f_file_stream_read() instead of f_file_read() after opening as a stream.
- Featureless Make: Use pre-existing cache rather than using a new variable.
- Firewall: Add additional sanity checks.
- Multiple Programs: Change man page year and month from January 2023 to March 2023.
- Multiple Programs: Add stand alone fss_identify, iki_read, ad iki_write builds.
- Multiple Programs: Program man pages, adding copyright, fixing help, and adding missing period.

The Featureless Linux Library stable version 0.6.3 is released.

This release contains breaking changes in the Featureless Make program to address functionality that is missing but should, if not must, be available.
This primarily adds documentation and fixes a small number of bugs found.

Added the following stand alone programs:
- fss_status_code
- status_code

There are now man pages for all of the programs.
These are manually crafted.

The Featureless Make program has two new features that are important enough to break the "featureless" concept as an exception to the rule.

The Featureless Make program must be able to install settings files and documentation files.
The documentation directory now exists.
This is similar to the documents directory but is entirely focused on documentation that is installed onto the system.
The documents directory might be synonymous with the standard share directory and the documentation directory might be synonymous with the share/man or share/docs directories.

The FLL install scripts is also updated to handle the installation of the settings and documentation files.

The Feeatureless Make program now supports the ability to specify a named section on the command line to be able to reasonably act as an alternative to GNU Make.
It is now possible to create an "install" section.
The user could then run "fake install" in a similar manner to how "make install" works.
The core reserved words are never run in this way.
These core reserved words are "build", "clean", "make", and "skeleton".

The following are changes since the 0.6.2 stable release.

Security Fixes:
- Control: Check if 'main' is NULL.
- Controller: Check if 'main' is NULL.

Features:
- FLL: Add support for installing documentation to the install.sh script.
- Featureless Make: Support passing a fakefile Section name to the main program.
- Featureless Make: Add missing documentation handling functionality to Featureless Make.

Bug Fixes:
- FLL: Several problems with the wrapping define macros, unused private functions, non-existent functions, and fix dependency.
- FLL: The f_int_128_t is using incorrect size.
- FLL: Fix wrapping define macros for several functions across different projects.
- FLL: The type macros in type.h are missing 'f_' or have spurious '_type' in the name.
- FLL: Incorrect define macros for private functions in f_file.
- FLL: Incorrect macro definition _di_pthread_support_ vs _di_thread_support_.
- FLL: The f_signal unit tests after significant change.
- FLL: The signal is not properly closing.
- Featureless Make: Not defaulting to top-level fakefile when data/build/ does not exist.
- FSS Status Code: Incorrectly string length causes inability to match string in fss_status_code.
- UTF8: The mode clang is missing from the UTF8 stand alone build settings.

Refactors:
- None.

Updates:
- FLL: The disable header files.
- FLL: Use more proper copyright communication.
- FLL: Restructure settings now the install.sh is installing them.
- FLL: Improve logic and design of install.sh script.
- FLL: Add explicit note about copyrights belonging to Kevin Day and the year 2023.
- FLL: De-couple the build settings data file from the install.sh script.
- FLL: Be more thorough in the f_file unit test.
- FLL: Code documentation is missing the function fl_conversion_dynamic_partial_to_unsigned_detect().
- FLL: Fix license in documentation.
- FLL: Clarify wording in specifications.
- FSS Status Code: Add stand alone fss_status_code build.
- FSS Status Code: Add man page documentation for fss_status_code.
- FSS Status Code: should have a fakefile.
- IKI Read: Add man page documentation for iki_read.
- IKI Read: Improve IKI Read help documentation.
- IKI Write: Add man page documentation for iki_write.
- IKI Write: Improve IKI Write help documentation.
- Status Code: Add stand alone status_code build.
- Status Code: Add man page documentation for status_code.
- UTF8: Add man pages for utf8 program.
- Multiple Programs: The stand alone programs configuration.
- Multiple Programs: Documentation and build settings, adding remaining man pages for programs.
- Multiple Programs: Minor fixes regarding structure and output relating to help.
- Multiple Programs: Add more detailed documentation to fss_status_code and status_code.

The Featureless Linux Library stable version 0.6.2 is released.

This release contains several security and bug fixes.
There are also several improvements to the building and packaging scripts.

Added the following stand alone programs:
- byte_dump
- firewall

The bootstrap.sh and package.sh scripts have received some needed improvements.
The bootstrap.sh script now processes more of the build settings and then also more appropriately processes the additional modes.
The bootstrap.sh now more properly processes the -s/--settings parameter option.
The package.sh script is now more versatile, allowing for additional dependencies files and optionally prepending a string to each generated package directory.

Adding the referenced stand alone programs revealed quite a bit of minor mistakes in the macros, defines, and some dependencies.
Many of these might be considered breaking API changes but fixing these is deemed necessary.

The flagship program is Featureless Make.
All projects and programs now have a fakefile for building as they should have had.

Problems with the Unicode handling have been identified and fixed.
The FLL and implementing programs like byte_dump and utf8 should now have more accurate handling of Unicode characters.

The project now contains a generated list of all disable defines for each project under the build/disable directory.
Use these to construct all the needed disable defines to reduce the amount of unneeded code.
These are now used when building the stand alone programs.

The documents and specifications have seen some major clean up.
All of the documents and specifications should now utilize IKI.
The Time and EpochTime standard written a while back now have formal documents and specifications.
The Time and EpochTime documents and specifications are now at the top-level directory of the source code.

Documentation explicitly describing the lossy allocation strategy used by this project is now provided.

The following are changes since the 0.6.1 stable release.

Security Fixes:
- FLL: Invalid access when calling fake without 'make' or 'build'.
- FLL: Invalid write in FSS functions and ensure a reset used length on error.

Features:
- FLL: Add support for additional dependencies and settings files in level_3 (in the package.sh script).
- FLL: Add support for a prepending a prefix to build directory names (in the package.sh script).
- Featureless Make: Add 'import' Object to fakefile and settings specifications (Support is not implemented in 0.6.x).

Bug Fixes:
- FLL: Incomplete UTF-8 zero-width detection, particularly for combining characters.
- FLL: Add missing f_type_array dependency.
- FLL: The level_0 console should use private functions.
- FLL: The fss_payload_write should not allow "payload" to be something other than last when specified.
- FLL: Incorrect ifndef defines for some functions and structures.
- FLL: Add missing ifdefs for f_file_stat() and f_file_stat_at().
- FLL: The private is_zero_width function is also needed by the is_graph functions.
- FLL: The f_environment_max_length should be f_environment_max_length_d.
- FLL: Some of the level checking defines have an "s" that should not be there.
- FLL: _di_string_ascii_s_ is missing the _f.
- FLL: The bootstrap script needs to treat -s/--settings as a possible path.
- FLL: The bootstrap script needs to support settings-specific built files.
- FLL: FSS write functions should use 'quote' when passed rather than f_fss_delimit_quote_single_s.
- FLL: _GNU_SOURCE should be wrapped in an ifndef.
- FLL: The "-mode" functionality is incomplete and incorrect in the bootstrap.sh script.
- Byte Dump: Incorrect spacing when combining --unicode with other digit displays.
- Byte Dump: Invalid print of character when a placeholder should be printed in byte_dump.
- Featureless Make: The IKI variables that expand reserved words should expand into multiple parameters.
- Firewall: Add missing dependencies and remove incorrect library from firewall program.
- FSS Payload Write: The first character never gets printed for payload Content.
- Multiple Programs: The type_array is probably a dependency for most of these.
- Multiple Programs: Imprecise desciption for --partial.

Refactors:
- None.

Updates:
- FLL: All projects should have fakefiles.
- FLL: Fix and improve FSS unit test regarding zero-width.
- FLL: FSS and IKI specifications now support backticks for quoting similar to single and double quotes (Support is not implemented in 0.6.x).
- FLL: Add pre-built define files for stand alone use.
- FLL: Wrap the conversion digits defines in _di_f_conversion_digits_d_.
- FLL: The ifndef wrappers should end in _t_ to represent it wrapping a type.
- FLL: The fake stand alone build defines.
- FLL: The disable defines files need to be updated when defines change.
- FLL: Remove unused "test" mode and add "clang" mode to stand alone builds.
- FLL: Style guide documentation.
- FLL: The status code wrapping defines should end in _e.
- FLL: The _di_compiler_attributes_ should e _di_compiler_attributes_d_.
- FLL: The status code wrapping global constant string wrapping defines should end in _s.
- FLL: The define _di_f_array_t_ should be _di_f_array_length_t_.
- FLL: Add mising _d in wrapping defines.
- FLL: Add more notes to 'disable' about.txt documentation.
- FLL: Add not implemented clarifications for 0.6.x versions.
- FLL: Add fakefile for the FLL monolithic and level builds.
- FLL: Out of date build documentation.
- FLL: Add lossy allocation documentation.
- FLL: Build and other documentation, fixing or adding IKI support.
- FLL: Add formal specification for Time and EpochTime and use IKI in the files.
- FLL: Documentation and specifications (All of the documentation and specifications should now be IKI based).
- Featureless Make: The stand alone fake config.h file.
- Featureless Make: Improve some of the Featureless Make documentation and specifications.
- Featureless Make: Slight changes to design around the build settings arguments.
- Firewall: Add stand alone firewall build.

The Featureless Linux Library stable version 0.6.1 is released.

This is the first micro release of the Featureless Linux Library.

Most of the fixes and improvements are centered around the build and test systems.
This release should be more portable and testable.

The BASH alternative ZSH is now supported for the following scripts:
- bootstrap-example.sh
- bootstrap.sh
- package.sh
- install.sh
- test.sh

In order to run these scripts under ZSH, one must defined the SHELL_ENGINE environment variable with the value "zsh".
Compatibility of ZSH is not well tested and there may be bugs.

Changes in the iki_read program involving the "--substitute" and the "--wrap" parameters.
The "--substitute" should support "--wrap" and the lack of this is being considered a bug.
The idea of having a "--substitute" that ignores "--wrap" is preserved using the new parameter "--reassign".

The Featureless Linux Library is a library that is intended to be used like nuts and bolts.
Given the license and the code, just take apart anything as desired.
To prove this out a new package build mode called "stand_alone" is available.
What this does is build with the minimal dependencies.
There is no reason to use code that is not being used.
This "stand_alone" makes it easier to get smaller binaries with fewer dependencies.
Only the following programs have "stand_alone" functionality defined (see files under "build/stand_alone/").
- fake
- utf8

Unicode 15.0.0 is now supported.
Much of the previous work randomly switch from 12.1 into 14.0.
There is a strong probability of missing functionality and mistakes so be advised.

The following are changes since the 0.6.0 stable release.

Security Fixes:
- None.

Features:
- FLL: Add support for 'stand_alone' builds in the package script.
- FLL: Add support for ZSH in addition to BASH.
- IKI Read: The iki_read should still support the older "--substitute" behavior.

Bug Fixes:
- FLL: Mistakes in disable macros and remove redundant check.
- FLL: Functions private_f_file_flush() and private_f_print_safely_get() are not being included when needed.
- FLL: The fll_program_standard_signal_received() needs a private implementation.
- FLL: private_f_memory_structure_resize() is not returning the error status codes.
- Featureless Make: Content is incorrectly attempted to be processed even though it does not exist.
- Featureless Make: Featureless Make dependencies are not accurately communicated.
- IKI Read: The iki_read should apply the "--wrap" when using "--substitute".
- FSS Read Programs: Two 0's are printed when "--total" is used and there are no matching Objects.

Refactors:
- None.

Updates:
- FLL: Enable gitlab test support.
- FLL: Always ensure content size is 0 when content is not found.
- FLL: Change logic to avoid potential negative numbers.
- FLL: Use resize functions rather than adjust functions for append and append_all functions.
- FLL: Add medium logos.
- FLL: f_memory_structure_increase_by() shouldn't do anything if amount is 0.
- FLL: Cygwin documentation.
- FLL: Support Unicode 15.0.
- FLL: Slight improvement in UTF unassigned detection and add or correct some ranges.
- Featureless Make: Redesign behavior of pipe, allowing it to run properly inside software like Gitlabs CI or Githubs CI.
- Featureless Make: Implement stand alone build for Featureless Make.
- Featureless Make: Describe modes being used when performing build or make.
- Featureless Make: Stand alone Featureless Make custom config.h header.
- Utf8: The utf8 program should be using the stream read functions.
- Utf8: Implement stand alone build for UTF8 program.

The Featureless Linux Library stable version 0.6.0 is released.

Several new programs are introduced since the 0.4.0 stable release series:
  - control
  - controller
  - fss_embedded_list_read
  - fss_embedded_list_write
  - fss_extended_list_write
  - fss_identify
  - fss_payload_read
  - fss_payload_write
  - iki_write
  - utf8

Most notable of these programs are the controller program and the utf8 program.

The controller program is a re-interpretation of the Featureless Make program written in a more generalized fashion that is focused on performing a set of tasks. This is very similar to a system initialize program such as sysvinit. Support for running as a system initialize replacement is partially complete. There is currently no way to send messages to the controller program to start and stop anything. The control program, which is used to communicate to the controller program is also incomplete. The next FLL development verrsion, the 0.7.0 series, will heavily focused on network protocols.

The utf8 program is a handy tool to convert from UTF-8 characters to their Unicode value or vice-versa. This can convert entire files.

Featureless Make has some major changes. The fake program now accepts piped data, which must be a valid fakefile. There are new Objects available for the build settings and the fakefile.

The default behavior of Featureless Make is now more similar to the GNU make program. When running fake with no parameters, it will first search for a fakefile in the current directory before checking for one at data/build/fakefile. This is analogous to how running make with no parameters will search for a Makefile in the current directory.

One major change is the complete rewrite of the printing functionality. The new design is heavily focused around formatted printing, similar to the printf() family of functions. Unlike the standard printf() family of functions, the new formatted printing understands the FLL special structures such as dynamic strings. The new formatted printing is UTF-8 aware and can handle printing raw strings, printing safe strings, and printing NULL characters. A safe string is a string where control codes or invalid Unicode sequences are replaced with place holders.

That standard console options have changed. All output changing parameters have had their short parameter argument made upper case. For example, +q is now +Q.

A new +E/++error parameter is introduced. This new parameter acts almost identical to +Q/++Quiet. The difference is that error messages are still printed.

The documentation may be found with the source code. Much of this website has been updated to also provide most of this documentation as well. The API is currently only available in the source code via the header files.

A major improvement of this release is safer and more stable code. This is thanks to a massive amount of time and effort spent into writing unit tests. The unit tests process is performed using the Featureless Make program. In addition to the unit tests, the static analyzer from GCC has been used to better identify and resolve problems.

The following are changes since the 0.5.10 development release.

Security Fixes:
  - FLL: Environment value has invalid read in f_environment_set().
  - FLL: Invalid read for formatted printing using partial ranges on a string.
  - FLL: Invalid reads on NULL terminated strings with a max width greater than 1.
  - FLL: Add support for +E/++error and change '+q' to '+Q'.
  - Featureless Make: Invalid read when using -s/--settings.
  - Featureless Make: Invalid read when processing not condition minimum value.
  - Featureless Make: Invalid read when processing an empty fakefile.

Features:
  - FLL: Add missing function f_environment_get_all().
  - FLL: Add missing signal functions f_signal_action(), f_signal_pause(), and f_signal_suspend().
  - Controller: Expose the "define" and "parameter" at the Entry and Exit level.
  - Featureless Make: Now supports a piped fakefile.
  - Featureless Make: Now supports the "write" operation.
  - Featureless Make: Now supports to the "print" operation for escape sequences just like the "write" operation has.
  - Featureless Make: Now supports the "top" parameter.
  - Featureless Make: Now supports the "current" parameter.
  - Featureless Make: Improve user experience by defaulting specified fakefile and build settings file to present working directory.

Bug Fixes:
  - FLL: IKI variables are incorrectly being processed when there is a non-IKI IKI-like string.
  - FLL: Single quotes are not being properly detected in FSS Extended Read functions.
  - FLL: private_f_file_open_at() has an incomplete set if ifdef conditions.
  - Byte Dump: Parameter after either the -N or -W is being processed when it should not be.
  - Controller: Incorrect information is printed on certain errors.
  - Controller: Delimits are not being applied for IKI variables.
  - Controller: "State is now ..." should not be printed when quiet is passed.
  - Controller: Guarantee that the child processes are terminated.
  - Controller: IKI substitution is incorrectly applied.
  - Featureless Make: Condition blocks are still being processed when they should be skipped.
  - Featureless Make: Empty strings improperly pass validation checks.
  - Featureless Make: IKI variable substitution results in incorrect parameter structure.
  - Featureless Make: Error verbosity is not being preserved.
  - Featureless Make: Text is being incorrectly stripped out.
  - Featureless Make: The copy operation doesn't work properly with trailing slashes.
  - Featureless Make: Copy should destination should be the base name rather than the entire path.
  - Featureless Make: Link operation is incorrect, support new link arguments, and clone, copy, and move operations failure problems.
  - Featureless Make: Block is incorrectly being reset when an else condition precedes an if condition.

Refactors:
  - Controller: Use "settings" instead of "setting" for better consistency between fake program and controller program.
  - Featureless Make: Rename "script" to "engine" to avoid possible confusion with the different uses of "script".
  - Featureless Make: "if defined parameter" and similar are simplified into something more like "if define" and "if parameter".
  - Featureless Make: Rename "exists" to "exist".

Updates:
  - FLL: Change execute error code handling to better accommodate standard GNU Bash return codes.
  - FLL: Further reduce memory allocation pressure by increasing default small allocation.
  - FLL: Restrict environment to PATH and LD_LIBRARY_PATH by default in all FLL build settings files.
  - FLL: The standard program setup should explicitly unblock all signals other than the default
  - FLL: Clarify IKI standard in regards to delimits and improve specification file.
  - FLL: Improve specification files.
  - FLL: The f_color needs to follow latest practices with private functions.
  - Controller: Change default controller settings path to './'.
  - Controller: Strip out NULL characters after applying delimits.
  - Controller: Timeout changes.
  - Featureless Make: Make environment variable handling design consistent between fake and controller programs.
  - Featureless Make: Ensure first if block is initialized to operate.
  - Featureless Make: Replace Unicode Terminate escape sequence with Non-printing escape sequence.
  - Featureless Make: Reduce number of allocations by pre-determining size when easily possible.
  - Featureless Make: Organize the validate operation into separate type functions and improve error handling logic.
  - Featureless Make: The example bzip2 now supports running the tests.

This is a Release Candidate for 0.6.x.

The primary focus of the 0.5.10 release is for releasing the 0.6.0 stable release.

Unit tests for all level_0 projects now exists (except for f_type which is not planned to ever have unit tests).

Many problems and consistency issue have been identified by the written unit tests and fixed.
The unit tests, however, are neither complete nor thorough.
There are almost no unit tests for level_1, level_2, or level_3 projects.

I noticed that the Unicode processing code is incomplete as of the 0.5.9 release.
The available Unicode processing functions are now complete.
A massive amount of unit tests now exist for testing the Unicode.

There are now over 3000 unit tests for all code in this repository.

Security Fixes:
- FLL: Floating point exception due to incorrect number type used in conversion function.
- FLL: The realpath() calls malloc() and free() is not called (memory leak).
- FLL: Incorrect pointers result in incomplete memory deallocation in f_directory.
- Fake: Add missing NULL at the end of string.
- Fake: Add missing parameter checks and rename "data" to "custom".
- Fake: Wrong variable passed resulting in invalid read and writes in Fake.

Regression Fixes:
- Controller: Remove invalid validation block.

Features:
- FLL: Provide simple script for assisting in the mass generation of Unicode handling code.
- FLL: Provide rebuild option in package script.
- IKI Read: The iki_read program should support wrapping a variable value.
- IKI Read: The iki_read program should support a more generalized substitution process called "replace".
- UTF8: Add missing functionality allowing the utf8 program to convert back to binary data with invalid codepoints.

Bug Fixes:
- FLL: Signal code is not being set when accepted signal is received.
- FLL: Problems and clean ups exposed when writing f_thread unit tests.
- FLL: The < 0xc2 test is supposed to be against the first byte rather than the second.
- FLL: A typo resulting in treating < 0xc3 as invalid UTF-8 when it is instead < 0xc2.
- FLL: Add missing endianness check to f_convesion.
- FLL: Uppercase 'T' needs to be supported (fl_conversion).
- FLL: Problems exposed by unit tests in f_utf.
- FLL: Incorrect 4-width characters are generated.
- FLL: Problems exposed by unit tests for f_signal.
- FLL: Problems exposed by unit tests in f_file.
- FLL: Problems exposed by unit tests in f_conversion.
- FLL: When any of -c, -p, or -s is the last parameter in test.sh no error is thrown.
- FLL: Package building test failures do not properly fail.
- FLL: Fix problems exposed by unit tests in f_status.
- FLL: Incorrect variable used results in F_parameter error.
- FLL: The print functions are not printing the last letter in certain cases.
- FLL: Trimmed printing is not working as expected.
- FLL: Fix problems exposed by unit tests in f_print.
- FLL: The quotes are always being defined even when there are no quotes in the FSS read functions.
- FLL: Problems exposed by unit tests (f_socket).
- FLL: Remove extra zero from hex-digit (f_utf).
- FLL: Fix problems exposed by unit tests (fll_status_string).
- FLL: Problems exposed by unit tests and do some relevant code style clean up (f_execute).
- FLL: Add missing return value handling in f_fss.
- FLL: Incorrect and missing initializer macros in f_fss.
- FLL: The FSS object write functions don't handle all newlines.
- FLL: Fixes to f_path of problems exposed by unit tests.
- FLL: Invalid read in f_file_stream_read_until().
- FLL: NULL is a valid character, causing utf8 not to properly print NULL characters.
- FLL: The FILE type may not have a known storage size and use F_type_output_d.
- FLL: Problems in f_file functions exposed by unit tests.
- FLL: Problems in f_file regarding file mode exposed by unit tests.
- FLL: The f_file_is_at() function is not properly comparing the file type.
- FLL: Three-width UTF-8 characters are improperly being detected as unassigned.
- FLL: Unicode characters are not printing correctly.
- FLL: Fix problems exposed by f_file project tests.
- FLL: Memory handling related to or exposed by f_directory unit tests.
- FLL: Invalid memory deletion.
- FLL: For f_file, use off_t, pre-test for EOF or error, use sizeof(f_char_t), and use size_t rather than ssize_t.
- FLL: The f_capability should accept f_string_constant_t rather than f_string_static_t.
- Byte Dump: The byte_dump --first and --last are not always working as expected.
- Byte Dump: Trailing Unicode sequences that get cut off before the encoding is completed improperly display.
- Controller: Entry file not found when --settings is used.
- Controller: Incorrect rule name for controller boot settings file.
- Controller: When compiled as "init" the controller program does not use the correct paths.
- Fake: IKI variable substitution in fake doesn't always expand properly.
- Fake: Use '%Q' rather than '%S' when printing error.prefix and add missing error.prefix.
- Fake: Environment variables in fake are not being expanded.
- Fake: The fake program should not require the data directory when explicit fakefile or settings files are specified.
- Fake: Defaults should not be applied when an empty Object is specified.
- FSS Identify: The fss_identify needs the latest version of f_utf_is_digit().
- UTF8: Last character of file after conversion from code point is not printed by utf8 program.
- UTF8: Combining and Width detection for utf8 are not properly printing.

Updates:
- FLL: Improve design in f_conversion to be safer when handling variables allowed to be replaced.
- FLL: Example bootstrap script now supports building all programs.
- FLL: White space function changes.
- FLL: Use "decimal" instead of "digit" (f_conversion).
- FLL: The f_utf project regarding digits and perform other clean ups.
- FLL: Use a regular int instead of uint8_t for counting digit in conversion function.
- FLL: Add script for generating Unicode Codepoints from integers.
- FLL: Generate Unicode script to support generating test data.
- FLL: Finish adding Unicode symbol handling code.
- FLL: Rename f_thread_signal() to f_thread_signal_write().
- FLL: Implement Math Symbol Category.
- FLL: Handle more cases of combining characters following white space.
- FLL: Add Unicode Symbols for currency and modifiers and minor comment clean ups.
- FLL: The f_utf punctuation codes.
- FLL: Tweak endiannes for f_utf_char_t.
- FLL: Use F_utf_not instead of F_utf and other resulting changes.
- FLL: Rewrite the f_serialize functions.
- FLL: The f_limit project is out of date.
- FLL: Add missing state.flag assignment in f_state_t_clear macro and fix syntax practice in initializer.
- FLL: Add missing function f_path_is_absolute() and fix existing f_path_is_*() functions.
- FLL: Utilize the state.flag to allow for fss read to not fail out on invalid UTF-8 code sequence and fix naming problems.
- FLL: Utilize the state.flag to allow for iki read to not fail out on invalid UTF-8 code sequence.
- FLL: The f_utf_is_* functions should be more specific on return state for F_failure.
- FLL: Add pictures of the Kohlrabi that I have decided to use to represent the FLL project.
- FLL: Remove unused code, cast (char) to (unsigned int) for array indexes, and fix bitwise problem.
- FLL: Add licenses to text files and clarify OSL text.
- FLL: Redesign f_file functions to not need struct stat passed and other improvements.
- FLL: Improve the logic for the read link f_file functions.
- FLL: Add missing checks to f_file_link_hard_at() and use F_file_descriptor.
- FLL: Implement file statistics flag enumeration, dereferencing/no-dereferencing, and also use F_stream_not.
- FLL: Simplify build settings files.
- All FSS Read Programs: Improve read program logic to allow for catching interrupts during file read.
- Controller: Add note about ulimit privileges potentially causes failure of example controller rules.
- Fake: Add additional checks just in case execution is attempted with both program name and arguments have no data.
- Fake: The featureless make should default to 'make' mode.
- Fake: The fake program should check file existence when clean is combined with another command like build or make.
- Fake: The fake "build" fakefile Object needs to support modes and fix a related bug.
- Fake: Use off_t instead of f_array_length_t to match uses in functions like f_file_size().
- Fake: The fake program should show the fakefile or setting being used when building.
- Fake: The example project build settings and fakefiles.
- IKI Write: Have iki_write use form-feed rather than end of line character for pipe input.
- FSS Embedded List Read: Remove extra error print in fss_embedded_list_read.

This is a Release Candidate for 0.6.x.

The primary focus of the 0.5.9 release is for releasing the 0.6.0 stable release.

Most of the project is at an acceptable state for a stable release.

Two of the programs:
1) Controller
2) Control

Did not quite make the cut.
The socket communication and related function is either removed or unimplemented.
The controller program is still function, it just doesn't accept socket communication.
It should operate as a controller rather well but not quite as well as an init program.

This now formally provides a draft of the open-standard-license-1.0 intended to be used for the standards and specifications defined within this repository.
This license is a work in progress and will be periodically updated until 1.0 is reached.

Security Fixes:
- Incorrect array size used in test (identified by CLang).
- Controller program is not initializing the alert mutex lock.
- Invalid write in FSS processing functions due to improper allocation size.

Regression Fixes:
- Some IKI vocabularies are missing their first character.
- UTF8 program is throwing error when trying to read files.
- Use correct function for mutex lock in Controller program.
- Invalid syntax in fake program.
- Accidentally reversed the big vs little endian bits.
- Invalid code added to controller.

Bug Fixes:
- Debug verbosity should include Verbose verbosity messages.
- Random quote that shouldn't be there is breaking tests.
- Incorrect code used in UTF8 character code for U+12C1
- Typo in variable name, should be f_print_sequence_enquiry_s.
- Incorrect variable type used for capability flag.
- Bootstrap script is not handling some build settings, such as 'define'.
- Invalid content count in FSS Basic List.
- When using --at with --total for --content, the returned number is always 1 and should not be.
- Invalid '%lu', in formatted print, should instead be '%ul'.
- Invalid F_parameter error in f_socket functions.
- Increasing strings by too much.
- Print functions are not always printing the entire string.
- The f_socket_connect() needs to handle EINVAL errno.
- Incorrectly performing nulless string appends and prepends.
- Partial string functions are incorrect.
- The out of range is printing and then continues processing.
- The byte_dump program should respect the +q/++quiet.
- Incorrectly checking byte width when already inside a character.
- UTF-8 endianess tests fail and improve seek to functions for UTF-8.

Notable Updates:
- Relax the uid/gid requirements in f_file_role_change* functions.
- Add local and remote status codes.
- Socket parameters, rename f_socket_bind_file() to f_socket_bind_local(), and return F_local_not when UNIX socket is required.
- Add test mode and provide -fstack-protector flag.
- Add missing dependency to f_type_array for f_iki project.
- Fix consistency where initialize macros are not available for every typedef.
- Stop using GNU old-style field designator extension.
- (Formally) Provide open-standard-license-1.0.
- Consistency improvements with *_append() and *_append_all().
- Add CLang support to the bootstrap-example.sh script.
- Add F_status status type and rename F_status_size_max_with_signal to F_status_size_max_with_bits_d.
- Provide Packet specification.
- Restructure parts of f_utf project, and use f_utf_t, and add 'u' to hexdigits in common.h.
- Bring f_utf project in sync with f_string.
- Update fll_program_data_t and restructure programs to use fll_program_data_t.
- Use const for f_console_arguments_t and add envp.
- Ensure all programs are handling signals, adding signal_received to fll_program_data_t.
- Remove inefficient and pointless size increase.
- Add F_once, F_receive, F_repeat, and F_send status codes.

This is a Development Release for 0.6.x.

The primary focus of the 0.5.8 release is fixing problems and wrapping up the API in preparation for the 0.6.0 stable release.

There are an enourmous amount of API breaking changes.

More in depth code analysis' have been performed and many bugs are fixed, many security problems are solved, and many missing features are added.

Due to the size of the changes and the upcoming stable release, this release is being released as is with additional breaking changes planned following the next release.

Now has an initial implementation of the Control program.
The Control program and the relevant parts in the Controller program are not complete.
This will be addressed in the next development release priot to any stable release.

As part of implementing the Control program, a new FSS specification has been created.
This new specification, FSS-000E, is called "Payload".
The purpose of this is the transport of data over a network, such as a Socket.
This structure allows for binary data embedded along with string-based header data.

This brings in unit tests for a small number of projects.

Fixes a file stream read inefficiency resulting in using ~50% less memory used.

Many build systems build object files separately before the final compilation.
The Featureless Make build mode now better handles these cases by supporting building objects only.
The "example-objects" example provides an example of this new functionality.
The bootstrap.sh script is updated to accomodate all of the Featureless Make changes.
The Featureless make build Objects added are:
- build_objects_library
- build_objects_library_shared
- build_objects_library_static
- build_objects_program
- build_objects_program_shared
- build_objects_program_static
- build_sources_object
- build_sources_object_shared
- build_sources_object_static
- path_object_script script
- path_object_shared shared
- path_object_static static
- path_sources_object
- defines_object
- defines_object_shared
- defines_object_static
- flags_object -fPIC
- flags_object_shared
- flags_object_static

The Featureless Make build settings now allows for almost all of its Objects to be expanded by a mode.
Specifying multiple modes at the same time are tested and confirmed to work.
The "project_name" has been refactored to "build_name" to allow for more consistent terminology in the build settings files.
The "path_headers_preserve" has been refactored to "preserve_path_headers" to allow for more consistent terminology in the build settings files.
The "path_standard" has been refactored to "has_path_standard" to avoid confusing with the Objects that represent actual paths.

There are major structural changes to the project, in some cases breaking up files into multiple files and sub-directories.

Many of the functions now are not only pointers to constants, now they themselves are constants (such as "const f_string_t * const dynamic").

Most of the strings data now guarantees NULL termination after the "X.used" position to make compatibility with libc/POSIX NULL terminated strings easier.
This effectively increases security at the cost of a trivial amount of resources.

This brings in new functionality:
- Control: Initial, but incomplete, implementation.
- Controller: Implement IKI support in controller program.
- Controller: Initial, but incomplete, implementation of Control processing.
- Fake: Add support for "context" IKI in Fakefiles.
- Fake: Build settings now supports compiling only object files.
- Fake: Enable support for modes on (almost) all Fake build settings Objects.
- FLL: Add and implement fss-000e Payload specification.
- FLL: The level 3 programs fss_payload_read and fss_payload_write are now available.
- FLL: Maps and Multi-Maps should support appending a single map rather than just an entire set.
- FLL: Major rewrite of all string management to use f_string_static_t instead of f_string_t, almost everywhere.
- FLL: Console Parameter handling code now handles environment variables passed directly from main(), with new structures available for handling this.
- FLL: Did not fully verify sanity of the passed argc, argv, and now envp (0fda7956).
- FLL Identify: The fll_identify -n/--name now supports full name as well as type code.

Security Fixes:
- Controller: Executed program string is not NULL terminated (c2e3a78a).
- Fake: Invalid read due to wrong parameter in fl_print_format() (ad662162).
- Fake: Invalid read because NULL is added to list but then f_string_dynamic_append_nulless() is used (c6b16ea5).
- FLL: Invalid read in private_f_print() (3864be02).
- FLL: Invalid reads, always add NULL for compatibility (11ac81cc).
- FLL: The va_list has undefined behavior when passed into functions (f8463f12).
- FLL: Invalid va_arg() call resulting in overflow (9706a6d3).
- UTF8: Invalid read when using -bB (5bc794b5).

Fixes and Improvements:
- Byte Dump: Return explicit error code when needing to.
- Controller: Delete socket rather than resize when array is over large.
- Fake: Fakefile inner Objects should load the last Object from settings Section.
- Fake: Do not validate directory existence when cleaning.
- Fake: The build setting path_sources is not being properly used and improve skeleton process.
- Fake: Refactor path_standard to has_path_standard.
- Fake: The path_headers_preserve isn't properly being processed and refactor it to preserve_path_headers.
- Fake: A fakefile should not load the build settings by default.
- Fake: IKI variables are not substituting consistently.
- Fake: Provide more details in the documentation on if/else logic.
- Fake: Partially fix "if is regular for xxx" exposes bug in error handling of and/or.
- Fake: Regression where the "failure" operation if condition type is not working as intended.
- Fake: If/else condition logic is incorrect or incomplete.
- Fake: The "if not defined" is not working as expected.
- Fake: Incorrect string is being printed on error message.
- Fake: Comparison should instead be an assignment.
- FLL: Help ensure va_copy() is defined.
- FLL: Improper IKI vocabulary position for when a quote is immediately to the left of the vocabulary name.
- FLL: Return F_data_not when amount or size is 0 in memory allocation functions and add missing F_string_tripless_t.
- FLL: IKI now accepts a structure f_iki_data_t, reducing the number of parameters passed.
- FLL: Change "one", "two", and "three" into "a", "b", and "c" for f_triple_t.
- FLL: Add clang build mode to the build settings files.
- FLL: Add debugging.txt documentation.
- FLL: Remove todo.txt documentation.
- FLL: Use F_directory_not instead of F_directory for non-existent directories.
- FLL: Improve f_file_name_directory() and f_file_name_base().
- FLL: Remove "_type" from f_type_array functions.
- FLL: Refactor project_name t build_name to match new Featureless Make build settings Object name.
- FLL: Remove fl_console from example bootstrap script.
- FLL: Refactor fl_console_parameter_to_string_dynamic_directory() to f_path_directory_cleanup().
- FLL: Fix bug where the prepend option is being incorrectly applied.
- FLL: File stream read inefficiency, allocation f_string_t instead of char, and actually use state.step_small.
- FLL: Use raw printing whenever safely possible and add missing raw safe print.
- FLL: Incorrect return result for fwrite_unlocked().
- FLL: Use libc functions more in f_color.
- FLL: Console parameter macro, console structure organization, and add initializer for some integer types.
- FLL: Use F_number_t_size_positive_d for F_string_t_size_d and update #ifdef structural logic.
- FLL: Lay out the foundation for proper endianness support.
- FLL: Implement more of UTF-8, finish "is unassigned", add "is surrogate" UTF-8 support, and update "is private use".
- FLL: Update testfiles should detect LD_LIBRARY_PATH.
- FLL: Update documentation and add "context" to IKI-0002.
- FLL: Add F_domain, F_family, F_protocol, and F_property statuses.
- FLL: Improvements to f_path and related.
- FLL: Improvements to file processing code.
- FLL: Additional status codes added.
- FLL: Add socket functions and improve existing ones.
- FLL: Incorrect file mode is being set.
- FLL: Fix bug in socket disconnect.
- FLL: Fix bug where valid comment lines are keeping leading white space.
- FLL: Fix bugs exposed by unit testing.
- FLL: Add additional unit tests.
- FLL: Add missing f_account_name_group_by_id(), cleanup comments, and update macro usage.
- FLL: Make sure constant pointers that are intended to be read-only are just that.
- FLL: Fix bug where an improper if condition range check is performed in the print functions.
- FLL: The private_fl_print_convert_number() is not properly handling number conversion with asterisks in some circumstances.

Remaining planned changes for preparing 0.5.x branch for 0.6.x:
- Finish writing UTF-8 support for existing functionality.
- Finish the "controller" program.
- Finish the "control" program.
- Review and fix some inconsistencies in the design that would influence the API.
- Update documentation.

This is a Development Release for 0.6.x.

The primary focus of the 0.5.7 release is completing existing incomplete projects.

This release contains an enormous amount of UTF-8 compatibility improvements.
A lot of incomplete code is now completed.
Not everything is complete, such as the unassigned block range for 3-byte wide characters (these are marked with todo comments).
A new program, called "utf8", is provided to help assist in converting to and from UTF-8 codepoints and the binary character.
This program should be capable of generating complete binaries but is not very well tested as of yet.

A lot of problems have been identified and solved, including security issues.
The goal of completing the controller and control programs is pushed off to the next release cycle as a result.

A major addition is the support for cmocka and writing tests.
Tests will be slowly added until there is reasonably full coverage of the project and all of its programs.
This will take time but will greatly assist in identifying problems and regressions down the road.
The cmocka unit test process is still not fully hashed out and many changes in the future are expected as a result.

This brings in new functionality:
- A small number of cmocka tests as well, utilized via a fakefile named "testfile".
- The utf8 program now exists and is available.
- New UTF-8 processing functions.
- Support the C11 aligned_alloc() but still provide an optional fallback to posix_memalign().
- The fake program now supports "not" with if-conditions as well as "and" and "or" if-conditions.

Security Fixes:
- Fix memory leak in fake program (e126c92439fd54005b043e89ca022a3a9e2bfd97).
- Segfault when "load_build yes" and "build settings" of fake program (634e4402b887d5abc8b6928909dafbf1dab4c42a).
- Buffer overflow in f_file (647417282a9c2cd0f06b9e571cb3410f49ba25a0).
- Invalid memory access in interrupt handlers of fake program (9e72630517b6dd27cfdf0e553592c713742a16f9).

The summary of fixes and improvements:
- All Programs: Performance is slow due to process signal checks.
- Byte Dump: Wrong characters being printed, switch to newer print functions.
- Controller: The controller_time_micro() is waiting too long.
- Controller: Functions like nanosleep() are not receiving interrupt signals and similar.
- Controller: Improve sleeping logic, also replacing sleep() with nanosleep().
- Controller: Use BLOCK after UNBLOCK rather than UNBLOCK again.
- Controller: Add two example entries for testing delay so that terminate signals may be tested.
- Controller: Script and Utility are no longer working when using "Extended" rather than "Extended List" format.
- Fake: Restructure fake settings, moving examples into a new projects directory.
- Fake: Individual build should be building with "version_file micro" and "version_target minor".
- Fake: Reset fakefile buffer and only call resize when necessary.
- Fake: Switch to simple string and cleanup syntax and comments.
- Fake: Ensure terminating NULLs, remove unnecessary arguments array, and cleanups.
- Fake: The "if defined parameter .." is not supporting reserved parameters.
- Fake: Relocate fake_main_t position in function arguments and make it a constant pointer.
- Fake: Move main data into the data make structure.
- FLL: Add "success" color context and initialize color "set" in programs.
- FLL: UTF-8 functions fail to properly handle ASCII.
- FLL: Fix print function bugs and add missing functions.
- FLL: Experimentally cast characters to uint8_t in UTF-8 processing code.
- FLL: NULL is being printed and fix inline function
- FLL: The color set context should also have the "reset".
- FLL: Signal related updates, consistency improvements, and miscellaneous code cleanups.
- FLL: Remove old color print functions.
- FLL: The print safely functions are now UTF-8 aware.
- FLL: Base 10 was used in hexdigit for comparison, resulting in invalid number conversion.
- FLL: Implement double support in print functions and add missing functionality.
- FLL: Improve UTF-8 Control detecting, expanding to distinguish Control Code and Control Format.
- FLL: Major UTF-8 changes and optimizations.
- FLL: f_utf_unicode_string_from() is not functioning correctly.
- FLL: Improve error handling and add F_utf_fragment to generic FLL error printing.
- FLL: Raw formatted print sometimes prints trailing NULL.
- FLL: Support printing errors for F_signal and F_interrupt statuses.
- FLL: f_utf_unicode_string_to() not treating numbers larger than 0x10FFFF as invalid.
- FLL: Cygwin documentation notes are slightly out of date.
- FLL: Use C11's aligned_alloc() by default, but keep posix_memalign() via macro _f_memory_USE_po
six_memalign_.
- FLL: Update: Improve performance by removing redundant memset().
- FLL: Handle more error messages for file types and cleanup organization a little.
- FLL: Add support for tests in the packager.
- FLL: Add cmocka tests for f_memory project.
- FLL: Don't bother checking, just always update pointer (in the memory allocator functions).
- FLL: IKI improvements, cleanups, and bugfixes.
- FLL: Incorrect return values in some print functions.
- FLL: The character 'o' is not properly detected as a mode.
- FLL: Signal id should be -1 the id should be passed to signalfd().
- FLL: Add tests for f_type_array.
- FLL: Numerous code cleanups and documentation improvements.

Remaining planned changes for preparing 0.5.x branch for 0.6.x:
- Finish writing UTF-8 support for existing functionality.
- Finish the "controller" program, which is another part of the non-systemd init design.
- Write the "control" program, which is intended to interact with the "controller" program.
- Review FSS and IKI standards for consistency in both specification and implementation.
- Bring "firewall" up to date.
- Cleanup existing code, getting the style back in sync for a stable release.
- Review and fix some inconsistencies in the design that would influence the API.
- Update Featureless Make to fully handle creating parent paths.
- Update Featureless Make to support overriding settings using program parameters.
- Update documentation.

The status of programs (level_3):
- byte_dump: working.
- controller: in progress.
- fake: working.
- firewall: working, outdated.
- fss_basic_list_read: working.
- fss_basic_list_write: working.
- fss_basic_read: working.
- fss_basic_write: working.
- fss_embedded_list_read: working.
- fss_embedded_list_write: working.
- fss_extended_list_read: working.
- fss_extended_list_write: working.
- fss_extended_read: working.
- fss_extended_write: working.
- fss_status_code: working.
- iki_read: working.
- iki_write: working.
- status_code: working.
- utf8: working, not well tested (brand new).

This is a Development Release for 0.6.x.

The primary focus of the 0.5.6 release is updates and bugfixes.

There are considerable improvements in the controller program that better enables it to operate as an init program.
The fake program has seen some improvements and bugfixes.
There are significant changes and improvements to the execute functions.
New status codes added, breaking previous ABI and API.

Of particular note are the execute changes.
The return status from a child process is not being returned and the forked process has no way of getting this value.
To solve this, the execute functions are re-written to enable returning special error codes on exit of the child process.
This value can then get picked up by the appropriate waitpid() call.
Only a 8-bits are available for this as per POSIX so a special subset of status codes exclusive to the execute process are now provided.

The formatted print functions still need additional work.

This brings in new functionality:
- Allow controller program to operate directly as "init program" by default.
- Controller Program should support uninterruptable and define default behavior.
- Enable config.h, config.c, and config.cpp support in package generation.
- Support "pid" and "show" entry settings in the controller program.
- Several new status codes (breaking API and ABI with 0.5.5 release and earlier).
- Implement timeout setting support in the controller program.
- Support "rerun" in controller program to re-run processes after exit or error, such as "agetty".
- The fake program now supports additional build settings:
  - libraries_shared
  - libraries_static
  - build_sources_headers_shared
  - build_sources_headers_static
  - build_sources_library_shared
  - build_sources_library_static
  - build_sources_program_shared
  - build_sources_program_static
  - flags_library_shared
  - flags_library_static
  - flags_program_shared
  - flags_program_static
  - defines_library_shared
  - defines_library_static
  - defines_program_shared
  - defines_program_static
- Add controlling terminal support to the execute functions to allow the controller program "init" to avoid messages like: "bash: cannot set terminal process group (-1): Not a tty" and "bash: no job control in this shell".
- The controller program now supports "session new", "session same", "with session_new", and "with session_same" to utilize the controlling terminal support.

The summary of fixes and improvements.
- Add missing parameter in firewall help and tweak spaces.
- Some projects should be using '%Q' and not '%S'.
- Fix problems exposed by testing the "init" program, including formatted print regressions.
- Controller program print locking issues and fix delimits cache issue.
- Incorrectly setting interrupt failure during exit.
- Improve pid file handling logic in the controller program, avoiding the need for the process_pid variable.
- Several formatted print regressions.
- Controller program environment should only be reset when specified, even if empty.
- Controller program infinite loop on invalid entry file and related printing problems.
- Make fl_execute_into() slightly more consistent with fl_execute_program(), adding environment processing.
- Formatted prints are pulling additional var_arg, resulting in a segfault.
- Conversion functions should not be considering the decimal '.' (0x2e) to be a number as the conversion functions are for whole numbers only.
- Fix number handling in the controller program.
- The rule for devices is "devices" and not "dev" in the controller program setting files.
- Execute functions and controller program changes, addressing return codes.
- Refactor fll_error_print_t to fl_print_t.
- Refactor old f_file_t output strategy to the newer fl_print_t output strategy.
- Refactor coding practices to utilize "_s" and "_d" in the macros (a major API change).
- Refactor the fake program setting "flags_all" to "flags" and "defines_all" to "defines".
- Move the fake program's hardcoded indexer arguments into a new setting "build_indexer_arguments".
- Fix regression where the example bzip fakefile build fails.
- Bootstrap build script should understand static and shared being built.
- Fix problem where "require" is not properly trigger an error in the controller program.
- The package script shouldn't be setting up the build settings to install config.h.

Remaining planned changes for preparing 0.5.x branch for 0.6.x:
- Finish writing UTF-8 support for existing functionality.
- Finish the "controller" program, which is another part of the non-systemd init design.
- Tweak "Controller" to have an "init" like behavior, but only for a custom program called "init", otherwise operate as a more generic controller.
- Write the "control" program, which is intended to interact with the "controller" program.
- Review FSS and IKI standards for consistency in both specification and implementation.
- Bring "firewall" up to date.
- Cleanup existing code, getting the style back in sync for a stable release.
- Review and fix some inconsistencies in the design that would influence the API.
- Update Featureless Make to fully handle creating parent paths.
- Update Featureless Make to support overriding settings using program parameters.
- Update documentation.

The status of programs (level_3):
- byte_dump: working.
- controller: in progress.
- fake: working.
- firewall: working, outdated.
- fss_basic_list_read: working.
- fss_basic_list_write: working.
- fss_basic_read: working.
- fss_basic_write: working.
- fss_embedded_list_read: working.
- fss_embedded_list_write: working.
- fss_extended_list_read: working.
- fss_extended_list_write: working.
- fss_extended_read: working.
- fss_extended_write: working.
- fss_status_code: working.
- iki_read: working.
- iki_write: working.
- status_code: working.

This is a Development Release for 0.6.x.

The primary focus of the 0.5.5 release is applying some security fixes.

There are a small number of bugfixes as well.

The primary security fix is that of printing control characters.
All previous releases are affected by this.
Any input data, such as file names, may contain control characters.
The print methods have previously not sanitized this on output and print those control characters.
This creates undefined behavior, of which I consider a security issue.

The solution is to write my own `printf()/fprintf()` alternatives.
See the `fl_print_format()` for the unlocked implementation and documentation.
See the `fll_print_format()` for the locked implementation of fl_print_format().

There are several new print functions and many of the color print functions have been removed or moved into the print projects.
In general, all `f_print_*()` or `fl_print_*()` functions asre unlocked and the `fll_print_*()` functions are locked.

The new formatted print functions are not entirely complete in that they do not have the printing support for float and double (I need to study some) and the number conversion is not as efficient as I would like it to be (again, I need to study some).

The summary of fixes and improvements.
- Installer script is attempting to install non-existent files.
- (Security) NULL dereferences discovered by GCC's -fanalyzer.
- Console parameter processing should handle unknown parameters with -/+ as regular parameters.
- (Security) Invalid allocation sizes due to incorrect types.
- iki_read never implemented --at.
- FSS Basic and Extended List Read -a -n -l parameter fails to work as expected.
- (Security) Static/Dynamic string compare functions aren't properly handling empty strings or empty ranges.
- Allow empty Objects in FSS Basic and Extended Lists.
- Add support for -R/--raw parameters in FSS read programs.
- Embedded List slash processing problems.
- Miscellaneous mistakes and cleanups.
- (Secuity) Redesign printing and and conversions, providing custom functions like `fll_print_format()`.

Remaining planned changes for preparing 0.5.x branch for 0.6.x:
- Finish writing UTF-8 support for existing functionality.
- Finish the "controller" program, which is another part of the non-systemd init design.
- Tweak "Controller" to have an "init" like behavior, but only for a custom program called "init", otherwise operate as a more generic controller.
- Write the "control" program, which is intended to interact with the "controller" program.
- Review FSS and IKI standards for consistency in both specification and implementation.
- Bring "firewall" up to date.
- Cleanup existing code, getting the style back in sync for a stable release.
- Review and fix some inconsistencies in the design that would influence the API.
- Update Featureless Make to fully handle creating parent paths.
- Update Featureless Make to support overriding settings using program parameters.
- Update documentation.

The status of programs (level_3):
- byte_dump: working.
- controller: in progress.
- fake: working.
- firewall: outdated.
- fss_basic_list_read: working.
- fss_basic_list_write: working.
- fss_basic_read: working.
- fss_basic_write: working.
- fss_embedded_list_read: working, buggy.
- fss_embedded_list_write: working, buggy.
- fss_extended_list_read: working.
- fss_extended_list_write: working.
- fss_extended_read: working.
- fss_extended_write: working.
- fss_status_code: working.
- iki_read: working.
- iki_write: working.
- status_code: working.