Tags

0.6.0

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.

0.5.10

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.

0.5.9

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.

0.5.8

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.

0.5.7

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).

0.5.6

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.

0.5.5

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.

0.5.4

Development Release for 0.6.x.

The primary focus of the 0.5.4 release is to address loose ends and wrap up the planned fixes and improvements.

I decided to commit this early and as such does not reach the objectives of wrapping up the current planned fixes and improvements.

This brings in new functionality:
- Newer FLL parameter processing via fll_program_parameter_process_empty().
- Redesigned FSS processing logic to better allow larger buffers.
- Utilize redesign FLL paramter processing to provide better interrupt and memory allocation related support.
- Add additional standard status codes, such as F_success and F_success_not.
- Add support for determining columns in FSS read programs.
- The install.sh should helper script should allow more granular installations.
- Support Unicode format "-U/--unicode" in byte_dump to display Unicode code values, such as U+1234.
- Allow controller program to run as a non-init (and then do so by default).
- Provide new functionality for identifying an FSS file (includes adding the program fss_identify).
- Redesign linkage functionality from Featureless Make and the bootstrap.sh adding nano version, version prefixes, version_target, and version_file properties.

Notable Fixes and Improvements:
- Fix regressions with recent signed and unsigned changes, reverting the behavior.
- Fix several bugs in the FSS read functions and their respective programs.
- Fix security concern where FSS Read functions should check range before buffer.
- Refactor use of 'data' to 'main' in programs to avoid potential naming conflicts.
- Refactor macro naming approach to have 'macro' as a prefix more consistently ('fake_main_macro_delete' becomes 'macro_fake_main_delete").
- Add some defines to the build settings to disable warnings in newer GCC and possibly Clang compilers.
- Fix invalid macro negations due to bad order of operations logic.
- Fix bug where some UTF-8 characters are not being fully printed.
- Improve portability.
- Fix problems with install.sh where "-w" is not being allowed to be used when destination_prefix is invalid.
- Fix regression where "fake skeleton" no longer works due to "file not found".
- The Featureless Make no longer needs to verify format of the -d/--define.
- Redesign Featureless Make's -d/--define to append instead of overwrite.

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.
- control: in progress.
- controller: in progress.
- fake: working.
- firewall: outdated and broken.
- fss_basic_list_read: working.
- fss_basic_list_write: working.
- fss_basic_read: working.
- fss_basic_write: working.
- fss_embedded_list_read: appears to be working, not well tested.
- fss_embedded_list_write: appears to be working, not well tested.
- fss_extended_list_read: working.
- fss_extended_list_write: working.
- fss_extended_read: working.
- fss_extended_write: working.
- fss_identify: working.
- fss_status_code: working.
- iki_read: working.
- iki_write: working.
- status_code: working.

0.5.3

Development Release for 0.6.x.

The primary focus of the 0.5.3 release is getting the Controller program and its dependencies working.

Significant portions of the Controller program is now complete and working.

That said, there are still things not yet completed in the Controller program with the most notable being:
- The control process and its related communication.
- Code needs structural cleanup.
- The start, stop, and kill timeout settings may or may not be going away (I need to consider the original plans vs the current design).
- Reload rules during runtime, which will require delicate handling.
- IKI support needs to be fully implemented.
- Variable based rule execution (so that a single rule may be used for multiple different processes, such as getty/1, getty/2, etc..).

This brings in a lot of fixes and improvements.
- Add custom time support and improvements including f_time structure.
- Significant improvements to the pthread support, fixing problems and adding missing functionality.
- Redesign project to install headers under 'fll' directory.
- Memory function improvements and fixes.
- Get UTF-8 string functions more in sync with normal string functions.
- Test compilation unde LLVM's Clang compiler, fixing problems exposed.
- Fix capability issues.
- Major improvements in the execute projects.
- Featureless Make and bootstrap script now properly creating parent directories for path_headers if parent paths do not exist.
- Add additional status codes.
- All projects now use legacy-only capability by default.
- Use 'char' instead of 'int8_t' and 'uint8_t' for character related codes except when dealing with Unicode byte sequences (in certain cases).

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: outdated.
- fss_basic_list_read: working.
- fss_basic_list_write: working.
- fss_basic_read: working.
- fss_basic_write: working.
- fss_embedded_list_read: broken.
- fss_embedded_list_write: broken.
- fss_extended_list_read: working, buggy.
- fss_extended_list_write: working. buggy.
- fss_extended_read: working.
- fss_extended_write: working.
- fss_status_code: working.
- iki_read: working.
- iki_write: working.
- init: removed.
- status_code: working.

0.5.2

Development Release for 0.6.x.

The primary focus of the 0.5.2 release is getting the Controller program and its dependencies working.

The Controller program has not been completed but I have decided to make an end of the year development release.

Of particular note, I realized that I accidentally wrote FSS Extended List Read and Write programs following FSS Embedded List format.
I separated the two but after some quick testing I found some bugs in the FSS Extended List Read program.
The FSS Embedded List Read and Write programs (and/or their dependent projects) did needs to be correctly implemented in regards to recursion (which appears to be badly broken).

Remaining planned changes for preparing 0.5.x branch for 0.6.x:
- Finish writing UTF-8 support for existing functionality.
- Write the "init" program, which is a non-systemd init design.
- Write 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 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: broken.
- fss_embedded_list_write: broken.
- fss_extended_list_read: working, buggy.
- fss_extended_list_write: working. buggy.
- fss_extended_read: working.
- fss_extended_write: working.
- fss_status_code: working.
- iki_read: working.
- iki_write: working.
- init: incomplete.
- status_code: working.

0.5.1

Release: 0.5.1

Development Release for 0.6.x.

The primary focus of the 0.5.0 release is getting the Featureless Settings Specifications working, especially the FSS Read and Write programs.

Remaining planned changes for preparing 0.5.x branch for 0.6.x:
- Finish writing UTF-8 support for existing functionality.
- Write the "init" program, which is a non-systemd init design.
- Write the "controller" program, which is another part of the non-systemd init design.
- 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.
- Update documentation.

The status of programs (level_3):
- byte_dump: working.
- controller: does not exist.
- fake: working.
- firewall: outdated.
- fss_basic_list_read: working.
- fss_basic_list_write: working.
- fss_basic_read: working.
- fss_basic_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.
- init: incomplete.
- status_code: working.

0.5.0

Release: 0.5.0

Development Release for 0.6.x.

The primary focus of the 0.5.0 release is getting the Featureless Make program to a reasonably functional status.

Remaining planned changes for preparing 0.5.x branch for 0.6.x:
- Finish writing UTF-8 support for existing functionality.
- Finish writing FSS functionality, namely the write functionality.
- Fix known problems or incompleteness with existing FSS code.
- Write the "init" program, which is a non-systemd init design.
- 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.
- Update documentation.

The status of programs (level_3):
- byte_dump: working.
- fake: working.
- firewall: outdated.
- fss_basic_list_read: needs work.
- fss_basic_list_write: incomplete.
- fss_basic_read: needs work.
- fss_basic_write: incomplete.
- fss_extended_list_read: needs work.
- fss_extended_list_write: incomplete.
- fss_extended_read: needs work.
- fss_extended_write: incomplete.
- fss_status_code: working.
- iki_read: working.
- init: incomplete.
- status_code: working.

0.4.3

0.4.2

0.4.1

0.4.0

0.3.0

0.3.x