Update: Add f_directory tests then fix problems discovered problems and perform appropriate cleanups.

The "preserve_path_headers" in settings-mocks and settings-tests should be set to "yes".

Add missing dependencies-tests file for any project providing tests.

Remove at_id <= 0 parameter checks because this is already handled by EBADF.

Fix alphabetic ordering of errno returns for f_directory.
I started doing this for f_file as well until I realized how much there is to do.
I won't continue this for f_file because I don't plan on adding tests for f_file for this next release.

The ENOTDIR should return F_directory_not rather than F_directory.

Unable to perform many of the tests because the dynamic linker wrapper is not properlly handling stat() and scandir() as expected.
These tests are commented out, incomplete, and comments are added describing why.

Bugfix: UTF-8 endianess tests fail and improve seek to functions for UTF-8.

The original commit dda60cc8d9cad69b55e7d79b4c052677b03b4413 introduced reversed endianness logic.
The tests passed for this and so the tests were wrong.

The commit that fixed the reversed endianness problems is 78daa0d760fbcc767dd099d68ae02d23b3df4991.
These changes revealed the test problems due to the tests now failing.

Fix the tests.
Make a new character type for the EOL, EOS, and placeholder in a way that is more consistent with the character macros for the f_char_t.

The F_utf_substitute_open_box_d_length and F_utf_substitute_open_box_shouldered_d_length should have _s_ rather than _d_ in their names.

Change the UTF-8 seek to functions to not need to check for URL fragments.
Change the UTF-8 seek to functions to accept f_utf_char_t rather than f_char_t.
This completely makes more sense.
This allows for searching a f_utf_string_t using a f_utf_char_t.
The tests are expecting this behavior earlier and they only happened to succeed due to the coincidence of the bitwise order of the previously incorrect tests.

This swaps the bitwise order of the strings.
More than likely I need a macro check to handle big endian as well.
This is left to changes in the future.
The 0.6.x stable series does not guarantee big endian support.
The 0.8.x stable series does guarantee big endian support because I will be working on adding networking support.
Leave the bitwise improvements and tests for the next development cycle so that I can focus on pushing out the 0.6.x stable release.
If I have the time, I might still fix this after the release candidate is released as I will most likely be improving the tests and fixing any discovered problems.

Update: Get the controller program in a better state for a stable release.

I started realizing that there were things that I forgot all about that the control and controller programs need to do.
There are too many changes to make immediately before the release.

Remove the incomplete code to avoid having stale code and therefore stale binary data.
Comment out the parts that generate socket related information as the socket cannot be supported yet.

Update: Get the control program in a better state and update the control/controller documentation.

I started realizing that there were things that I forgot all about that the control and controller programs need to do.
This is too many changes to make immediately before the release.

Wrap up the control program into a tolerable state and it will be published as is.
Release notes will be used to document that this program didn't make the cut in time.

Regression: Invalid code added to controller.

This got accidentally changed in this commit: 928bb81378ba50f086af5eb54327819751a523aa.

Bugfix: Incorrectly checking byte width when already inside a character.

The width has already been determined, so these values are parts of a UTF-8 character.
The code is doing a byte check and attempting to verify or process this as a new UTF-8 character sequence.
This results in an inaccurate data from that point forward for the rest of the file.

Update: Do not use sizeof(char_t) for explicitly handling 1 byte.

The char_t could potentially be of some size other than 1.
This read is per-byte and not per-character.
Normally these or true, but some special architectures this might not be.

Bugfix: The byte_dump program should respect the +q/++quiet.

When printing the "Invalid UTF-8 code.." or "read() failed.." error message, the code needs to check and respect the verbosity state.

Regression: Accidentally reversed the big vs little endian bits.

I had a fear that I might of done this with the commit dda60cc8d9cad69b55e7d79b4c052677b03b4413.
Turns out I was right.
All that back and forth getting confused before I realized that I should not use the BIG_ENDIAN macro did result in me getting confused on what bit goes where.

Update: Centralize common error function, minor cleanups, and improve status code programs.

Printing an error for two different long parameters that cannot be used together is very common.
Move this into a single function inside of fll_program.
Make sure that these calls are wrapped in appropriate verbosity checks.

The status code programs is now able to print the number with the error bit and/or warning bit set.
The status code programs status codes error and warning can be used together when using the -n/--number.

Perform minor cleanup where the "main->parameters.remaining.used > 0" can be simplified.

Regression: Invalid syntax in fake program.

