Progress: Continue working on completing the remove program.

Make sure to not set the `kt_remove_main_flag_option_type_d` for the "different" and "same" parameters.
Make sure to not set the `kt_remove_main_flag_option_used_d` for the "empty" parameters.

The `kt_remove_flag_file_operate_recurse_d` flag is being set on a directory, but it is always being set without regard to te recursive parameter.
Remove it an and just check the recurse parameter instead.

The empty not flag should be checked when checking empty states.

Remove accidental assignment of `kt_remove_flag_file_operate_remove_d` when `is` is true for the `kt_remove_preprocess_file_type()`.

Address the program unit tests.
Add the empty parameters in places where the tests were originally expecting the remove command to remove non-empty directories by default.

The directory tree tests were improperly returning false on the mocked empty for the parent directory after the child directory was mock deleted.

I'm currently investigating problems where the following does not work as expect:
```shell
clear ; md a/b/c ; touch a/b/file ; remove a/b/ -r +V ; t a
```

Cast the `flag_operate` when transfering to/from the `recurse.state.code`.

Progress: Continue working on completing the remove program.

Remove redundant code and get rid of a lot of the callbacks.
I did further structural investigation and found that I really didn't need most callbacks.

Add special flags to distinguish when file types are being specified and when they are not.
Then when this is set, handle accordingly and print errors.
This reduces the need for custom handling code in each of the other programs like `rm`, `rmdir`, and `unlink`.

Update the settings and flags accordingly.

I have not gotten the time to update the unit tests, which currently now fail.
I also need to review the programs and their replacement counterparts for any problems.

Progress: Continue working on completing the remove program.

Clean up the function naming.
The file remove and directory remove structure is rather confusing, name-wise.
Simplify the names.
Now that I know how I intended to implement the callbacks, I can remove unused callbacks.

This is being committed in isolation to allow for better diagnostics.
I will follow this up with additional testing whose changes, if any, will be in additional commits.

I still need to review existing functionality and also resolve incomplete functionality.

Progress: Continue working on completing the remove program.

Fix recursion parameter to actually work by setting the `kt_remove_depth_max_d` when calling `f_directory_remove()`.
Make sure `--force` works as expected as well as work when not specified (remove unnecessary checks).
Still print verbose messages even when in debug mode while the force parameter is passed.

Oops! I incorrectly used `macro_f_console_parameter_t_initialize_6()` when I instead should have used `macro_f_console_parameter_t_initialize_4()`.
The `macro_f_console_parameter_t_initialize_4()` is for the short parameter type where the `macro_f_console_parameter_t_initialize_6()` is for the simple parameter type.

Finish the `--help` messages for the `rm` program.
Make sure to note that the `--one-file-system` is not supported.

Fix messaage for `--preserve-root=all` error.
Make sure to handle `--preserve-root=/`.

Update: With latest FLL changes to fll_program.

Progress: Continue working on completing the remove program.

Implement most of the `rm` program.
There are some remaining details and I need to also test the program.

Move some of the repeated setup code into `kt_remove_setting_load_standard()`.

Add the initial settings needed to support the `--preserve-root` and `--presserve-root-not` support via the newly added `root` flag.
This work is not yet implemented and needs to be completed.

Add support for all programs to return `2` instead of `1` when `F_support_not` is an error return to the main program.
I might end up applying this behavior to all of my FLL and related programs.

The `rm` program in particular has the `--` being manually processed.
I figured given the simple nature of this program that it would be easier to manually pre-process than to utilize the custom callbacks supported by the `f_console_parameter_process()`.

Progress: Continue working on completing the remove program.

Make sure the `--force` parameter is properly suppressing errors and warnings when a file is not found.
Do not print an error or error out when `--force` is used.
Utilize the `ignore` string and print the boolean state based on `--force` when a file is not found during simulation mode.

Remove the warning on file not found because an error is potentially printed later on.

Update the `--prompt` settings.

Update the program unit tests.
The program now properly returns non-zero on file not found when trying to remove.
The program unit tests are updated to match this expectation.

Update the readme documentation for the remove program.

Fix the standard parameters and properly use `f_console_standard_parameter_last_e`.

Begin adding the `rm` program.

Progress: Continue working on completing the remove program.

