Cleanup: Rename pictures that have logo in the name twice.

These should be named icon not logo.

Update: Specifications.

Started using IKI format in the specification files.
Made changes and performed fixes as I noticed them while copying the specifications to the website.

Bugfix: The iki_read program is not handling verbosity correctly.

The newline should be printed at the end of the program unless in quiet mode.
This fails for two reasons:
1) The conditional checks before printing are wrong.
2) The quiet parameter is at the wrong position resulting in it being mixed up with the "no color" parameter.

Feature: The iki_read program should support wrapping a variable value.

One of the original design intentions of the IKI standard is to allow for substitution.
That substitution includes wrapping text with something like HTML markup.
The current design of iki_read falls short here.

While the substitution can be performed, the wrapping while preserving the existing value is not performed.
For example consider the following:
  emphasis:"Some message."

This should be substituted with the HTML5 "<em>" tag.
The substitute parameter requires knowing the value.
The replace parameter also requires knowing the value.

The emphasis HTML5 markup needs to be prepended and appended without having to know every single value.

To solve this, the -W/--wrap option is now available.
This is a 3 parameter option that acts similar to the -r/--replace parameter.
However, it will instead accept a "before" and "after" representing the before and after strings.
Either the before or after string may be an empty string.

The design of this feature re-utilizes existing structures.
These structures have context in their names that do not match "before" and "after".
This can be confusing, but this is considered an inconvenince at this time.
The goal is to keep the changes simple if at all possible with a stable release around the corner.
I also do now know what words to use to share between the different types without creating a new one to make such a change.

This feature is necessesary to ensure completeness with the original intent and design of both the IKI standard and the iki_read program.

Bugfix: Previous commit overlooked the counter resulting in some replacements not being processed.

Oops! This is what I get for rushing this out with little testing and review.

The problem here is that the "+3" is for the 3 parameter option "--substitute".
The 2 parameter option "--replace" must instead use "+2".

Feature: The iki_read program should support a more generalized substitution process called "replace".

In the distant past I mixed up having only two or three substitution parameters.
After getting confused, I decided to just have a 3 argument substitution.
The three argument substitution only substitutes if both the variable name and the variable value match.

This is great but it doesn't follow the completeness theorem.
The iki_read should also handle the general case in addition to the specific case.

Provide a two argument substitution called "replace" that handles the more general case.
When any variable name matches the given replace parameter, then the variable value is replaced for all matching variable names regardless of the existing variable value.

Fix small mistakes in the IKI specification.
I needed to refer to the "variable value" with this change and "variable variable" is simply not the correct way.
Use "variable names" rather than "object names" to be more consistent and clear in this regard.

Update: Add cmocka specific environment variables to the testfiles.

These environment variables are commented out by default.
The "define" "settings" Object defines the environment variable.
The "environment" "settings" Object exposes that environment variable to any called programs.

Update: Add unit tests for fll_status_string.

Bugfix: Fix problems exposed by unit tests.

Update: Add unit tests for f_status_string.

Bugfix: Problems exposed by unit tests and do some relevant code style clean up.

Update: Unit tests, fixing minor mistakes and add missing tests.

While these tests are not expected to be thorough at this time, there are several checks that should still be and can easily be made.

Some of the test files have incorrect comments.

Order test functions alphabetically.

Bugfix: Add missing return value handling in f_fss.

Update: Add unit tests for f_limit.

Update: The f_limit project is out of date.

Writing unit tests revealed that the f_limit project does not operate like the latest code.
Restructure and rewrite f_limit to be consistent with the latest practices and designs in the rest of the project.

Other projects utilizing this are also updated.

Bugfix: Incorrect and missing initializer macros in f_fss.

Regression: Fix mistake in variable name of controller program.

When I added a missing variable to the function, I somehow overlooked a compiler error/warning.
This should be "global.main" and not "main".

Update: Add new status codes and fix problems with existing ones.