I thought I compiled this to confirm that the code was correct.
Apparently not.

Fix the syntax so that the code compiles.

Update: Add F_once, F_receive, F_repeat, and F_send status codes.

This includes the *_not inverse versions.
Move the F_search into the correct position.

Update: Remove inefficient and pointless size increase.

This must have been by accident or by habit.
The (range->stop - range->start) for these shouldn't be happening.
These checks are solely for ensuring there is enough room after what is already allocated.
The behavior is actually potentially doubling its size.

Only increase size by the required amount.
There are likely other such problems that need to be fixed across this project.
I will likely not get to these by the 0.6.0 stable release and will have to address them following that as I find them.

Update: Ensure all programs are handling signals, adding signal_received to fll_program_data_t.

Make sure fll_program_data_t supports storing the signal.
Move the commonly written functions that are pretty much identical across programs into fll_program:
- fll_program_standard_signal_received()
- fll_program_standard_signal_state()

Increase standard signal check from 10000 to 20000.
I really dislike the signal_check logic that exists purely as a work-around to the signal handling.
Most likely the only way to do this nicely that is available without rewritting the kernel and the libc will be to implement threads.
This will not be done for the 0.6.x versions and will likely happen for the 0.8.x versions.

Update: Move the program data into the main for control.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Move the program data into the main for control.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Partially move program data into the main for controller.

This does not use fll_program_data.
The controller needs a more complex structure than the one provided by fll_program_data.

The parts that can be moved are moved to be more consistent with other FLL provided programs.

Update: Add pid integer to fll_program_data_t.

Update: Move the program data into the main for fake.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Add umask integer to fll_program_data_t.

This should be a standard practice that ideally must go away if the POSIX standard ever fixes that idiotic umask() design.
Never under any circumstances should a read-only operation result require a write operation!
I am forced to work around this, so I might as well provide a standard practice work-around.

Update: Move the program data into the main for firewall.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Add child integer to fll_program_data_t.

A few of the programs practice returning the child return status or the child process id.
Make this behavio standard by adding child to the fll_program_data_t.

Update: Remove redundant F_status_set_error() when returning status with an error.

Update: Use const for f_console_arguments_t and add envp.

Update: Move the program data into the main for fss_basic_list_read.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Move the program data into the main for fss_basic_list_write.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Move the program data into the main for fss_basic_read.

Move parameter initialization and deallocation for FLL program data into main.c.

Cleanup: Fix styling, add new line before break.

Security: Invalid write in FSS processing functions due to improper allocation size.

The start and stop ranges are inclusive.
This means that the size is (stop - start) + 1.

The problems happens where the code is adding additional digits to represent end of line or other special characters.
When this is added, I seem to have forgotten to add the additional numbers to the + 1 and instead replaced the + 1.
This results in the size being potentially short by a single character and thus an invalid write is possible.

Update: Move the program data into the main for fss_basic_write.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Move the program data into the main for fss_embedded_list_read.

Replace fss_embedded_list_read_main_t with fll_program_data_t and fss_embedded_list_read_data_t.
Move parameter initialization and deallocation for FLL program data into main.c.

Update: Move the program data into the main for fss_embedded_list_write.

Move parameter initialization and deallocation for FLL program data into main.c.

Cleanup: Add missing F_attribute_visibility_internal_d.

Update: Move the program data into the main for fss_extended_list_read.

Move parameter initialization and deallocation for FLL program data into main.c.

Cleanup: Remove unnecessary error assignment.

Update: Move the program data into the main for fss_extended_list_write.

Move parameter initialization and deallocation for FLL program data into main.c.

Cleanup: Remove unnecessary error assignment.

Update: Move the program data into the main for fss_extended_read.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Move the program data into the main for fss_extended_write.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Move the program data into the main for fss_identify.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Move the program data into the main for fss_payload_read.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Move the program data into the main for fss_payload_write.

Move parameter initialization and deallocation for FLL program data into main.c.

Cleanup: Remove delete function notes from documentation comments.

Bugfix: The out of range is printing and then continues processing.

When out of range happens an error should be printed and should stop processing for that parameter.
This is not happening because the status is incorrectly being returned when status is not assigned an error bit.
The out of range check happens independent of the status variable.

Update: Move the program data into the main for fss_status_code.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Deallocate before releasing signals.

This helps ensure that signals, if being controlled, are properly deallocated before allowing any signals free range.

Update: Restructure iki_read to use fll_program_data_t.