Add the `rmdir` program.

The `install.sh` script doesn't utilize the `-s` parameter.
There only needs to be a single `install.sh` command, which attempts to install everything in the build directory.

Update the version numbers to `0.7.1` just to make relating to the 0.7.x FLL more consistent and obvious.
Eventually these will separate and change in their own ways but for now this is not a problem as there is no official Kevux Tools release.

Change how the `--remember` logic works.
Skip the pre-process entirely if the remember matches.
Do not append a trailing slash for directories.
(There may need to be more code reviews due to the new remember logic and I will have to do this later.)
The `skip` printing in the simulation mode is no longer needed due to this change.

The `--empty` logic along with the `--ignore-fail-on-non-empty` is changed.
I need to rethink the design but for now just make the logic work for `--ignore-fail-on-non-empty`.
This allows for `rmdir` to work as expected with `--ignore-fail-on-non-empty` and without `--ignore-fail-on-non-empty`.

These changes break some of the unit tests.
The `--force` tests also started failing.
It looks like I didn't actually finish those tests and they happened to previously pass so I didn't notice that it is incomplete.
I will come back to these tests later to address them.

Bugfix: Stand alone builds should not have library.

The `build_sources_library` is accidentlly being used when instead `build_sources_program` needs to be used.

Progress: Continue working on completing the remove program.

Update the copyright year.

Add the `unlink` program.
Make sure all necessary callbacks are available to perform this.
Use a custom parameter processing to more closely match the standard Coreutils unlink argument.
I am still preserving some of the core parameters of the FLL/Kevux projects.
(This means that there is the `++version` and the `--version`.)

Fix bug where no error was being printed on non-existent file.
Make sure to also exit on error in this situation.

Progress: Continue working on completing the remove program.

Use polling on the standard input to allow for blocking in an interruptible way.
Once there is input the file read can be called to read the input.

This finishes the `remove` program development.
I am still designating this as progress because the following wrapper programs now need to be written:
  - `rm`
  - `rmdir`
  - `unlink`

Progress: Continue working on completing the remove program.

This wraps up most of the `remove` program functionality.
It seems that I already had Time and EpochTime logic in place and I didn't have to do anything.
Add the program unit tests for time and EpochTime.

Fix some documentation comments in the program unit tests.

There is a remaining `@todo` in the `remove` program that will need to be address in the FLL.
I will have to brain storm on how I want to do this and I may end up adding callbacks to all file read and write functions.

Progress: Continue working on completing the remove program.

Add UNIX Timestamp tests.
Fix date changed tests where I forgot to reset temporary date loop variable assignment before committing.

Add the accessed and updated (modified) time tests.

When recursion is disabled and a directory is being followed, then prevent a double delete by not performing the delete on the "after" at the top level.

Implement the `--prompt` support.
Make sure to take in command line input.
Make sure to quit the program when prompt is one time and the answer is no.

Change the flag to 32-bit for consistency reasons.

Progress: Continue working on completing the remove program.

Finish some work that I thought I finished in the previous commit.
There were some commented out cases where I was doing controlled manual testing and I forgot to restore the commented out logic.

The Time and EpochTime are not well documented and are also not actually implemented!
Add more of the Time and EpochTime documentation.
I will look into implementing this at a later date.

Add unit tests for the basic Unix Date format.

Progress: Continue working on completing the remove program.

This adds the yesterday and today program unit tests.

Focus on getting the unit tests working and correcting the logic.
There is a lot of logic surrounding the relative dates and times that makes this ripe for an error.
I will need to add more program unit tests over time to better catch logic mistakes.

Progress: Continue working on completing the remove program.

Finish setting up any remaining start and stop values.
Make sure the timezone adjustments apply to the stop times.

Remove redundant code in the setting of the timezone.

Use `uint8_t` rather than `f_status_t` for `result` to avoid any potential confusion.

Fix the `time_spec_clocks` date and the `Not` check.

Progress: Continue working on completing the remove program.

Update the `fakefile` to allow for choosing only just `remove` or just `tacocat`.

Begin adding the date tests.
Fix problems as encountered.
Make the start and end dates initially the same when populated from the clock.

Progress: Continue working on completing the remove program.