The API will be frozen on the stable release.
There are upcoming changes in the next development cycle that will focus on networking.
Provide additional status codes that will be used in networking to make transition and compatibility simpler and easier.

There are also plans in adding init support to the controller program.
Operations such as halt and terminate become necessary.

While working on this I noticed this introduces a discrepancy between "terminate" and "terminated".
The "terminated" is meant to focus on buffers, such as a terminated string.
To fix this conflict, I decided to favor the practice of trying to always use present tense.
This means replacing "terminated" with a present tense word.
I chose "end".
There already is an F_end, so break out a new status section and move all of the newly minted "end" types into that.

While making these changes I noticed and fixed a few problems.

There is both F_warn and F_warning.
Remove F_warn in favor of F_warning.

Add these new status codes (and their _not compliments):
- F_break
- F_desire
- F_discard
- F_drop
- F_exit
- F_halt
- F_keep
- F_need
- F_restart
- F_restore
- F_revert
- F_skip
- F_store
- F_terminate
- F_want
- F_wish

The F_string_too_large and F_string_too_small checks are incorrectly returning F_too_large_s and F_too_small_s, respectively, when they instead should be returning F_string_too_large_s and F_string_too_small_s.

Bugfix: Use '%Q' rather than '%S' when printing error.prefix and add missing error.prefix.

Cleanup: Use standard name when printing message.

Bugfix: The FSS object write functions don't handle all newlines.

There are several cases where the newline character in the object is not being properly treated as an error and returned.

Cleanup: Add U+000A Unicode codepoint in error message.

Refactor: Rename -R/--raw to -O/--original in programs.

The help for this parameter reads "Print with the original quotes and escapes.".
Using the word "original" simply makes more sense that "raw".

Now that there is a reason to use "raw" for other purposes, refactor "raw" into "original" so that "raw" can be made available for defining.

Update: Add unit tests for f_pipe.

Update: Improvements exposed when writing unit tests.

Make sure to call memset on structure.
Minor style clean ups.

Update: Add unit tests for f_path.

Bugfix: Fixes to f_path of problems exposed by unit tests.

Remove unnecessary variable.
Remove unnecessary if condition.

Change while loop to be more robust in .
Check the path.used before checking path.string in case path.used is 0 (this should be safer).

Update function documentation.

The logic in private_f_path_real() is incorrect.
The realpath() function returns a string (char *) rather than an integer.

Also do some code clean up.

Security: Add missing parameter checks and rename "data" to "custom".

Using "data" as the variable name for the "custom" property is confusing and can lead to mistakes.
Use "custom" to directly match that this is the "custom" property rather than the "data" property.

Update: Add missing state.flag assignment in f_state_t_clear macro and fix syntax practice in initializer.

Security: Wrong variable passed resulting in invalid read and writes in Fake.

Bugfix: Environment variables in fake are not being expanded.

The if condition "if (data_make->setting_make.load_build) " should no longer be relevant.
The environment variable should not be tied to load_build.

Change the fl_string_dynamic_partial_compare() checks to fl_string_dynamic_partial_compare_string() to avoid needing to define a custom range.

Bugfix: The fake program should not require the data directory when explicit fakefile or settings files are specified.

Set or reset the validate_parameter_directories check as appropriate when calling 'clean' or 'skeleton' operations.

Make the parameters_required check contingent on the presence of the parameters --fakefile and --settings.
When these are specified, do not even bother checking for the data directory at all.

Update: Add missing function f_path_is_absolute() and fix existing f_path_is_*() functions.

The f_path_is_absolute() function, being the compliment of f_path_is_relative() is now added.

I noticed multiple problems when looking at this code.
- The f_path_is_relative() and f_path_is_relative_current() functions are not checking that the max length is reached before comparing.
- the f_path_is_relative_current() is not incrementing the counter when attempting to check for the next character resulting in invalid results.

The f_path project clearly needs unit testing.
I intend to write unit tests and fix problems found before the next stable release is made.

