Update: redesign error codes

This is a major rewrite of the error code system.

Previously, the error system did the following:
- used an unsigned short data type
- allowed for all 16 bits to be used
- because it was unsigned short, different architectures might have different size.
- it is rather inefficient and ugly to check for errors when there may be as many as 30 different error codes to compare against.

The new error system does the following:
- enforce exactly 16-bit unsigned integer by using uint16_t.
- reserves the first two high order bits in the following manner:
  - bit 1 = error bit (1000 0000 0000 0000)
  - bit 2 = warning bit (0100 0000 0000 0000)
  - (note setting both bit 1 and bit 2 is unsupported)
- provide a series of macros to quickly detect and manage the new bits
- limits the total available number of error codes to 14-bits instead of 16-bits

The advantage of the new system is that what the status code is can be detected in one or two conditionals (using bitwise operations).
This should speed up performance and make the code easier to read.

Update: add the new default/example firewall setting files

I forgot to add this with one of the previous commits.
This is the rewrite of the setting rules using custom chains.
This also utilizes the newly added protocol support.

Feature: add support for 'protocol' option

The protocol option adds support for mass adding things like '-p tcp' in front of every rule.
This reduces repetition of the -p * commands.

The 'protocol' option accepts any single parameter or the reserved parameter 'none'.
Using 'none' will turn off the protocol option.
Other than 'none', this poses no restrictions on what the protocol may be.
Instead, that is left to iptables.

Update: rewrite firewall, adding support for custom chains

This is a major redesign of the firewall program.
Iptables chains are now supported automatically.
Each new basic list is itself a chain.
Reserved words not allowed for custom chains are:
- main
- stop
- lock

The 'main' chain signifies use of the default iptables chain.

The layout and structure of the files have been rewritten to utilize chains.
The default-firewall file has been removed and replaced with the following files:
- firewall-first
- firewall-last
- firewall-other

The newly written rules defines default firewall rules and chains such that there the following self-explanatory chains:
- input-tcp
- input-udp
- input-icmp
- output-tcp
- output-udp
- output-firewall

In addition to the above changes, the base functionality has been broken up into smaller functions to improve code quality.

Update: add support for array_length arrays

Because this uses memory operations it was moved to a separate file called types_arrays.h
This adds a dependency on f_memory.
While the dependency is circular, f_types will never provide source files.
Therefore chicken and the egg issues should not be a problem (f_types is always installed before f_memory).

Bugfix: fix invalid f_string_lengths initializer

This should initialize to 0 and not the f_string_length_initializer because it is a pointer.

Update: add file position reset macro

Define a macro because creating a function is just overkill for this.
This macro should save a few lines of code when reseting the file position.

Bugfix: reset position on back to back lists

If two lists are back to back such that one does not have content, then make sure that the position resets to the start.
If this does not happen, then the next object will be skipped.

Update: remove used vs size parameter checking

Remove this so that non-dynamic strings can be placed in a dynamic string data type.
In such cases, the dynamic string has a used but not a size.
This means allocations should not be performed on the string.

Cleanup: Move private functions into its own source and header files

It has become painfully apparent that much of the firewall main function needs to be broken down into smaller functions for managability and readability purposes.
The first step in doing such is to create a privte header and source files and move all internal functions there.
Everything in the private-* files are intended to never be exposed in the library.
Its only purpose is to make programming large projects more managable and readable.
As such, none of the functions should ever be considered part of the libraries/programs api.

Bugfix: use proper if then logic in firewall

Some of the if then else statements where not properly nested.
As a result, valid list objects got skipped.

Cleanup: remove stale TODO comment in firewall

The TODO is already done.

Bugfix: remove invalid counter code from firewall

The counter2 was being used when it should not have been.

Update: add support for custom user chains

Users should now be able to add their own custom chains.
Chains can be created by creating a new fss object that is not one of the following: first, last, stop, lock, or main.

Bugfix: fix problems with #defines

Remove an unusued/redundant define.
Use correct size length for some string length defines.

Update: redesign parameters for fss write functions  to be more consistent with fss read functions

The fss read functions all take -o or --object to signify that an object is being processed.
Do the same with the write functions.

Bugfix: set stop point to before a valid close quote, not after

The following reproduces the error:
- fss_basic_write -t object -s 'Hell o\' | fss_basic_read -o
Should produce the original string, but instead included the double quote used to signify object close.