The existing program unit tests revealed that the date pre-processing is:
1. Happening even when none of the date flags (access, changed, and updated) are set.
2. Is incorrectly returning `F_yes` due to the initial `F_okay` assignment to `status`.

Add `accessed_changed_updated` helper flag and use that flag to ensure the `kt_remove_preprocess_file_dates()` only gets called when needed.

Initialize the `status` value to `F_false` in the `kt_remove_preprocess_file_dates()`.

The newly added pint functions is resulting in an extra call to `geteuid()`.
Add a second wrap call to address this.
I may want to use a variable in the future to prevent multiple calls to this function.

Progress: Continue working on completing the remove program.

Utilize the FLL file type strings.
Merge the separate file stat printing into the simulate function and create the appropriate print functions.

Fix the loop variable name order ('i' before 'j').
Fix the printing of the Time and EpochTime units.
Print the time units on the same line as the `updated`, `accessed`, and `changed`.

Improve error printing for user and group IDs when the ID is not found or too large.

This provides changes that were documented in that commit.

Fix the `--force` flag, which essentially means that it must ignore missing files.
Update the help documentation regarding this.

The file stat printing function is very redundant and should be combined into the simulate function.
I noticed that the date based pre-processing is only in the printing and is not yet toggling the flags.
Begin moving this over.
I decided to make a separate function to handle this given its size.

Reset the `!(^)` check back to a `==`.
The compiler should be able to determine the most efficient operation and using plain `==` is just more readable.

Add some additional help messages describing how  the `<` and `>` characters must be quoted to prevent them being used as redirect characters.

Is `stop_year` not being used when it should be?
Plan on investigating this.

Be more consistent with the parameter handling strings in the program unit tests.

Add the unit tests for `--force`.

This provides changes that were documented in that commit.

Use the `^` operator (XOR) to determine if mode is different or the same.

Add file mode program unit tests.

Progress: Continue working on completing the remove program.

I forgot to perform the `git add` for the previous commit bf990a10a2c24f6304bb04dc2569765abb5b2347.

This includes changes that were supposed to be in that commit.

Add file type based program unit tests.
Add user based program unit tests.
Add group based program unit tests.

Fix bug exposed by the program unit tests where the id tests are only being performed as a group test even when it needs to be a user test.
This is fixed by creating and passing the `is_user` boolean to the functions.

Fix bug exposed by the program unit tests where the `--same` and `--different` boolean logic is reversed resulting in `--same` removing for different users and `--different` removing for the same user.

Progress: Continue working on completing the remove program.

Add more recurse simple program unit tests.
Add the tree simple program unit tests.

Implement the tree delete operation.
Relocate the parent directory pre-process to a loop that is processed after all other files and directories are removed.

Progress: Continue working on completing the remove program.

Add the first more complex file removal runtime unit tests.
I may start calling these "program unit tests" as that sounds more accurate than "runtime unit tests".

The `f_directory_is()` should not be needed because the `fl_directory_do()` already passed a flag designating that the path is or is not a directory.
Remove the calls to `f_directory_is()` and instead use the appropriate flag.

Add `directory_parent` helper flag.

Report whether or not the path is a parent path when using tree mode.
The tree mode has changes in this commit that are not yet tested and need to be tested.
I should write a program unit test for this as well.

The "list" flag is not needed for the `fl_diectory_do()` processing.

The `parent` and `child` flags are now used differently.
The `parent` flag is now used to represent a parent directory only in the case where tree mode is enabled and the directory is only a parent directory do to parent tree traversal.
The `child` flag is now used to represent recursion from some directory.
The recursion cannot happen on a `parent` as the tree mode does not support recursion on a parent.
The `child` is passed to any directory or file that is being recursed into.
The lack of the `child` flag should designate that this is a top-level directory as far as recursion is concerned.

Fix an issue where the wrong flag is being used for the `flag_operate` `directory` flag.

Both the `kt_remove_operate_file_directory()` and the `kt_remove_preprocess_file()` should have the directory and parent flags cleared when called via pre-process recursion.
The pre-process recursion does not need to pass any flags to the recursion callback (via the `recurse.flag`).
The operate recursion does not need to pass the list flag to the recursion callback (via the `recurse.flag`).
Make sure the directory state is preserved by mapping the flag from the `fl_directory_do()` to a flag for the kt_remove file operations.

