The Featureless Linux Library stable version 0.6.12 is released.

This release provides some significant polishing, bug fixing, and corrections (or clarifications) to the project, the standards, and the specifications. Much of this work is done to pave the way for forward compatibility with improvements and changes introduced in the 0.7 development branches. I try to avoid making such changes in the specifications for stables releases but I feel these specific changes are merited.

This increases the correctness of the FSS processing code, specifically with the FSS read functions. The previous behavior only cared whether or not the tests produce equivalent results in terms of reading and writing. I back ported the 0.7 runtime tests and found that it would be better to have consistent and correct output in regards to white space. Doing this also exposed several bugs and mistakes in the FSS processing code.

The FSS Embedded Read, in particular, was completely forgotten about by me. The previous releases have been marked stable but I forgot to actually verify the proper functioning of the FSS Embedded Read program. The back porting of the runtime tests exposed significant problems with the FSS Embedded Read program.

The FSS Embedded Read to include the back ported fixes from the 0.7 development branch:

  • The use of f_memory_array_increase() is incorrect in several cases.
  • Switch to f_memory_array_resize().
  • Add two when resizing to account for the depth position but also an additional element as a minor memory allocation optimization.
  • The --select now also follows the more strict behavior as implemented in the 0.7 branch.
  • The --total to match the more strict behavior as implemented in the 0.7 branch.

The FSS Embedded Read has the following additional notable fixes thanks to the runtime tests:

  • Security issue regarding incorrect memset value (passed sizeof(skip) when instead sizeof(bool) should be used).
  • The --line parameter is not being correctly validated and throws an error when a value is specified.
  • Fix a bug where empty Content is being improperly handled and } is being returned as the Content for empty Content.
  • The --select is not always printing a number, so make sure a number, even if it is 0, is always printed.
  • The comments are not being properly processed because graph_first is not and should be being set to 0x1 at start, resulting in the first comment is not being treated as a comment.
  • The entire Content is being displayed when --object is used with --line when instead only a single line must be printed.
  • Column counts with empty data are not being correctly handled.
  • Should not display anything when Content is empty and Objects are not being printed.
  • Delimits are not being applied when printing in line mode.
  • Do not double-print the before spaces when both original and trim modes are in use.
  • Print the before even with original and trim are in use when the Object has no size.
  • I had not implemented the --columns support for FSS Embedded Read in prior releases and this is now properly supported.

The FSS-0002 and FSS-0003 standards have some unclear situations regarding the white space before and after a valid Object is now clarified. I discovered problems and realized that the standard could be more clear according to the spaces before and after the Object. This does not change the FSS-0002 and FSS-0003 standards in any functional way. The simply clarifies the standard regarding the spaces to make the specification more clear and reduce the chances for a mistake.

The original print is now better preserved. Printing an Object can now print the before and after Object characters (usually white space). The trimming and original print may be used together to produce the results where there is no white space before or after the Object but everything else from the original source is preserved. This combination of trim and original essentially ensures that the old behavior can be still produced. This does not utilize the closes structure as is done in the 0.7 development branches to ensure API does not get broken. This behavior simulates the white space tabbing and more proper and precise support for this requires at least the 0.7 development branch.

I did some experimentation and found that I could get this project to build and run on an Android environment. I generally do not want OS-specific build files in the core FLL project, but I have made an exception here. This should help build more support for the Android environment and help pave the way for future projects that may help those users unfortunate enough to find themselves in an Android environment. This Android functionality is not well tested nor is it well supported. The Android support has been tested to build using bootstrap.sh and then using fake.

Example build and install process on an Android: 

# mkdir ~/software
# cd fll-0.6.X/
# ./bootstrap.sh build -m monolithic -m thread -m clang -m android && ./install.sh ~/software
# cd ../fake-0.6.X/
# ./bootstrap.sh build -m monolithic -m thread -m clang -m android -w ~/software && ./install.sh ~/software
# export LD_LIBRARY_PATH=~/software/libraries/shared
# export PATH=~/software/programs/shared
# cd ../byte_dump-0.6.X/
# fake -m monolithic -m thread -m clang -m android -w ~/software && ./install.sh ~/software