Update: rework delimit management to ensure delimits are only applied when valid.

This unfortunately increases the complexity slightly as deallocation must occur before functions exist.
On the other hand doing so avoids overly complicated loops that would probably make the code less readable.

Bugfix: be sure to delimit trailing \ if it is an the end of a quoted content

What happens is that if the content is (ignore single quotes): 'hell o\'.
The fss extended content conversion should be (include double quotes): "hell o\\".
The code must realize that the last \ is a would end up before a quote, or one would get: "hell o\".
That content string would then be classified as an unterminated group.

Update: add level 3 fss * write projects

Bugfix: Do not de-allocate the additional array

Do not de-allocate this array when some allocation error happens.
The data is defined outside of this function, so leave it to the caller to handle deallocation.
This allows for giving the caller more choices when trying to decided what to do on allocation problem.
For example, some program may want to try to continue anyway even if there is an allocation problem.
It will be tricky, but in such a case one would just have to make do with what is already allocated.

Update: add support for repeated parameters

Thus, something like my_function -s 0 -s 1 would be able to process both -s 0 and -s 1.
Previously, only the last -s option would have been processed.

Bugfix: checking for == on fwrite size results is not an error

The code was checking the total number of bytes written and the total number expected to be written.
If both numbers are the same, then this cannot be an error.

Update: add write append macro

This was missing.

Update: add file write support

The write functions are little more than wrappers to fwrite().

Bugfix: fix positioning output of help system

Update: add fll fss object and content write support

This adds the functions that allow for writing fss objects and contents.

Bugfix: test for eol during object write

If this is not done, then close quotes could end up being placed after a newline character.

Update: add additional error testing macro groups

This adds additional error testing macro groups that are common.

Update: implement fl basic list object and content write support

This adds the fss basic list object and content write functions.

Cleanup: only define location variable when needed

Instead of defining it outside the loop, define it inside the loop and then only in the areas where it is needed.

Update: rewrite basic list object and content read functions

Follow the new approach.
Also, it occured to me that there is no reason to support quoted object names for a basic list.

The reasoning behind this is that the basic list object always terminates on a newline and there cannot be any content on that newline.
If there is no content, then there is no reason to protect the object by wrapping it in quotes as done in basic an extended.
Quote support has been removed and as a result the implementation of the object and content reads are much simpler.

Update: return stop points even when no object/content is found

This makes a things a little more consistent.
If an object was not found, then the code would seek to the end of line or a stop point.
Prior to this patch, after doing the sleep, the appropriate object/content not found is returned when a stop point was reached.
Now, the appropriate no_data or none stop point return value is used in such a case.

Bugfix: fix return state codes for stop point

For objects, if an object was not found and a stop point was reached, return approproate f_no_data codes.
For objects and content, if a stop state was reached during a quoted group, return appropriate f_unterminated_group codes.
For objects and content, if a stop state was reached during a valid pass, return appropriate f_none codes.

Bugfix: don't write comment lines (wrap the # in quotes)

The object write functions should not write comments.
The comments are not valid objects, so if passed a leading #, then be sure to wrap it in quotes.

Update: rewrite fss extended content read function

This was rewritten to follow the same style that the object read uses.
Because content can have multiple "groups", an outer loop had to be added.
For some reason I feel like I am forgetting something or doing something wrong here, but I cannot tell what that is and so I note my concern here.

Update: use f_array_length for an array of locations instead of f_string_length

Cleanup: Use the parameter names for the fl fss write functions

After review, I think this naming scheme makes more sense.

Bugfix: initial slash + quote only needs one additional slash on match at start when writing

If the object or content group begins with any number of slashes followed by a single or double quite, only a single slash is needed to delimit the quote.
This is done because no valid object or content group can start with a slash and expected to be treated as if it were quoted.
That means the quote is meaningless.
The initial slash delimit is necessary in case the object name starts with a single or double quote but it should not be treated as such.
This for an object name of " would be written as \".

Update: add fl fss extended content write support

Cleanup: rename delimit_slash_count to slash_count

I see no reason to prepend delimit_ to the slash count.
Shrinking it makes things a little easier to read.

Bugfix: delimit whitespaces on write

I believe I had a mental lapse on this one.
The previous code was acting like a read operation in certain cases when dealing with whitespace.
When doing a write if a white space exists treat don't ignore it; instead, wrap it in quotes so that object names can contain spaces.
For example " " is a valid object name which is a object whose name is a single space.

