]> Kevux Git Server - fll/commitdiff
Update: always ensure standard file descriptors are closed on program exit.
authorKevin Day <thekevinday@gmail.com>
Sun, 13 Dec 2020 21:01:33 +0000 (15:01 -0600)
committerKevin Day <thekevinday@gmail.com>
Sun, 13 Dec 2020 21:06:07 +0000 (15:06 -0600)
Explicitly close file descritpros on exit.
This is especially important now that the program could be a child process and the file descriptor could be open between a parent process.

36 files changed:
level_3/byte_dump/c/main.c
level_3/control/c/control.h
level_3/control/c/main.c
level_3/controller/c/main.c
level_3/fake/c/main.c
level_3/firewall/c/firewall.h
level_3/fss_basic_list_read/c/fss_basic_list_read.h
level_3/fss_basic_list_read/c/main.c
level_3/fss_basic_list_write/c/fss_basic_list_write.h
level_3/fss_basic_list_write/c/main.c
level_3/fss_basic_read/c/fss_basic_read.h
level_3/fss_basic_read/c/main.c
level_3/fss_basic_write/c/fss_basic_write.h
level_3/fss_basic_write/c/main.c
level_3/fss_embedded_list_read/c/fss_embedded_list_read.h
level_3/fss_embedded_list_read/c/main.c
level_3/fss_embedded_list_write/c/fss_embedded_list_write.h
level_3/fss_embedded_list_write/c/main.c
level_3/fss_extended_list_read/c/fss_extended_list_read.h
level_3/fss_extended_list_read/c/main.c
level_3/fss_extended_list_write/c/fss_extended_list_write.h
level_3/fss_extended_list_write/c/main.c
level_3/fss_extended_read/c/fss_extended_read.h
level_3/fss_extended_read/c/main.c
level_3/fss_extended_write/c/fss_extended_write.h
level_3/fss_extended_write/c/main.c
level_3/fss_status_code/c/fss_status_code.h
level_3/fss_status_code/c/main.c
level_3/iki_read/c/iki_read.h
level_3/iki_read/c/main.c
level_3/iki_write/c/iki_write.h
level_3/iki_write/c/main.c
level_3/init/c/init.h
level_3/init/c/main.c
level_3/status_code/c/main.c
level_3/status_code/c/status_code.h