Update: Utilize the state.flag to allow for fss read to not fail out on invalid UTF-8 code sequence and fix naming problems.

One of the original goals of the FLL project is to achieve fail-through functionality.
Knowing that this is a lot of work, I have ignored a lot of situations where I can implement fail-through and simply performed fail-out or fail-over.

With the upcoming stable release, I believe that this must handle bad data files.
This adds the option to conditionally change the behavior between fail-through and fail-out for the fss read functions and related for invalid UTF-8 code sequences.
The default behavior is now changed from fail-out to fail-through.

This took longer than I hoped.
I will need to do additional reviewing of this code before the stable release is ready.
I also realized that I need to support raw printing of data in the fss read functions as well (and that means changing the existing -r/--raw parameter).

This also fixes the following naming problems:
- fl_fss_apply_delimit() should be f_fss_apply_delimit().
- fl_fss_apply_delimit_between() should be fl_fss_apply_delimit_between().

Update: Utilize the state.flag to allow for iki read to not fail out on invalid UTF-8 code sequence.

One of the original goals of the FLL project is to achieve fail-through functionality.
Knowing that this is a lot of work, I have ignored a lot of situations where I can implement fail-through and simply performed fail-out or fail-over.

With the upcoming stable release, I believe that this must handle bad data files.
This adds the option to conditionally change the behavior between fail-through and fail-out for the f_iki_read() and related for invalid UTF-8 code sequences.
The default behavior is now changed from fail-out to fail-through.

Update: The f_utf_is_* functions should be more specific on return state for F_failure.

Rather than returning F_failure, return F_complete_not_utf.

Bugfix: Invalid read in f_file_stream_read_until().

The file.size_read variable is incorrectly being used when instead the buffer_size variable is intended to be used.

Cleanup: Add -Wno-missing-braces due to false positives.

Update: Add flags to the f_state_t.

Set the flag size to 32-bit as 16-bits is often small for bitwise flags.

I try to keep structures like f_state_t as minimal as possible.
However, I feel that I need to pass information to functions to allow for more flexibility.
I have mixed opinions on this as this encroaches on the Keep It Simple concepts.
However, after consideration, I believe some of this complexity is necessary for the upcoming stable release.

Future development branches will be free to change this as the project exposes the good and the bad of such a decision.

Cleanup: Add -Wall when running tests and fix problems exposed by warnings.

Update: Add pictures of the Kohlrabi that I have decided to use to represent the FLL project.

I grew this myself and felt that this properly symbolizes the FLL project.

Built from the ground up, the FLL is a layered project.

Bugfix: NULL is a valid character, causing utf8 not to properly print NULL characters.

The function f_utf_unicode_from() is incorrectly treating f_utf_char_t as a string (or a pointer).
The f_utf_char_t is a 32-bit integer.
The !0 check is therefore incorrect.

This affects all print functions.

Update: Remove unused code, cast (char) to (unsigned int) for array indexes, and fix bitwise problem.

A bit of stale code is exposed by running the compiler with -Wall.
Example:
  fake clean build -d -Wall
  fake clean build -d -Wall -m clang

Using char (generally) is fine because the numbers match.
However, there tends to be specific cases and behaviors that might result in char being not treated as expected.
Explicitly cast to an (unsigned int) to play it safe.

The fwrite_unlocked() response checks were previously mass refactored to use a size check on the response.
Mistakes in this resulted in the the not operation "!" being left there resulting in a bad if condition check.

Clang warnings about not having parenthesis when using "&&" and "||".
I would argue that this is simply an ignorance or incompetence in the programmers.
The programmers should be expected to understand basic parts of a language, such as order of operations.
Rather than fight this battle, I am just adding parenthesis.

Cleanup: Remove extra space in Featureless Make help.

Cleanup: Add additional spaces to controller program --help.

This fixes alignment/tabbing issues.