Progress: Continue working on completing the remove program.

Add more runtime unit tests.

This begins adding simple directory recurse tests.
The current test written for this is incomplete and needs the `fl_directory_do()` to be unwrapped.
Then the individual parts need to be mocked as needed.

Progress: Continue working on completing the remove program.

Fix a bug exposed by the directory unit tests where the `recurse.path_top` is not being defined and must be.
Add additional safety checks to fall back to a NULL string if `recurse.path_top` is NULL.

Add basic file and directory tests.
There are still a lot more tests to write.
This should be an acceptable start.

Refresh the stand alone build settings and config.h files.

Progress: Continue working on completing the remove program.

I discovered that the `fl_directory_do()` could use some improvements while working on this.
Those changes are now made in the FLL project.
Make changes to this project based on the `fl_directory_do()` updates.

I began writing some tests and I encountered several problems and concerns that side-tracked me.

Rename the `kt_remove_operate_file_recurse()` to `kt_remove_operate_file_directory()`.
This should make its design and purpose more clear.

Make sure that the recurse status is processed in the proper order for the file operation directory.
Fix the problem where the recursion is being performed even when the recurse flag is not set.
Add checks to see if the directory is empty or not before deleting when recursion is not enabled.
The flag (called code in this case) needs to accurately reflect the directory status of the file during recursion.
Make sure the recurse error handler uses the top path or the recurse path as appropriate.

Print debug messages before recursion begins.

Add missing `f_status_t` return states to several print functions.
I did not do an exhaustive look (I imagine the TacocaT program needs similar changes).
Fix problems where the program output is being used for the print functions rather than the print output.

The runtime unit tests do not work correctly because the standard outputs are being closed.
Add additional ifdef checks to prevent the set down functions from being called.

Progress: Continue working on completing the remove program.

This adds the beginnings of the runtime, unit test like, testing.
This approach for a runtime test is being done to make mocking functions easier.
The goal here is to not have actual files created and especially to have no files actually deleted.

If the delete doesn't work properly, then there should be no consequences due to not actually running any real deletes.

The current state of this simply tests the help and version parameters.
I chose this as a way to hash out the process that I am going to use.

This fixes a mistake in the individual library link name for `-lfl_directory`.

Remove unused `kt_remove_main_t *main ` declaration.

Fix documentation comments for several header files.

Update: The fll_error dependencies.

This brings the code in line with the recent centralized string design.

Progress: Continue working on completing the remove program.

Implement the memory cache for the remember parameter.

Progress: Continue working on completing the remove program.

Update the remove documentation.

Add support for the remember parameter.

Stub out the memory cache processing for when the remember parameter is set to yes (enabled).

Progress: Continue working on completing the remove program.

Complete the recursion logic.
There wasn't much left to do at glance.
Additional testing will weed out any remaining incomplete functionality.

This should leaves:
  - The remaining `@todo` notes.
  - Any remaining advanced matching (if any).
  - Adding runtime tests.

A note about adding unit or runtime tests.
I am thinking that I need to mock all of the remove functions.
These mocked functions will write a flag bit in something that will designate all of the removed files.
This result of marked removals can be matched to the expected removals.
This could operate like a combination of a unit test and a runtime test (unit test over the main program, which would be effectively the same as a runtime test in some ways).

Progress: Continue working on completing the remove program.

Utilize the recently added `f_id_t`, `f_gid_t`, and `f_uid_t` types and the respective function to reduce the amount of code for user and group ID processing.

Progress: Continue working on completing the remove program and update with FLL changes.

There is a lot of work on the recursion behavior.
These changes were interrupted and I need to relook at them and get back to where I was.
There are likely partially complete changes that puts this code in a bad state, in terms of execution.

Update with the latest FLL changes.

Progress: Continue working on completing the remove program.

Implement the prompt simulate message logic.
Change the "prompt all" to "prompt each".
Move link detection outside of the print function (which it probably should not have been there anyway) and perform the link detection during preprocessing.

The simulate function is renamed to preprocess.

Add a tree cache structure for building a distinct list of tree paths.
I may very likely need to sort this somehow.

