Update: Revert back to 'char' rather than 'unsigned char'.

There are a lot more changes that I realized.
changing 'char' to 'unsigned char' will be for the next development release after the upcoming stable release.

Introduce the f_char_t type to allow for easier switching from 'char' to 'unsigned char'.

In all places that us 'unsigned char', just switch to 'char'.

Move the directory '..' and '.' into static strings.

Progress: Control and Controller sockets.

This also removes accidentally committed debug code (accidentally committed in a previous, unrelated, commit).

Update: Switch to explicitly using sizeof() for char memset() and memcpy().

Different architectures might not actually have a 1-byte size.
Rather than assuming the common behavior, always call sizeof(unsigned char) to determine size of memset() and mempcy() functions.

Update: Avoid the generic 'char' and switch to the explicit 'unsigned char'.

Operations against unsigned are generally safer than the signed equivalents.
Using the generic 'char' may be different between compilers and expecations cannot be guaranteed.
This could result in obscure security issues.

Changing this to 'unsigned char' guarantees consistent behavior.

There are problems with some standard libc functions that expect char.
Explicitly cast to 'char' in these cases.

Progress: Implement controller to/from control networking.

Continue implementing the contoller to control communication.

I thought I described the packet structures in addition to the payload structure.
It seems I have not.
This begins adding the packet structure documentation.

Update: These specific documentation files relate to the specification and needs to be licensed as such.

Update: Provide open-standard-license-1.0.

The Open Standard License is a more formal definition of my original intents and license behind my Standards and Specifications provided in this project.
This standard is still considered an Informal Draft because I have yet to perform legal review and as such it is considered incomplete.
This standard will be formalized pending legal advice and even the name is subject to change.

I thought that there might be confusion between the LGPL license in this project (which focuses on Source Code) and the Standards and Specifications provided within this project.
To make this difference explicitly clear, I am in the process of formalizing the license.

One big important part of this is this license focuses on Implementations of the Standard or Specification.
This is a substantially different concept to what is used in the LGPL and similar licenses.

Bugfix: Bootstrap script is not handling some build settings, such as 'define'.

Workaround: Clang compiler problems, add _clang_not_a_compile_time_constant_workaround_.

This should also be added to the level_0 and monolithic build settings files.

Update: Stop using GNU old-style field designator extension.

Apparently this is a GNU extension rather than a standard C language style.
Switch to the more correct style.

This issue is exposed by CLang and not GCC.

Security: Incorrect array size used in test.

The groups is testing an array of size 3 but it is only defines as size 2.
This test itself effectively has an invalid read (a stack overflow).

CLang properly identifies this problem but GCC does not.

Bugfix: Incorrect variable type used for capability flag.

CLang properly identifies this problem but GCC does not.

Workaround: Clang compiler problems, add _clang_not_a_compile_time_constant_workaround_ define.

CLang fails to handle this well and errors out with: "initializer element is not a compile-time constant".

Provide a custom define _clang_not_a_compile_time_constant_workaround_ to be used as a work-around for the problematic CLang compiler.

Bugfix: Typo in variable name, should be f_print_sequence_enquiry_s.

Bugfix: Incorrect code used in UTF8 character code for U+12C1.

This bug was discovered due to a CLang warning that GCC did not identify.

Update: Fix consistency where initialize macros are not available for every typedef.

Update: Add tests to f_iki project, perform cleanups, and fix discovered bugs.

Update: Add missing dependency to f_type_array for f_iki project.

Regression: UTF8 program is throwing error when trying to read files.

Update: Add test mode and provide -fstack-protector flag.

The recently added Github action for running tests is failing due to a stack overflow bug.
Compile with ssp explicitly enabled during testing to help better identify these cases.

The problem has not yet been identified and does not reproduce locally.
More investigation on that is be required.

This overflow happens while executing the cmocka based test.
There is the possibility that the overflow is in cmocka or as a result of how I am using cmocka.