Cleanup: Rename 'Available Commands' to 'Commands' in Firewall program.

Cleanup: Expand newline into two words and expand EOL into more descriptive terminology.

Cleanup: Handle a coiple of additional words that now should now each be two words separated by spaces.

Cleanup: Fix typo in the word 'whitespace' and break the word 'whitespace' into two words.

I noticed a typoe 'whitspace'.
Add the missing 'e'.

When printing to the user or documenting in comments use the standard two word form of 'whitespace'.
The programming specific variant of that as a single word will remain in use for programs.

Cleanup: More confusing messages due to a bad refactor.

At this point it has become clear that there was a refactor in the past that incorrectly replaced some of the words with "file".
This made nonsense messages.
These are to be fixed as I noticed them.

Cleanup: The help is displaying a confusing message (more of them).

Cleanup: The help is displaying a confusing message.

Cleanup: Use upper case Object and Content.

Update: Have iki_write use form-feed rather than end of line character for pipe input.

The IKI specification allows for just about any character inside the content, including newlines.
Given that newlines are far more common than form-feed characters, switch to form-feed.
The form-feed character is chosen because there is a standard escape sequence that can easily be passed to commands like echo.
For example: echo -en "a\fb" | iki_write

Regression: The iki_read is not processing anything.

This is a mistake in the commit b1dddea0ecf4aecfe0c7965b1b40b2432ce47b8a.
The size_file variable was created but file.size_read was not replaced in the call:
  status = f_file_size_by_id(file.id, &file.size_read);

Cleanup: Fix +n/++no_color help message.

Cleanup: Rename 'binary' to 'bytecode' in UTF8 program.

The use of the term "binary" here is both valid and invalid.
The UTF-8 is considered text and so this is better called text.
Another name for this is "bytecode".
Given that these both have "b" (for partially preserving the parameters) and "bytecode" is a bit more specific than text, use "bytecode".

Update: Add licenses to text files and clarify OSL text.

Minor modifications to the text in the open-standard-license-1.0.
One notable change is changing "application" to "applying" because "application" can be mis-interpreted as a program (which are also called applications or app for short).
In this context the word "application" is meant to mean "applying".
Just change the word to "applying" to avoid this potential confusion.

Add more text to the protocol terminology to declare the context is in regards to computers and source code.

Add the cc-by-sa-4.0 license file.
They do not provide a downloadable copy of the license, so for now just add links.
I need to come back and fix this once I get a downloadable text file that I can legally store in the source code and transfer to others.

Cleanup: Controller program return codes should be more generalized.

It turns out that when agetty returns on access denied while trying to login, it returns access denied to the controller program.
The controller program has no way of distinguishing that this is access denied while trying execute the program to this is access denied because the program returned access denied.
Change the error messages to be more generalized so that they are less misleading.

Bugfix: Incorrect rule name for controller boot settings file.

Bugfix: When compiled as "init" the controller program does not use the correct paths.

The isolation between the "init" specific changes and the normal "controller" specific code is insufficient.
Move all of the special paths into the main program, introducing a new header and source file called "main-common.h" and "main-common.c".

The main program is now responsible for providing these strings.

Bugfix: The FILE type may not have a known storage size and use F_type_output_d.

Instantiate it as a pointer instead given that it is possible in this case.

Use F_type_output_d instead of "stdout".

Bugfix: Should include <stdio.h> when using printf() in the tests.

Update: Update the "github" test system in the testing script for cmocka and libcap dependencies.

Directly git clone the needed repositories.
Compile and install the dependencies.
Include these custom paths when building and testing.

Cleanup: Remove spurious 'individual' from cmocka build settings file.

Update: Implement "github" test system in the testing script.

The github actions has a repository that lacks cmocka.
Using the apt-get to download the systems cmocka library is slow and a waste of time.

Utilize the support for a custom "github" test system and manually download, compile, and install the cmocka source.
Given that this is for github, utilize a cmocka mirror repository that I found on github.
This is not ideal because it pulls from master rather than a specific version but it should work well enough.