The tree caching allows for dynamically building the tree list and allowing for the tree removal during a post process step.

I am trying to avoid excessive pre-processing loops.
I am currently thinking that the simulate can still handle the processing without a pre-process loop that organizes everything before the simulate.
There will need to be some sort of logic added to detect and ignore already deleted paths in cases where the same path appears multiple times.

Progress: Continue working on completing the remove program.

Bring in recent signal change logic from other FLL projects and code.

Start working on the `--tree` parameter.

Other minor improvements.

Update: The threaded signal handler to avoid signal id races.

Apply the same anti-race improvements implemented on the non-threaded signal checker to the threaded signal checker.

Still check for a negative id to prevent the signal message from being printed more than once.

Update: Stand alone build with latest FLL changes.

Progress: Continue working on completing the remove program.

A good portion of the settings loader is simplified.

Swithc to using `fl_path_clean()` instead of `fl_path_canonical()`.
I find the shorter paths more convenient at this time than the full canonical ones.
I may add a custom option in the future that toggles on canonical paths.

Update to the latest signal handling logic.

Progress: Continue working on completing the remove program.

Add fl_path dependency to utilize fl_path_canonical().

Replace project specific array reallocations with FLL array reallocations.

Add missing directory parameter processing.

Update: Use the pre-defined typedef structure style for the main program type.

Make sure that the typedef is defined early for a later defined type.
This allows for circular use of the main, such as with callbacks.

This is being done across all of my programs.

Progress: Continue working on completing the remove program.

Clean up the code a bit and fix some obvious mistakes.
Problems with the parameters are now fixed.

Start organizing and fixing the simulate.
Added some strings that may or may not be needed and will be removed if the future if it turns out they are not needed.

Add and use the process_operate_file_simulate() function.
The process_operate_file() shouldn't be called within simulate.

Do some work regarding directories and the empty state.

Additional flags are added.
Add flag bits to designate that if the remove flag bit is set then it should be ignored.
It is ignored as do not remove or it is ignored as do not remove then throw an error.
Using a bit like this allows for the rest of the code to only care about when it should add the remove flag.
Only in cases that explicitly prevent removal should the remove not and remove fail flags be set.

Progress: Resume work on completing the remove program.

This may be simpler to complete than TacocaT.
Make a few improvements while reviewing the state of the code and trying to remember where to resume development.

I should try to wrap up the simulate function entirely as the starting point.

Cleanup: Remove kt_remove_parameter_isolate_e commented out code.

The isolate parameter is not supported and is not planned to be supported.
One of the reasons why I decided to write this remove program is because I observed odd bugs with the rm and rmdir programs in a chroot environment when compiling Kevux.
The `/proc` might not be mounted and the remove commands fail.
Adding support for `/proc` adds more code that requires special user-space paths to exist.
This is not an unideal situations.

I've decided to not support the `-i`/`--isolate` command because of this reason and because not implementing this simplifies the code.

Update: Refresh the stand alone builds following the FLL 0.7.0 development release.

Update: Add android build support.

Update: To include the new FSS Read private file.

Cleanup: Move defines-threadless below defines-thread.

Update: With the latest 0.7.x time code and other changes.

Progress: Resume working on the remove program and some parts of the tacocat.

Update: Project structure, dependencies, and add stand alone builds.

Update the project structure so that it directly matches the standard install path.
This makes the stand alone builds easier to build.

Clean up the settings and fakefiles.

Fix problems with the dependency files.

The config.h files are not yet configured.

Update: Project structure with latest practices and improve header file define wrappers.

The ifdef wrappers used for each header file is updated to be more accurate in regards to the directory and file path structure.

Cleanup: Build settings and fakefile mode related settings and documentation.

Cleanup: Restructure project using the program sub-directory.

Bugfix: Utilize the newly defined "stage" setting to allow for the fakefile to build all projects.

Refactor: Change bit-wise enumerations into defines.

I did some reviewing of how the enumerations used for flags are used.
These generally are not being used as a type.
An enumeration slightly increases the resulting binary size.
Enumeration values might be limited to just type of int.

This seems like an easy (small) optimization to just use defines rather than enumerations for flags and other bit-wise numbers.