Update: Finish implementing the FLL Project Mass Test Script.

Bugfix: Random quote that shouldn't be there is breaking tests.

Update: Improve verbosity message passing, making it more consistent across scripts.

Cleanup: Fix wording of normal output argument help message.

Cleanup: Make scripts more consistent with their arguments.

Cleanup: Bootstrap build script.

Make the structure slightly more consistent.

Progress: Begin implementing testing script.

Cleanup: Scripts syntax and styles.

The primary focus is on fixing the uppercase letters for the error and warning statements to follow proper sentence structure.
Other clean ups are incidental.

Update: Style Guide.

Add some additional rules that I thought I had.
They might exist in other documentation elsewhere.
I have not searched for inconsistencies as of yet.

Regression: Some IKI vocabularies are missing their first character.

The previous bugfix (4f0c01eb) failed to check for additional problems introduced by the changes.
I should focus on writing unit tests for fl_read() shortly.

Bugfix: Debug verbositiy should include Verbose verbosity messages.

Update: Socket parameters, rename f_socket_bind_file() to f_socket_bind_local(), and return F_local_not when UNIX socket is required.

Make the f_socket_t passed to the f_socket_bind() and f_socket_bind_file() a pointer constant.

Use the f_socket_bind_local() rather than f_socket_bind_file() to better communicate that this is a local (UNIX) socket.
The f_socket_bind_local() requires the socket to be a local (UNIX) socket, so return F_local_not (with error bit) if it is not a local (UNIX) socket.

Update: Add local and remote status codes.

Update: Relax the uid/gid requirements in f_file_role_change* functions.

Be less picky.
If both ID's are not available, then return F_data_not rather than an error.

Update: Next micro version (0.5.9).

Bugfix: A Rule's "define" settings are not being exported.

The exporting of the define is never performed and needs to be.
This is a quick implementation.
I've added a TODO describing what I really want to do.
The improved implementation is to be addressed after the FLL-0.5.8 release.

Feature: Maps and Multi-Maps should support appending a single map rather than just an entire set.

This is really an oversight on my part.
The append should by default append a single item.
To append an entire set, a new function should be used (an append all function).

This should be done for all of the string types that are applicable.
Such changes are left for the next release and are not planed for the 0.5.8 release.

This functionality is necessary for bug fixes in the controller program.

Feature: Implement IKI support in controller program.

The functionality is designed to mimic some of the design used in Featureless Make in regards to IKI variables.

There are now "define", "parameter", and "program" IKI vocabularies available.

The "program" should probably have some sort of security property in an Entry to restrict its use.
There is a likelyhood of some design not wanting to expose the program parameters to the Rule.
I may also want to implement a "time" vocabulary in the future (likely to happen no sooner than FLL-0.5.0).

It appears that the define environment variables are not being exported as expected.
This is either an existing bug or a problem in the new feature.
Having reviewed this, I suspect that the problem is in the existing design.
A follow up commit will address this issue.

The --simulate and --test displays any loaded IKI variables.

Update: Delete socket rather than resize when array is over large.

I realized that this might be more performant.
If I have to resize the array because it is over large, then a resize could result in a copy of memory.
At this point in the program, the data is irrelevant.
I suspect deleting the array will perform better than resizing the array to a smaller size.

Security: Invalid va_arg() call resulting in overflow.

This overflow doesn't seem to cause crashes, which is even scarier as has gotten away with unnoticed.

The else condition inside of the formatted print functions are accidentally declaring va_arg() when it shouldn't.
The except_at and except_in are also being unnecessarily declared.

Security: The va_list has undefined behavior when passed into functions.

When the va_list is started using va_start(), the va_arg() must be called within the same function.
This is a design problem with how va_list and its respective functions are implemented.
The man pages directly document that passing an already started va_list to a function and then calling va_arg() is undefined.