Cleanup: update error code header documentation

Bugfix: don't forget to return f_none_on_eos and f_none_on_stop where applicable

Bugfix: remove default from switch to avoid returning f_unknown

While it is good practice to always have a default: in switch, I believe this is a case where it is not.
Do not provide a default switch so that the default return statement is always false.
This prevents having to return f_unknown at the end of the function as it is now possible to get to the end of the function.

Update: add eol return codes

Update: handle eol when doing writes

If the buffer being read from contains an eol, then do not process any further.
This prevents writing newlines without ignoring them entirely.
This returns f_none_on_eol, which does not exist yet.
A commit following this one will add the eol return codes.

Bugfix: add buffer overflow checks

When I added the input parameter to the write functions I forgot to do buffer size checks now that the input size could be different than the buffer size.

Cleanup: remove fss_basic.h include

This is not needed here, so do not include it.

Update: add fss extended object write function

This is identical to the fss basic object write function.

Update: rewrite the basic and extended read functions

This should hopefully fix some slash delimiting weirdness I thought I was seeing.

Update: rework the basic write to accept a string location argument

This should make things more consistent with how the basic read functions work.

Cleanup: Remove () from while comment

The end of a while loop comment will no longer have open close parenthesis.

Thus:
  while (f_true) {
    // ..
  } // while()

Now becomes:
  while (f_true) {
    // ..
  } // while