Create iki_read_data_t for private data and passing the fll_program_data_t pointer.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Restructure iki_write to use fll_program_data_t.

Create iki_write_data_t for private data and passing the fll_program_data_t pointer.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Move the program data into the main.

Move parameter initialization and deallocation for FLL program data into main.c.

Update: Make Utf8 private data private and move the program data into the main.

Move parameter initialization and deallocation for fll program data into main.c.

Move the utf8 data into the private files.

Update: Use signal_check more consistently in programs.

There are programs that do not use the fll_program_data_t structure.
These now define the signal_check in their main.
Such cases will go away as soon as they are converted into using fll_program_data_t.

Regression: Use correct function for mutex lock.

The lock is a mutex lock and not a lock.

Security: Controller program is not initializing the alert mutex lock.

This results in undefined behavior and a possible segfault.

This appears to be an oversight.

Also remove stale commented out code and slightly improve the wording in a comment.

Update: Finish writing tests, fix endianness, simplify some code.

Now that f_char_t exists and is in use, rename f_utf_character_t to f_utf_char_t to be consistent (and simpler).

The endianness detection is incorrect.
The BIG_ENDIAN is not represented as expected.
Change the detection to use GCC's __BYTE_ORDER__ macros.
Fallback to little endian if those macros are not available.

It took a while to figure out this was the problem and I got rather confused going back and forth between byte orders.
I think the changes I made are correct, but I need additional better testing on the byte orders.

Update: Bring f_utf project in sync with f_string.

I have been explicitly avoiding making change to f_utf until I finished updating and successfully vetted the f_string project.
Now that the f_string has tests that pass, mass update the f_utf project.

This changes the functions and structure to be inline with how f_string works.
Many of the fixes are brought over.
I have observed that several of the bugs that were recently in f_string is also present in f_utf.
These bugs in f_utf should now be fixed as well.

This tests are brought over.
Only the tests for functions that are shared between f_string and f_utf are implemented.
And then those tests currently cannot be compiled.
The reason is that normal quoted strings cannot be used with the special UTF dynamic strings.
I simply did not have the time to get to this to finish writing these tests for f_utf.

There are some parts of f_string that make no sense in f_utf, such as f_string_range_t and f_string_quantity_t (both of which can be used on f_string and f_utf strings).
These have been omitted when copying the relevant f_string into f_utf code.

Cleanup: The f_string project.

Update: Restructure parts of f_utf project, and use f_utf_t, and add 'u' to hexdigits in common.h.

Move the relevant functions into utf/convert.h, utf/is.h, and utf/is_character.h.

Implement f_utf_t as a type of uint32_t.
This should allow more customizability on that type if need be.
It also provides a more explicit context.

Add 'u' to designate the hexdigits are unsigned (This likely more specifically means it is an unsigned int).
This might be removed if it becomes a problem with architectures where "u" represents 16-bits or less.
Due to the size of the work, I am avoiding making this change in all of the Unicode comparison functions.
There are quite a lot of hexdigits in use.

Update: Add remaining tests for f_string project.

Bugfix: Partial string functions are incorrect.

The tests exposed these problems.

The *_assure() functions are operating as if they are *_assure_nulless().
Remove the NULL checks that should not be there and fix the documentation comments.

The *_assure() functions are not considering the following:
1) The case where range.stop is >= source.used.
2) The fact that range.stop is inclusive and should not be directly used in the same way that *.used is used.

In the case of (1), if the stop range result in it overflowing past the actual length, the previous code results in invalid reads.
In the case of (2), the stop.range needs to instead be stop.range + 1.

Update: Add additional tests for f_string project.

This adds tests for the f_string functions for functions defined in string.h.
This adds tests for the f_string functions for functions defined in dynamic.h that functionally mirror functions defined in string.h.

There are still more functions in dynamic.h that need to have tests written for them.

Bugfix: Incorrectly performing nulless string appends and prepends.

These problems are exposed by the tests that I am writing.

The destination->used < length check cannot be performed because of the presence of NULL characters.
The nulless versions of the strings may be identical even if their sizes do not match.
The only case where this check should still happen is when destination.used is 0.

The comparison operator is using the wrong variable in some cases ('j' should be used with 'destination').

Replace uint8_t with f_char_t.

Minor updates to the documentation comments.

Progress: Controller and Control sockets.

Bugfix: The f_socket_connect() needs to handle EINVAL errno.

Bugfix: Print functions are not always printing the entire string.

I observed this when working with printing binary data in '%Q'.