The va_list, being a macro, might also be a pointer.
This makes passing it as a pointer (or with "const") risky.

Due to the mentioned undefined states and risks, this is considered and treated as a security issue.

Move the va_XXX() logic into a single function.
This unfortunately means some functions have to be expanded out into the code and deleted.
The code now, unfortunately, has more nested as a result of having to add more loops within the same function.

The va_copy() macro is used and so the ap list state is no longer changed outside of the function.

Update: Help ensure va_copy() is defined.

Bugfix: Improper IKI vocabulary position for when a quote is immediately to the left of the vocabulary name.

I distantly remember attempting to shorthand and optimize the logic to reduce the while loop usage.
This appears to have backfired in that I missed one of the possible conditions.

An example of this is the following bash command utilizing IKI substitution:
  echo "IKI Path is 'define:"PATH"'"

In the aboce string, the bug is claining the IKI variable is "'define".
The quote is not a word charcter, not a dash, and not a plus.
The IKI vocabulary is supposed to be "define".

Redesign this back to have the multiple loops.
While this is messier, it should be harder to make a logic mistake.

Cleanup some of the logic to not need the private_f_iki_seek_special() function.

Make sure the width is always calculated prior to calling the UTF aware string functions.

Update wording in iki.txt specification to make a little more sense.

Bugfix: private_fl_print_convert_number() problems and do some cleanup.

The private_fl_print_convert_number() function stops either on non-diit, asterisk, or NULL.
The code is subtracting 1 from the string position.
This allows for the subsequent continue and resulting string increment to not overflow the buffer.
The problem happens when the stop position is a non-digit.
This non-digit is effectivly being skipped by this logic.
Change the logic to always return a position that will allow the subsequent increment without modification.
The position at function exit must never be pointing at NULL.
The position at function exit must never be pointing at a non-digit.

Use "++string" instead of "string += 1".

Change the structure to order from 8, 16, 32, 64, and 128.

Update: Add terminating NULL position and set all values to 0.

Bugfix: Improper if condition range check.

This is supposed to check the start and stop range, but accidentally checks the start range on both side.
This mistake appears to have been copy pasted quite a few times.

Update: Return F_data_not when amount or size is 0 in memory allocation functions and add missing F_string_tripless_t.

Return F_data_not rather than return F_parameter (with error bit set).
This allows for more possibilities where a set of data may be calculated without worrying about an error that is not really an error.
If you want to allocate nothing, then nothing is allocated (and the same for deallocated).

The resize and adjust functions still use a length of 0 as synonymous to deleting the data.

The array of an array of F_triple_t is no longer missing.
All appropriate allocation functions are defined.

Update: IKI Improvements and some cleanups.

The _di_X_t_ where "X" is something like f_fss_object, is missing the leading "f_" in several cases.

Make the *_increase() step variable an f_array_length_t.
Rather than trying to optimize, just guarantee whatever step size is desired is available.

Move the iki_read programs practice of defining an iki_data_t structure into the level_0 iki project.
This then allows simplifying the arguments passed to the iki read functions.

Security: Invalid read when using -bB.

The incorrect variable is being used when performing the size check.
This resulted in the wrong calculation and the subsequent invalid read.

Update: Controller and control.

Fix bug in control where parameter should be "settings" and not "socket".

The controller can now detect the current path and provide a canonical relative path only for paths whose actual canonical path is within the current working directory that the controller program started in.

Fix printing of the help in the controller program (missing slashes).

Don't create socket and pid files when running validate and simulate.
When running simulate, still create the pid and socket files as appropriate.
Add new entry setting to allow explicitly setting the pid file path.

Remove no longer necessary functions that ensure terminating NULL.
The recent changes in the string functions now guarantee this.

Remove a lot of todo comments.
I will either get to them or not.

I plan on getting to writing IKI support.
It needs to happen and I can use the Fake program as an example.

Update: Make sure constant pointers that are intended to be read-only are just that.