Make any other appropriate changes or improvements to the testing script.

Update: Add f_execute unit tests.

Cleanup: Remove non-existent header file in f_environment unit test mock settings.

Update: Add unit tests for f_environment, make changes to f_environment, and add new function f_environment_secure_is().

Add the unit tests for f_environment.

The new function f_environment_secure_is() brings in libcap dependency requirements to f_environment.
This is added to add support for something similar to secure_getenv() rather than wrapping a non-standard method.
I am still not very experience with capabilities and do not guarantee an accurate replacement for secure_getenv().

Replace F_valid_not error returns with F_parameter error returns.

Cleanup: Bad data and incorrect include in f_file.

Update: Finish writing unit tests for f_file.

Bugfix: Fixes for f_file exposed by unit tests.

Progress: Continue witing f_file unit tests.

Almost there.
Just a few more functions to write tests for left.

Bugfix: Fixes for f_file exposed by unit tests.

Fix case where private_f_file_stat_at() is being passed F_true rather than the flag.

Add missing path.used checks.

When total is 0 in f_file_stream_read_until(), then immediately return as F_none_stop.

Handle case where freopen() actually allows for the path to be NULL in which case the mode string is applied.
In this case, return F_data_not only if both path and mode are not used.
Always re-assign the file stream after calling freopen().

The return status' from private_f_file_stream_write_until() calls are not being processed.
The code is checking the values but the value is never assigned.
Add the missing return value assignment.

Move file stream locking into private_f_file_stream_write_until() and make sure only unlocked functions are used.

The f_file_type() and f_file_type_at() functions need to accept a dereference boolean for consistency with the rest of the project.
Have these two functions call private_f_file_stat() and private_f_file_stat_at() respectively.

When fwrite_unlocked() is called, be sure to set check if ferror_unlocked() returns an error rather than checking size_write.
The previous behavior is incorrect because it is checking if size is less than 0 and the man pages claim that fwrite()/fwrite_unlocked() returns nothing smaller than 0 on failure.

Have the fwrite_unlocked() unknown errnor codes return F_file_write rather than F_failure.

Clean up function ordering.

Progress: Continue witing f_file unit tests.

Bugfix: Fixes for f_file exposed by unit tests.

Restructure private_f_file_close() to be more consistent with the parameter ordering as is done with the rest of the project.

Have f_file_stream_close() not handle flush errors so that close is only to be called once.
The design of fclose() and close() state that even on error the descriptors are freed.
This means that file close doesn't fail, it always succeeds.
But the errors need to be propogated.
Ignore flush and always call close so that the behavior of never calling close twice can be guaranteed.
The private_f_file_close() will still
This also means that the stream and descriptor are to always be reset on close.

Return values need to be updated for several functions.

Rename f_file_stream_descriptor() to f_file_stream_open_descriptor() to make it clear that this is an open command.

Progress: Continue implementing f_file unit tests.

Bugfix: Fix problems in f_file exposed by unit tests.

Add _f_file_rename_use_renameat2_ to enable support for renameat2() for systems in which this is available.
Add flags parameter to rename function to automatically support this.

Add missing "!path.used" checks.
Add missing parameter checks.
Move parameter checks that should instead be file closed checks that process normally.
Consistently apply file closed checks.

The function private_f_file_role_change_at() needs to check that result is not an error before processing group.
Failure to do this may result in hiding an error.

Minor clean ups.

Progress: Continue witing f_file unit tests.

The __wrap_read() needed to be updated.

Bugfix: Problems in f_file functions exposed by unit tests.

Clean up f_file_name_base() and f_file_name_directory() code.

Use f_string_ascii_period_s rather than f_string_ascii_plus_s to match a period!
Perform this comparison check after allocating the necessary space to ensure a NULL terminated string is returned.