The fwrite_unlocked() might prematurely return but not on an error.
If it does, first check to see if it is an error and then keep trying until everything is printed.

This is more of a band-aid fix.
This requires an additional variable and an additional loop.
I would rather avoid all of this and so a re-design is likely necessary for greater efficiency.
As this is not my focus at the time I am going to tolerate this less than desirable design.

Bugfix: Increasing strings by too much.

The *_increase_by() methods already include the ".used" length.
The previous code is also adding the ".used" length resulting in an increase of ".used" * 2.

Progress: Controller and Control sockets.

Cleanup: Clarify documentation comment that the function appends to the destination.

Bugfix: Invalid F_parameter error in f_socket functions.

For these functions, the length pointer is optional and therefore must allow the length pointer to be 0.

Bugfix: Invalid '%lu', in formatted print, should instead be '%ul'.

Bugfix: When using --at with --total for --content, the returned number is always 1 and should not be.

The code need to count all newlines rather than always returning 1.
This is likely a bug from copying the code from fss_basic_read where the non-zero count would indeed always be 1.

Bugfix: Invalid content count in FSS Basic List.

When F_none_eos or F_none_stop is returned, the content ends up having an additional size than the actual size.
This is happening because found->used++ is incremented immediately before returning.
When either F_none_eos or F_none_stop is returned, the content is not to be incremented.
Only the caller should know when to assume this is a proper ending representing the content end.

The macro private_macro_fl_fss_content_return_on_overflow_delimited() is only used in one place so remove it.

Make sure to initialize the content for all content read functions to ensure the content count is consistent.

Cleanup: Restructure to have the *_type_name() functions into public functions under common.h or similar.

Have the programs expose these functions to the public API.

The enumerations, consequently must also be exposed publicly.

Progress: Controller and Control sockets.

Progress: Controller and Control sockets.

Cleanup: Add a version number to the Open Standard License draft.

Update: Use return rather than assignment and break in type name functions.

Progress: Continue working on control and controller.

This focuses on the control end of things.
This pulls in several dependencies that are needed to process the packet.

Update: Packet specification.

Update: Add F_status status type and rename F_status_size_max_with_signal to F_status_size_max_with_bits_d.

The max size for what is now called F_status_size_max_with_bits_d is (2^16)-1 and not 2^16.

Update: Add clang support to the bootstrap-example.sh script.

Cleanup: comments.

Cleanup: Header define should end in lower-case 'h'.

This style problem is identified by CLang.

Update: Consistency improvements with *_append() and *_append_all(), add tests, and other clean ups.

The array functions for managing structures needs to be consistent with the *_append() functions.
This introduces the *_append() all across the board.
The previous *_append() behavior is essentially refactored into *_append_all().

The *_append() now accepts a single type for a given structure rather than a set.
(The single type can still be representative of a set itself.)

Add a lot of tests.
Add missing f_iki tests.
The f_string tests are not fully implemented, the f_dynamic_* functions are only partially tested.
All of the other f_string structures should be fully tested now.

Make the macro_f_string_range_t_initialize() macro consistency with all other macros.
That is, the macro initialize that does not have a digit initializes using all of the structures members.
This effectively refactors macro_f_string_range_t_initialize() into macro_f_string_range_t_initialize2() and macro_f_string_range_t_initialize2() into macro_f_string_range_t_initialize().

Change the behavior of the *_resize() and *_adjust() functions to return F_none rather than a direct f_memory status code.

Update some of the string functions to return F_data_not_eos.

Restructure some of the code to be a bit more organized.
Specifically, the f_iki_data_t is moved into its own source and header files.
Reduce the clutter in some of the private source and header files by moving some of their content into separate individual files as appropriate.

Progress: Controller and Control sockets.

This also adds a new FSS: FSS-000F (Simple Packet).

I decided that this needs its own specific specification to represent it.
This further helps make it clear that a Packet is not the same as a Payload.

There can still be some confusion because the FSS-000F (Simple Packet) has a Payload Block.
That Payload Block contains the FSS-000E (Payload).
That FSS-000E (Payload) has a Payload section within itself.
This means that there are three different, but very similar (and also related), contexts used for a "payload".
To try and avoid this, I refer to the payload in FSS-000F (Simple Packet) as the Payload Block.
I refer to the payload in the specifications as the FSS Payload or the FSS-000E (Payload).
I refer to the payload within the FSS-000F (Simple Packet) as the Payload Object, the Payload Content, or the payload section.

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.