I often read "const char *name" as a constant pointer.
This is strictly incorrect.
This actual means that this is a pointer to a constant character.

Mass change the pointers to constants that are intended to be themselves constant.
This is changed via a regex and test to compile and run.
I'm not sure if there are any problems with this change but everything seems fine.

This new code looks more awkward but is strictly correct.
Now "const char * const name" represents a constant pointer to a constant string.
This makes the parameter a constant and still allows for the pointer to point to a constant variable.

Update: Add additional debugging documentation notes.

Refactor: Complete the mass converting to f_string_static_t and use const more.

This should be the last commit needed to migrate from f_string_t to f_string_static_t.

In particular, this breaks apart several of the string rip functions into a dynamic rip and a partial dynamic rip function.

Try to use "buffer" as the variable name more often than not rather than using "dynamic" for f_string_static_t parameters.

Progress: Continue mass converting to f_string_static_t and use const more.

In particular this separates the fl_conversion functions into two forms:
1) That accepts only the f_string_static_t and uses dynamic.used as the length.
2) That accepts both f_string_static_t and f_string_range_t and uses the range to determine the length.

This makes the conversion functions more consistent with the rest of the project's practices.

Refactor: Change "one", "two", and "three" into "a", "b", and "c".

This makes the use of triples easier.

Feature: The fll_identify -n/--name now supports full name as well as type code.

For an example "fss-0001", in addition to matching "fss", also match "0001" or "fss-0001" if requested.

Cleanup: Start comment with uppercase.

Update: Fakefile inner Objects should load the last Object from settings Section.

Use the last found Object for each name for Objects that support only a single value.

That is to say if there is:
  load_build yes
  load_build maybe
  load_build no

Then the last load (whose value is "no") will be used.
No warnings will be thrown.

Objects that support multiple values will continue to append Content for each Object as they are found.

This does not change the "settings" and "main" Objects to match this behavior.
Those will remain as first specified is the first and only one processed and used.

This makes the behavior with the fakefile more consistent with the build settings.

Update: Remove stale warning.

The message from this warning is no longer true as of6283ef1e "Feature: Enable support for modes on (almost) all Fake build settings Objects.".

Bugfix: Comparison should instead be an assignment.

This bug is exposed by the CLang compiler.

Cleanup: Use signed type and cast to unsigned.

This situation is exposed by a warning from the CLang compiler.
The warning makes sense, so the code is changed to a signed type and then cast.

The negative value should never make it to the assignment if the preceding if condition properly catches it as intended.

Feature: Enable support for modes on (almost) all Fake build settings Objects.

The only ones that are now not supposed to support this are the "modes" and "modes_default" Objects.

It should now be possible to build against clang with a command like the following:
  fake clean build -m monolithic -m clang

This is possible because of the "build_compiler-clang clang" and similar settings added to the build settings file in addition to the functionality added by this commit.

Security: Invalid reads, always add NULL for compatibility.

After switching from f_string_t to f_string_static_t, the NULL terminated string problem has become apparent.
If at any point in time these strings are passed to a standard function that expects NULL terminated strings, then an invalid read (or write) can occur.

Manually appending a NULL termination every time its needed has made the code messier than I would like.
This commit changes the behavior to instead always append a NULL termination after the string.used when appending strings.
I accept the additional resource cost of 1-byte per string to guarantee this.

This should make the program more easily more secure by catering to the NULL terminated string code out there.
This project still doesn't need the or care about NULL termination for most (but not all) of its functions.

Security: Invalid read due to wrong parameter in fl_print_format().

This is the result of a mistake during the migration from f_string_t to f_string_static_t.
I missed replacing some '%S' with '%Q'.

Update: Add clang build mode to the build settings files.

Currently the "build_compiler" might not support modes.
This is planned to be changed before the stable release.

This changeset prepares the build settings files for this change.
The clang-specific flag "-Wno-logical-op-parentheses" is moved into the clang mode.