Cleanup: Remove extra space.

Update: Remove the ++first and ++last parameters and relating logic.

Update: The documentation.

Update: Add central fakefile for building all projects.

Cleanup: Improve fakefile help using the bracketed IKI syntax.

Cleanup: Fix tabbing.

Update: Remove the ++first and ++last parameters and relating logic.

I have used this for a while and have decided these are not worth the effort.
The addition is very nice but the additional code and logic is just extra maintenance and complexity for very little gain.

Bugfix: Add _GNU_SOURCE to silence strptime() warnings under some glibc systems.

Update: The f_string_range_t is now f_range_t.

Update: Add new parameters to fll_program_print_copyright().

Update: Remove -D_FORTIFY_SOURCE because several systems automatically add this and the screen is spammed with warnings.

Progress: Further work in TacocaT.

I've decided to shift focus on the controller program migration.
This still needs a lot of work regarding packet parts.

Checksum and encryption are also needed (via third-party libraries).

Progress: Further work in TacocaT, updating "salt" and "time" packet headers.

The "salt" header is now in the FLL project.
Remove the "salt" string definition from this project.

The packet send now utilizes the "time" header via the standard UTC time.
This is for informative purposes rather than for any accurancy.
Which means that the lack of microseconds or nanoseconds is acceptable.

Feature: Use the newly added f_random_array_shuffle() in tacocat.

The send() packet now automatically randomizes the header structure using f_random_array_shuffle().

Update: The payload header structures based on recent development changes.

The f_fss_payload_header_state_t and f_fss_payload_header_internal_t should instead be fl_fss_payload_header_state_t and fl_fss_payload_header_internal_t.

Update: The string map to use "key" rather than "name".

This changes the code to be in line with the latest refactoring in the FLL project 0.7.x.

Cleanup: The OSLv1 license, fixing grammar and clarifying intent.

This does not change the license other than fixing grammar and making the intent more consistent and clear.

This also adds a day to the license data that represents that last time this license has been modified.
The version number is changed only when there is a functional or substantial change to the license.

I have noticed that in some places individuals decide the "includes" is a restrictive word.
It is not, especially given that it is literally an inclusive word.
This changes the wording from "includes" or "including" to something like "including but not limited to" avoid any of that non-sense.
The proper application of the English language would result in the "but not limited to" being redundant and pointless.
This specific language is added just in case somebody does not understand the English language when it comes to the word "including".

Try to be consistent and use "lawful" instead of "legal" (except in cases where both are mentioned).

Generally, referring to "lawful" here also includes "legal".
The "lawful" is chosen to represent actual law rather than the more questionable "legal"  terminology.

The wording of "access to use, implement, etc.." can be misinterpreted such that the "access to" is applied to implement (and etc..) such that it becomes "access to implement".
The actual intent and design is not simply around "access to implement".
Instead, it is around "to implement", period.
Clarify this by splitting out "access to use" into "to access", "to use", etc...

Update: Add missing snippet from OSLv1 license (also fix file naming).

This piece of the license appears to have been lost somehow and is now added back.

The license file should have the '-or-later' in the name.

Update: Disable -fstrict-flex-arrays=3 flag because it doesn't work on GCC 11.

I just did tests on GCC 11, which is not too old.
The -fstrict-flex-arrays flag does not work there.
For now, just disable the flag by setting it to the non-existent gcc_13 mode.
The mode can be added to the mode list and enabled if so desired.
I may make version specific modes available in the future (or not) but that will require some planning.
The fakefile should be designed to test the GCC version, but I would rather avoid such logic by design.
Let the distributor or the system administrator handle such decisions.

Update: Add additional flag -Wno-missing-braces.

Update: Build settings to be consistent with latest build settings changes.

Progress: Pull in recent changes and practices from the latest 0.7 development branch.

Progress: Pull in recent changes from the latest 0.7 development branch.

Progress: Further work in TacocaT.

This strongly moves in the direction of setting up sending and receiving the different packets.
This includes handling of multiple packet parts.

None of this is ready yet, but progress is being made.
There is currently a strong focus on getting the FSS Payload processing code wrapped up, working, and tested.

Progress: Further work in TacocaT.

Start making room for handling the additional package parts, error packets, and all other packets.