Cleanup: add space between while(

Fix syntax style to have a space after while and before (.

Cleanup: put space between do{

Fix the syntax style to have a space between do and {.

Cleanup: put a space between switch(

Fix syntax style mistake where switch( did not have a space after switch and before (.

Cleanup: mass change ){ into ) {

I have decided that the syntax style should have a space between ){ from now on.
I did this change in mass via a sed script.
I did not notice any incorrect changes, but there is more to review than I am willing to review.

Bugfix: process quotes at the start of a basic object

This was overlooked.
If the first character is a single quote or a double quote, then it must be delimited.
If the first character is a slash, followed by any number of slashes and then followed by a single or double quote, then all slashes and the quote must be delimited.
Starting slashed that are not followed by a single or double quote must not be delimited.

Update: add write support for fss basic

This adds the write functions for converting a dynamic string that represents an fss basic object into a valid object.
This adds the write functions for converting a dynamic string that represents an fss basic content into a valid content.

Update: use the error code source name instead of a human friendly name for error code translation

The human friendly variant is more convenient, but it is probably better to use the machien name directly on error output.
This should make things script-friendly and also allow for distinguishing something simimarl to f_my_error and fl_my_error.
With f_my_error and fl_my_error, using the previous method, both would report as "my error", when in fact they are different errors.

The down side is that this now requires 1 more step to convert the codes into a human friendly name.

Cleanup: remove useless code

I was considering to use status to return true or false, but later changed my mind.
There was a line of code where I was initialize status, this code is no longer needed.

Bugfix: correct linkage agains fll_execute

The fll_execute used to be fl_execute, when it was changed the projects that depended on it did not get changed.
This updates the build settings to link to the proper library.

Bugfix: use proper parameter data type

f_array_length should be used and was not being used.

Update: rename *error_code projects to *return_code

This should make the applications make a little more sense.
That is, when testing for not-error codes, it makes more sense to say not-error return codes than to say not-error error codes.

Update: add support for identifying errors, warnings, and okays

Add three new parameters: is_okay, is_warning, and is_error.
These should test to see if the error code is in fact an error, a warning, or not an error.

Update: change return codes enum to start at 131

This should makes things sort of compatible with bash shell scripts.
Bash limits its return states to 255, so the fss return codes may still not always function..
This at least allows for some sort of compatibility.

Cleanup: don't use f_console_standard for stuff outside of f_console

This was probably a copy and paste accident where the define names were not properly updated.

Add Package: firewall

This package was missed during the conversion from svn to git.

Update: add support for building settings data

The settings data (which is different from the build settings data) is now supported.
This is data that goes in /etc/ or /share/.

Update: do not provide a default pipe argument afterall

Now that I have learned how to read pipes, this usage parameter that I guessed about is not needed.

Add Package: fss_error_code

This is the handles translating fss-specific error codes to strings.

Add Project: error_code

This is a cli front end for the error code to string translation.
This only translates standard error codes.

Update: process f_unknown

In an ironic twist, the f_unknown error code was no translated into a string.

Update: return the literal error code

The error code was being converted into 0 if the code was f_none.
Stop doing this behavior, all the scripts need to be fll return state aware from this point forward.

Bugfix: set error code to invalid parameter when parameters are missing

Bugfix: include library build directory when compiling

Include the local library path so that the built libraries can be pulled in.

Cleanup: update version numbers to 0.3.x (again)

Looks like there have been even more version numbers that were overlooked.

Update: add fss_error level 2 functions

Provide fss-specific error code to string translation.

Add Project: fl_errors

Add the level 1 errors project that provides error code to string translation for standard error codes.

Cleanup: macros in f_errors should be f_errors and not f_error

Be consistent.

Update: add buffer_too_small and buffer_too_large error codes

This could come in handy and is more generic than string_too_small and string_too_large.

Bugfix: fix logic flaws with file input buffers

The first mistake made was that when adding the fread result to the buffer, the actual size of each read byte needs to be taken into mind.
If the characters were wide characters with a byte size of 2 instead of 1, then the buffer->used counter would increase at a rate of 2x of what was actually in use.

The second mistake made was that the fread max read size was being set to the entire buffer size instead of what was available.
This should have been producing some sort of buffer overflow, but none was reported.
Instead of request a read of (buffer->size - 1), only request a size
equal to that of the available allocated space (buffer->size - buffer->used - 1).

The third mistake made was not performing sanity checking on the buffer->used and buffer->size variables.

Bugfix: add missing return statements

The new hidden/internal functions did not have the final return statement.

Cleanup: change version numbers to 0.3.0

The internal version macros were not updated when the fll projects were mass moved to 0.3.x.

Update: add support for accepting pipe values

Data can now be piped to the fss_*_read functions.
To make this practical, this adds and uses a hidden/internal functions.

Update: add support for reading from fifos

In particular, this is used for reading from piped files, namely stdin.

Add Project: pipe

This adds the level 0 implementation of project pipe.
At this time, all it does is provide a way to tell if the current instance of some program has piped data being passed to it.

Update: add all types of file open modes

This also changes f_file_read_write to not create the file if it does not exist.
To create the file if it does not exist, use f_file_read_write_create.

Update: add f_file_stat_error

Update: add pipe console parameter

The fll standard console arguments now inclide +p, ++pipe.
This pipe command requires a single numeric argument that represents the size of the pipe.
When this is specified, it tells the application to read from pipe in byte chunks of the specified size.
The default pipe size is left up to the application when this is not specified.

Cleanup: remove duplicate string.h include

Update: implement fll_execute_program and fix fll_execute_path

This adds fll_execute_program and changes how fll_execute_path works to function properly.
Prior to this change, fll_execute_path did not set the first argument which would cause the programs argv[0] to not be equivalent to the program name.

This also corrects a few mistakes where level_1 syntax and comments were not changed to level_2.

Update: rework and cleanup serialized project

Simplify the serialize functions by:
- replace f_serialized data type with f_dynamic_string
- remove the serialized strategy and change serialized function names to communicate the strategy.

Fixed a few logic flaws and mistakes with the serialized functions.

Bugfix: fix definition of array_length_printf macros

Use ifndef and not ifdef for _di_f_array_length_printf_ because using #ifdef _di_f_array_length_printf_ is completely wrong.
Use #define and not typedef as these are not data types, but instead are strings.

Bugfix: add support for specifying c and bash files paths

Update: change version number in settings file to 0.3.0

The version number in the settings files is the actual version number of the given project.
Assign this value for all projects to 0.3.0.
All micro releases will have their micro number changed immediately prior to officially releasing a given micro version..

Update: rename/move fl_execute into fll_execute

This is done so that it can utilize some level_1 dependencies, such as fl_serialize.

Update: switch to 0.3.x version

This is now the development release series 0.3.x.
The version number for the source files will now end in an x instead of a number to make project management simpler.

Bugfix: -t -n (somename) should show total of (somename) not all objects

This fixes an oversight or logic flaw where the total count was returned in all cases.
When a specific object name is requested, the total count should be the total number of objects that match the given name.

Bugfix: fix the argc argument for the *_read_main() functions

The commit 8fef4128c71a3010d4facf05f0d801118add5f7a changed the argc argument from f_s_int to f_array_length.
The header files were not updated and thus making the header definitions inconsistent.