index 9a955d2b35e95ec6ca87a524f3a36cf9fbd70383..171442274be3306e8b73362426f2b4108c35acea 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(byte_dump_main(arguments, &data))) {
+  const f_status_t status = byte_dump_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index 0be02a656d1e384dca729b95c8926212f21e95c9..031111173f75b87692540ddcf9d549a5d35e17d0 100644 (file)
@@ -13,6 +13,7 @@
 #ifndef _control_h
 
 // libc includes
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index 27593416ca31abd800a1e0e0dc3511d59e705a7e..b0da32a9524faced014ed48d348c47b818f6a6df 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(control_main(arguments, &data))) {
+  const f_status_t status = control_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index 653a1e4028e1e42306039349dece48277d887110..d9cde60ea61600af07173eaf3353089cade05812 100644 (file)
@@ -10,7 +10,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
 
   data.pid = getpid();
 
-  if (F_status_is_error(controller_main(arguments, &data))) {
+  const f_status_t status = controller_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index 5d612b00b0b6f78c654f62f665d10bd06f368b1b..bf9a47ed4b4bfbba551e7fdb867b1a504bf0d0c9 100644 (file)
@@ -45,6 +45,11 @@ int main(const unsigned long argc, const f_string_t *argv) {
 
   f_signal_close(&data.signal);
 
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
   if (F_status_is_error(status)) {
     return 1;
   }
index 40797fbf56f0f22969f395b6bc1ab89821b3192c..51b5a13e7c8db3a77394545d4f6ecf6318740450 100644 (file)
@@ -15,6 +15,7 @@
 #include <dirent.h>
 #include <stdio.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index 2925fa58f0a946b7190593f9ae498a6ebf16d3be..7ce5951f542bdb5c4a749dbfa98059c0a102b28f 100644 (file)
@@ -18,6 +18,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index 8bc7bb7c8c143dfb3c3bd1d4a6e890991ee27489..c7119c89e240a65c123f84286e737c81b0d7bc49 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(fss_basic_list_read_main(arguments, &data))) {
+  const f_status_t status = fss_basic_list_read_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index c3cf3d2b4f79236d8f895859eda5516e4e2549b4..091c45282b8c53a931094161c8a0005fb6145b68 100644 (file)
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index d7b0ee0cdafe50d6fb7000483e2aa2bc4c96011e..8821ae6ca45c770ed8b19bbc3f28ef28e1e51293 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(fss_basic_list_write_main(arguments, &data))) {
+  const f_status_t status = fss_basic_list_write_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index 8613c14939415f268c1d0f9ff739357e363d844c..c473b13e815d55904d4fd755f64976bf0b1acc78 100644 (file)
@@ -18,6 +18,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index 8c53a8c3a4e9a7c3839451a2aa7fa7e110a8d918..525f9a868628148f354a413dcc09341a75a189de 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(fss_basic_read_main(arguments, &data))) {
+  const f_status_t status = fss_basic_read_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index 137a743cb32f2550912e264b3914c6be5f803c90..086d6ff804ca99c83982f90a25459a9510269259 100644 (file)
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index 8a52fc72f2df404c3cf8dfaa132552b4e3a05d43..3e3b56b271341e225e1438018401247fc11db296 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(fss_basic_write_main(arguments, &data))) {
+  const f_status_t status = fss_basic_write_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index 255c83d2c01e9b77423cf40bc5f61798871f8a90..09a09da55524e450225855c7b66484729f0d8816 100644 (file)
@@ -18,6 +18,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index 904d21f2480c88d3ffdbff6f7f3994ab4937da47..7cd347c709e3aa7ac820593cdd2430bd3fc9daea 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(fss_embedded_list_read_main(arguments, &data))) {
+  const f_status_t status = fss_embedded_list_read_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index c3df671461955eaef3d6fe5a7b5a2bda2ceebaf6..9e573889638845eaa3ea7448430d438e13ce666d 100644 (file)
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index 7db7189817691ccce9d6f4b845c1a5fb07bc841d..d194dfba040f740de8b1eb93be195b9ccc8f2167 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(fss_embedded_list_write_main(arguments, &data))) {
+  const f_status_t status = fss_embedded_list_write_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index 71a87713b90e6c9cc512cb21813c41f3caf498dd..62f9d89b9f3236f832f6e5e20c9d8e7bdf5c9782 100644 (file)
@@ -18,6 +18,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index a53a2496f822170d5087a6f32d967f2cc981f75f..c1d03831f532f3cddf4df1763eaf21ad0a11831d 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(fss_extended_list_read_main(arguments, &data))) {
+  const f_status_t status = fss_extended_list_read_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index 791f2254f97e4ff81b23ebd5b3732d36fb78ce42..fc4151b2b44b0af05af6367997094072358fb0c1 100644 (file)
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index 2360d4d2c933d86421a4640495914cc459ddb26e..d543498b19f2b4aa7d874bb9c4f877a533a722bb 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(fss_extended_list_write_main(arguments, &data))) {
+  const f_status_t status = fss_extended_list_write_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index ab106beecf2433695f37f1c84bb588f31b7bbee5..61263503a8f6500fa50b1d047c21947e9916e939 100644 (file)
@@ -18,6 +18,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index d1a3e10fb1097a603bcefdeccd99609852bdc0f4..d9c3ea902da15e57e35acfefa95a7a2394be73ec 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(fss_extended_read_main(arguments, &data))) {
+  const f_status_t status = fss_extended_read_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index 2f674fc6e5686861acef104e31e2af1eb514a65a..9b94f5d32d86dbe0836d55c78d5bd899782944d8 100644 (file)
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index 5f78046cd29cc0e799f302236c8697ec7b609586..4eee1d6c90308812c5af64a7a0b67168801b5cef 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(fss_extended_write_main(arguments, &data))) {
+  const f_status_t status = fss_extended_write_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index c3dccd560264e9703d5cd92eb80944d273ef1491..20af5677e0ed9f13cf8bf8c2ed6c036adcc536f5 100644 (file)
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index 765f96f5d53aaebe2c70321f020b225864ad8896..a668c81ee186290e656ec22ee926e45b4c8bf890 100644 (file)
@@ -10,6 +10,11 @@ int main(const unsigned long argc, const f_string_t *argv) {
 
   const f_status_t status = fss_status_code_main(arguments, &data);
 
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
   if (F_status_is_error(status) || status == F_false) {
     return 1;
   }
index bdde2b85868a293eb7039764b1bfc1db3712304e..23c1a9eda9ad48cfb01005b295492b01668feb74 100644 (file)
@@ -19,6 +19,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index d0c40933ec1de369040255540c08ef8e4b4339e3..0a7f6b4dbac39d8a2a4785e08bb00a2640fdf895 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(iki_read_main(arguments, &data))) {
+  const f_status_t status = iki_read_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index 9d371fb3ad97b5565d4aa63ed81ccbdb9b0c48b8..1bddce4bf9f09428ea1381578fc90fe1baa76991 100644 (file)
@@ -19,6 +19,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index f86f945ec8c80a0977ca3bcd40fce72e2dc365db..08a68b7c48a731db6272aee2c3f2eb07282709cc 100644 (file)
@@ -8,7 +8,14 @@ int main(const unsigned long argc, const f_string_t *argv) {
     data.process_pipe = F_true;
   }
 
-  if (F_status_is_error(iki_write_main(arguments, &data))) {
+  const f_status_t status = iki_write_main(arguments, &data);
+
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
+  if (F_status_is_error(status)) {
     return 1;
   }
 
index f28bf2dbe51f17c8e74fb06b594769d8dc93d9d4..84979cb23cdc532acde519eee09d135ac22834c8 100644 (file)
@@ -20,6 +20,7 @@
 
 // libc includes
 #include <sys/mount.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>
index e6fe0306b228cf70d90a58b746db0fd0cfe93533..cd1282bdb81e1c0683a4d1d335a1ae90f07de4df 100644 (file)
@@ -3,7 +3,6 @@
 int main(const unsigned long argc, const f_string_t *argv) {
   const f_console_arguments_t arguments = { argc, argv };
   init_data_t data = init_data_initialize;
-  f_status_t status = F_none;
 
   f_signal_set_empty(&data.signal.set);
   f_signal_set_add(F_signal_abort, &data.signal.set);
@@ -25,10 +24,15 @@ int main(const unsigned long argc, const f_string_t *argv) {
   // restore umask.
   umask(data.umask);
 
-  status = init_main(arguments, &data);
+  const f_status_t status = init_main(arguments, &data);
 
   f_signal_close(&data.signal);
 
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
   if (F_status_is_error(status)) {
     return 1;
   }
index 19775d18d05e898fbb98cf471c76535b6f4903f4..1126a88823eb40b9dd7b98d20245d7bcdecf69c6 100644 (file)
@@ -10,6 +10,11 @@ int main(const unsigned long argc, const f_string_t *argv) {
 
   const f_status_t status = status_code_main(arguments, &data);
 
+  // close all open file descriptors.
+  close(f_type_descriptor_output);
+  close(f_type_descriptor_input);
+  close(f_type_descriptor_error);
+
   if (F_status_is_error(status) || status == F_false) {
     return 1;
   }
index 7d146541e39afdd3c5a6f2d10011301de154f16d..ab1222507ee0094b24a10febd7839e2b02852539 100644 (file)
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 // fll-0 includes
 #include <level_0/type.h>