Clean up some of the documentation and add tacocat package specific documentation.

Progress: Further work in TacocaT.

Implements the processing of the Header.

Progress: Further work in TacocaT.

Begin processing header.

Progress: Further work in TacocaT.

The payload is now the only thing that gets written.

The next things to do are to:
- Process the headers and possibly the signatures.
- Go through a lot of the error cases and make sure they are handled.
- Address all of the todo and fixme comments.
- Consider supporting encryption and including optional third-party libraries to perform such tasks.

Progress: Further work in TacocaT.

I previously just jammed on a random seed based on time as a quick short term solution.

I created an f_random FLL project to provide some basic random entropy processing code.

This change set focuses on utilizing these to get set the random entropy.

The setup of the seed is set to non-blocking with a single delayed retry if blocked.
On failure, this still falls back to the time() based setup.
The fallback also must be cast t an unsigned int rather than a long.

Progress: Further work in TacocaT.

I have confirmed that the send and receive to/from tacocat works.
This does send and receive with the current code but the written data writes the entire packet rather than just the payload.
This behavior will change.

This begins changing the design to make the receive consistent with some design differences from the send.
The received packet needs to be processed using the appropriate FSS functions.
Much of this is commented out next to where the work needs to be done.

Progress: Further work in TacocaT.

Build the entire packet now in one buffer.

Fix some mistakes in the packet too-small/too-large status codes.

Change the send packets are built.

Setup the random seed and add a proof of concept salt header.

Progress: Further work in TacocaT.

The F_pipe is being returned on socket write calls because the socket.address.inet4.sin_family (and probably the socket.address.inet4.sin_family) is not being set.

The kt_tacocat_socket_flag_send_connect_e is not needed and is now removed.

Use f_socket_close_fast_e in f_socket_disconnect().

Pass f_socket_flag_signal_not_e as a flag to f_socket_write_stream() so that a signal is not received if f_socket_write_stream() returns F_pipe.

Progress: Further work in TacocaT.

Get the current state of the project in sync with the recent f_socket_connect() changes.

Currently, the send is failing on f_socket_write_stream() due to code 414 (F_pipe).
This is the next point of investigation.

Progress: Further work in TacocaT.

I need to resume the send logic but first I needed to make these minor fixes.

Progress: Further work in TacocaT.

While working on testing, cleaning up, and finish the code I stopped to make changes to the networking code.
This is the random state the code ended up being in while I adjusted focus.

I will have to resume here and figure out what I was last doing before my adjusted focus happened.

Progress: Further work in TacocaT.

The socket id and id_data descriptors need to be initialized to -1 and not 0.
Make sure they are setup after allocation and after processing (or after disconnect).

Provide more verbose error reporting that reports the particular block step the send fails on.
The receive is not yet updated to do the same but in the future it should be updated to do so.

Progress: Further work in TacocaT.

The send f_socket_write_stream() is failing.
Probably due to some incomplete step.

Take advantage of this and implement the retry logic and error handling.

Progress: Further work in TacocaT.

Finish updating the primary structure in kt_tacocat_send_process().
The next thing to do is to test and figure out what is incomplete or broken.
After that, the next thing to do is to address the existing todo's and perform appropriate clean ups.

Progress: Further work in TacocaT.

Progress: Further work in TacocaT.

Progress: Further work in TacocaT.

Progress: Further work in TacocaT, adding initial code regarding sending.

Progress: Further work in TacocaT.

Minor fixes, removing some todos and fixmes.
Add some message printing.

Progress: Further work in TacocaT and in particular update kt_tacocat_socket_set_t structure.

Restructure the kt_tacocat_socket_set_t to reduce the number of arrays.
I originally had the structure for f_polls_t.
I then got lazy and kept using the same array structure for everything.
Fix the array structure of kt_tacocat_socket_set_t and provide kt_tacocat_socket_sets_t.

The buffer string intended for a generic cache is move into the kt_tacocat_cache_t.
I am not sure if this is even being used and so this buffer string cache may be removed in the future if I fail to find a use for it.

Begin setting up the custom file name variable to resolve the fixme.
Also make preparations for only opening the file on poll and read operations.
Then close the file when done.
This keeps files from being held open for no reason.