The POSIX standard designates that read() returns 0 on EOF.
Rather than checking for size_read == file.size_read (and similar), check fo size_read to be 0.

When total is 0, return F_data_not for f_file_read_until().

Progress: Continue implementing f_file unit tests.

Update: Redesign f_file functions to not need struct stat passed and other improvements.

While working on unit tests I noticed that passing struct stat seems inconsistent.

While there is likely a performance gain of not having to call the stat() functions, the inconsistency is undesirable.

Optimizations can be done under another API series.

Add missing path.used check.

Progress: Add f_file_mode_from_string() unit tests.

Bugfix: Problems in f_file regarding file mode exposed by unit tests.

The f_file_mode_from_string() function clearly didn't survive multiple refactors.
There are problems clearly the result from mass-refactoring.

Now that the parameter is f_string_static_t rather than an f_string_t, use the ".used" rather than NULL checks to determine end of string.
Failure to do this could result in unexpected behavior.

There are also bugs and mistakes that I do not know how they even got past me.
The comparison checks are missing from some checks!
Add missing '==' comparisons.

Exit as soon as possible when code.used is smaller than it is allowed to be.
Mode strings that start with '+', '-', or '=' of length 1 cannot be valid.
Mode strings that start with '=' should replace across all blocks.

Better detect when the code is incomplete and return an error.

Add missing detection for when mode string is too large for number-based modes.

As per chmod command, replacement digits (not having '+' or '-') result in replacing special bits as well.

Update the documentation to better describe how f_file_mode_t works.

Progress: Continue implementing f_file unit tests.

The unit tests for f_file_mode_determine() are very minimal.
There are quite a lot of permutations that I should test but will not get to.
These additional permutations will have to be done in some distant date, probably after the first stable release of the 0.6.x series.

Update: Improve the logic for the read link f_file functions.

The f_file_link_read() and f_file_link_read_at() functions have their dynamic allocation logic improved.
Use link_stat.st_size rather than target->used to pass to readlink() or readlinkat().

Initialize target->used to 0 and then update target->used on success while ensuring the string is always NULL terminated after the target->used.

The unit tests revealed that these can and should be improved.

Update: Add missing checks to f_file_link_hard_at() and use F_file_descriptor.

The F_data_not tests are missing, add them.

The EBADF is returning F_directory_descriptor.
In this specific case, the descriptor is not for a directory per-say but for a general file.
The F_file_descriptor code should be returned in this case.

This has been revealed by the unit tests that I am writing.

Bugfix: The f_file_is_at() function is not properly comparing the file type.

The check should be checking against the passed file type.

This has been revealed by the unit tests that I am writing.

Regression: The trailing Unicode sequences don't always show correctly for sequences ending normally.

The commit 85df83a6d846d575657016682c7014a09ac8af4e didn't handle all of the cases it needed to.
I forgot to check the normal behavior and ended up breaking normal behavior while fixing the exception cases.

The width_utf might be -1 for ASCII and performing the subtracting without handling -1 (and then casting it to unsigned) results in bad behavior.

Only handle incomplete character at the end of the stream when the character is actually incomplete.

Update: Directory tests following recent changes.

The change from a7d607fecf1fdd5eff36d53b6108b6cc316bdf1f didn't include test updates.
The tests need to provide properly dynamically allocated structure for the mocks so that the deallocation internal to the called functions work as expected.

Cleanup: Remove unnecessary condition block.

Bugfix: Trailing Unicode sequences that get cut off before the encoding is completed improperly display.

Detect when this kind of underflow happens.
Print remaining characters without trying to print missing characters.
Reset and perform remaining data to print at end.

Bugfix: Three-width UTF-8 characters are improperly being detected as unassigned.

This is due to a simple typo where the last two digits (the zeros) are missing from the hex digit.

The UTF-8 character sequence for U+FFF0 is 0xef 0xbf 0xb0.

Cleanup: Use macro to add program name to print string in byte_dump.