Update: Remove todo.txt documentation.

Update: Add debugging.txt documentation.

Security: Executed program string is not NULL terminated.

While the FLL code doesn't need NULL termination, the C/POSIX execute functions are.
The lack of a NULL terminated results in an invalid read on execute.

Progress: Continue mass converting to f_string_static_t and use const more.

Cleanup: Simplify example bootstrap script by hard coding the version number and always run clean.

Cleanup: Relocate static strings out of the string/dynamic.h into string/static.h.

Regression: Fake static compile not building.

The path_sources_object should not be used for the static library sources.

Skip empty data in static build.

Add additional status check.

Cleanup the example-objects sources.

Progress: Continue mass converting to f_string_static_t and use const more.

Continue on in the f_string_static_t refactoring.
Also take care of adding "const" to the function parameters that pass pointers.

Update: Move hardcoded strings into a const static string for f_color.

Update: Console improvements with related security fix.

Add f_console_environment_process() to process environment variable data passed via main().
Add appropriate testing.

Setup all level 3 (programs) to have the environment data (envp).
The level 3 currently do not utilize this.

While looking at the tests, I realized that I noticed that I did not fully verify the sanity of the passed argc, argv, and now envp.
This is a security issue in that invalid data (argc could be wrong, argv could be NULL, etc..) could result in an invalid read.
Update the f_console_parameter_process() to verify the argc and argv data (f_console_parameter_process() doesn't utilize envp).
Improve tests to catch these potential problems.
Return F_data_not (without error bit) to represent that there is no argc, argv is NULL, or when argv[0] is NULL.
Change the previous F_data_not return to instead return F_complete_not (without error bit) to represent that all of the expected values were not found.

Update functions to use "const" after the asterisk representing the parameter pointer.

Refactor: Switch to a more directory based source file structure.

Mass change all of the code to further utilize directories.
The project has gotten big enough for this to matter.
The stable API should have a relatively clean directory structure.

Cleanup: Minor updates to cygwin documentation.

Update: Use F_directory_not instead of F_directory for non-existent directories.

Also add documentation.

Regression: Invalid read in f_directory_create().

Now that this uses f_string_static_t, the string is not necessarily NULL terminated.
This new behavior resulted in an invalid read.

Redesign to use a range check instead of a NULL check and to include a NULL terminating space in the built string.

Update: Improve f_file_name_directory() and f_file_name_base().

Have both of these functions include a NULL at the end to make compatibility with NULL terminated strings easier.

The directory name should not return "." when the directory is the current directory.
Replace this with an empty string.

Bugfix: Invalid read because NULL is added to list but then f_string_dynamic_append_nulless() is used.

The NULL doesn't matter if the function being called specifically ignores it.
This mistake causes invalid memory reads.

Update: Don't double check the variable.

Update: Add missing unit tests for f_type_array.

Bugfix: Do not validate directory existence when cleaning.

Do not call the directory validation existence check before cleaning.

Also treat F_directory as not an error when cleaning.

Remove unnecessary signal check.

Output to warning stream instead of normal output stream when displaying warning.

Regression: Tests failing due to incomplete refactor.

The f_type_array_lengths_resize() is now f_array_lengths_resize().

Update: The build setting path_sources is not being properly used and improve skeleton process.

Resolve the fixme regarding the path_sources_object and similar.
Consolidate the static source build into functions.

The fake_build_setting_name_preserve_path_headers_s is in the wrong location, resulting in the incorrect loading of build settings data.

Provide default for path_sources.
Make the main->path_sources a prefix path where all sources exist (there will likely need to be a follow up commit to address this in bootstrap.sh).

Get rid of the path_source_* forr bash, c, and other custom paths.

Get rid of the redundant version default assignment in fake_build_load_setting_defaults().
Rename fake_build_load_setting_defaults() to fake_build_load_setting_override().

Update the skeleton generation.
Add "specifications" directory creation.
Add "sources/script" directory creation.

Refactor: Remove "_type" from f_type_array functions.

The f_type_array project is really just an exception case extension of f_type.
It's purpose is to provide the array functions for the associated array structures in f_type.
These cannot be stored in f_type due to circular dependency needs for the f_memory project.

I used f_type_* to prefix these functions but the inconsistency between the structure names has shown to be a problem.
Rename these functions to not have the "_type" within them.

Refactor: Break f_type_array apart into multiple files.

This cleans up the structure to make the code more manageable.

Refactor: path_standard to has_path_standard.

Just like with the preserve_path_headers, change path_standard to has_path_standard.
This hopefully makes the terminology easier to understand by maintaining that all path_* Objects represent paths.

The commit changing path_headers_preserve to preserve_path_headers could have made more changes.
Further update preserve_path_headers to handle what was missed.

Regression: The path_headers_preserve isn't properly being processed and refactor it to preserve_path_headers.

It seems that I changed the path_sources.used to path_headers.used, probably thinking that I had previously made a mistake.
Rename the preserve to preserve_offset to make the intent and purpose more obvious.
The preserve_offset represents and offset to skip before performing the preserve.
The path_sources is the path that should be ignored (path_headers is not used here!).

Refactor path_headers_preserve to preserve_path_headers to make it clearer that this is not a path but instead a property related to a path.

Feature: Fake build settings now supports compiling only object files.

I've observed that many programs like to compile each source file separately by passing "-c" to GCC.
Then the linking is done separately.

I believe unit tests may benefit from compiling individual object files for cases when mocking needs to be performed only for select functions.

With an upcoming stable release planned, I felt that now is the time to get this in.

Due to limitations of the compilers, only a single object file may be generated at a time.
Multiple generated object files may be combined into either a library or a program.
Object file generation is shared vs static aware.
Custom defines and flags may be specified for building objects.

It is now possible to compile different objects files for the generated library and for the generated program.

These are improvements to the build settings build process.
The make build process is still available for more advanced compiling.

An example project, called "example-objects", is provided to demostrate how to utilize the build settings and a fakefile to compile multiple objects separately and then combine them into a single program.

Additional fixes and improvement were necessary to properly complete this feature.

Summary of additional fixes and improvements:
- Improve default handling behavior in both fake and bootstrap.sh.
- Provide more defaults, such as having "compiler" default to "gcc".
- Massive cleanup of the bootstrap.sh (bootstrap.sh is now much closer to matching the functionality of the fake build settings).
- Update documentation.
- Add an error message for when an unknown build mode is passed to the boostrap-example.sh script.
- Fix bug in f_path_directory_cleanup() where the termnating NULL is being included in the count.

Update: A fakefile should not load the build settings by default.

Require this to be explicitly set to be enabled.

Refactor: project_name t build_name.

Originally the build settings files are meant for projects.
I now believe that these should represent "builds".
Replace "project_name" with "build_name".

Bugfix: Missing "extern" in const static strings.

Cleanup: Relocate unit tests under a "unit" directory.

This improves organization and makes room for other kinds of tests.

Regression: Make sure setting.path_pid is NULL terminated.

The libc path functions end up accessing this string.
The libc functions require NULL terminated strings.

Update: Remove fl_console from example bootstrap script.

There no longer is an fl_console project.

Progress: Continue mass converting to f_string_static_t.

This should get all of the programs compiling again.
There is still more work to do with switching to f_string_static_t, but the current pass is considered complete.
Another pass will follow up shortly.

Refactor: fl_console_parameter_to_string_dynamic_directory() to f_path_directory_cleanup().

I decided to improve the mentioned function and realized that it could be further generalized and move into the f_path project.
There is nothing else in fl_console and as such the fl_console project is entirely removed.

Progress: Continue mass converting to f_string_static_t.