Example execution of byte_dump of the bash program (this is a large dump). 

# byte_dump -wt 7 $(type -p bash)

The Featureless Make is intended to not be language specific since its inception. I did not know how the languages were to work when I first started this project, and so I mostly built this project to only guarantee C/C++ support.

I recently discovered that the golang supports some command line based compilation. The golang is now supported in the most basic way, but this support is not well tested. Use the example_go project as a point of reference. I have only tested the basic build and I have not done anything more complex than that.

Some of the requirements in the build specification are now relaxed. The bash is changed to shell to encourage more types of scripts. The custom is added and used as a fallback if build_language_path is not used.

I found that there needs to be some additional settings in the settings specification. This updates the specification and adds:

  • build_compiler_arguments
  • build_compiler_arguments_library
  • build_compiler_arguments_library_shared
  • build_compiler_arguments_library_static
  • build_compiler_arguments_object
  • build_compiler_arguments_object_shared
  • build_compiler_arguments_object_static
  • build_compiler_arguments_program
  • build_compiler_arguments_program_shared
  • build_compiler_arguments_program_static
  • build_compiler_arguments_shared
  • build_compiler_arguments_static
  • build_language_path

Some discovered mistakes in the language of the specification are also fixed.

The following are changes since the 0.6.11 stable release.

Exploit Fixes:

  • None.

Security Fixes:

  • FLL: Incorrect memset value (passed sizeof(skip) when instead sizeof(bool) should be used).

Features:

  • FLL: Add support for building under Android.
  • Fake: Fake settings specification updates and enable simple Golang support.

Bug Fixes:

  • FLL: Replace index() with strchr().
  • FSS Read programs: FSS Embedded List Read printing tabbing when using original mode and trim mode.
  • FSS Read programs: Get the FSS Embedded List Read working as expected based on runtime tests.
  • FSS Read programs: FSS Embedded List Read is not applying delimits when printing in line mode.
  • FSS Read programs: Empty Content lines with no Object printed should not be included for FSS Embedded List.
  • FSS Read programs: Incorrect handling of column counts with empty data for FSS Embedded List Read.
  • FSS Read programs: FSS Embedded Read is printing a single line with --line parameter with --object.
  • FSS Read programs: Invalid comment handling in FSS Embedded Read.
  • FSS Read programs: FSS Embedded Read has incomplete and incorrect code.
  • FSS Read programs: FSS Extended Read needs to only print new line if Object or Content is printed.
  • FSS Read programs: FSS Extended Read needs to properly handle --total when using --select and also --empty.
  • FSS Read programs: FSS Basic Read needs to properly handle --total when using --select and also --empty.

Refactors:

  • None.

Regressions:

  • None.

Updates:

  • FLL: The bootstrap example script now handles building using fake.
  • FLL: Improve robustness of the fll_control_group_prepare() function.
  • FLL: The FSS lists (FSS-0002, FSS-0003, FSS-0008, etc..) to match recent specification changes and reduce redundancy.
  • FLL: The FSS Basic List (FSS-0002) to match recent specification changes regading Objects.
  • FLL: The FSS-0002 and FSS-0003 standards, modifying the space after Object rules.
  • FLL: Clarify the FSS-0002 and FSS-0003 standards regarding the white space before and after a valid Object.
  • Controller: Cgroup example controller script example to show running under a SystemD system.
  • Firewall: Refresh firewall iptables rules and relax some of the defaults.
  • FSS Read programs: Implement Object alignment and trim expanding in FSS read programs and restructure the program flags.
  • FSS Read programs: Always count any --select when using --object for FSS read programs.
  • FSS Read programs: Improvements around FSS read functions regarding correctness.
  • FSS Read programs: Back port tests for the FSS read programs with more recent changes.

Check out the project on the FLL release page.

The project is built like a tool chest. Individuals who are unfamiliar with the project should have an easier time trying out the pre-packaged monolithic sources. These programs, by default, are designed to build against a library built using the monolithic source tree.

The stand alone sources for the several programs can be found pre-packaged at Sourceforge.

Kevin Day