Bugfix: Unicode characters are not printing correctly.

At some point it seems that I accidentally mass converted all of the macro_f_utf_byte_width() and similar to macro_f_utf_char_t_width().
This broke the printing logic.

The f_print is handling normal characters and not f_utf_char_t.

Cleanup: Remove the 'u' at the end of the numbers.

I feel nervous about this and it is not well tested.
Just remove them.

Security: Incorrect pointers result in incomplete memory deallocation in f_directory.

I accidentally lost the '&' when writing commit 3448c3cdf856f0b46114281235807be2e39c72c5.
I also didn't catch all of the problems when writing commit 3448c3cdf856f0b46114281235807be2e39c72c5.

Update: Implement file statistics flag enumeration, dereferencing/no-dereferencing, and also use F_stream_not.

While writing the unit tests for the f_file project I noticed an oversight in the design.

The dereferencing logic needs to be designated rather than assumed.
This requires changing the parameters to functions.
Now is the time to break the API as the official stable release is not made.

This takes the minimalistic approach to changing the API.
I can imagine better designs where I pass the file stat flag everywhere rather than sometimes passing the file stat flag and other times passing a dereference boolean.
This is a larger change in which I wish to avoid.
Improvements to this can be made for the next development series.

The roles can be merged into the file statistics flags.
The roles of group and owner are separated.
For the purposes of limiting changes, both owner and group are treated the same.
The next development cycle will be expected to improve upon this.

The exclusive boolean is now merged into the file statistics flags.

The fake program must be updated.
A new functionality for designating when to dereference and when not to.
The default behavior is to dereference.
This means that the new option is "no_dereference".
To always favor the dereference by default, the file statistics flag is a "reference" flag used to designate that something must not dereference.

The f_file_descriptor() function should return F_stream_not.
This makes more sense as it only fails when the file descriptor is not a valid file stream.

As mentioned above, I was in the process of updating the tests.
This includes some test updates.

Progress: Begin adding tests for f_file project and clean up the f_directory tests.

The f_directory tests has two unused mocked functions that are no longer needed (they are stale).

The size of the f_file project is huge.
The number of tests needed is huge.

This is my first pass and writing the unit tests for f_file.

Bugfix: Fix problems exposed by f_file project tests.

The f_file_access() should have the mode parameter.
Add missing f_file_access_at().

The f_file_clone() and f_file_copy() are treating exclusive incorrectly.
Do not test for exclusive when assigning the file mode, that is not what exclusive is for.

Add missing paramter check in f_file_descriptor(), f_file_read(), f_file_read_block(), f_file_read_until(), f_file_stream_read(), and f_file_stream_read_until().

The return error result for when a file is not a directory should return F_directory_not rather than F_directory.

Remove unneeded parameter check from f_file_mode_set(), f_file_stream_write_until(), and f_file_stream_write_range().

Add missing range.start > range.stop checks where appropriate.

Many of the file stream functions have locked function calls when unlocked function calls should be used.
Such as where feof() should instead be feof_unlocked() and ferror() should instead be ferror_unlocked().

The private_f_file_stream_write_until() function needs to use unlocked function calls and then must be wrapped between manual flockfile() and funlockfile() calls.

Update documentation comments.

Clean up much of the errno checks alphabetic ordering as appropriate.

Clean up the macro definitions, adding more structure and organization.

Add file access mode define macros.

Simplify function calls where the function may be called with different number of parameters.
This is not strictly allowed by the C language but somehow the POSIX standard got these in and implemented.
This is likely done through macros or some fancy linker tricks.
Avoid these uses and instead use the most likely implemented one.
Example:
  openat(at_id, path.string, file->flag);
  vs
  openat(at_id, path.string, file->flag, mode);
The latter is the one chosen to be most likely.

Add missing result checks that without those checks could potentially alter owner/group on files after an error occurred.

The f_file project tests are a works in progress and so there may be more such fixes to come.