I don't like a lot of things about GPGME, so do not enable it by default.
I'm still uncertain how I want to structure the encryption support with gpgme.
I plan on considering other encryption and checksum algorithms/libraries.
For now just create an encrypt send step file.
This is highly subject to change.
This adds a new header called "encrypt" that will explicitly designate the encryption method used.
version_target minor
modes android clang coverage debug fanalyzer flex_arrays gcc gpgme individual individual_thread level monolithic pinephone test thread threadless
-modes_default debug gcc gpgme monolithic thread
+modes_default debug gcc monolithic thread
build_compiler gcc
build_compiler-clang clang
build_sources_headers print/error.h print/message.h print/verbose.h print/warning.h
build_sources_headers packet.h process.h receive.h send.h signal.h tacocat.h thread.h
build_sources_headers receive/step/check.h receive/step/control.h receive/step/done.h receive/step/extract.h receive/step/find.h receive/step/next.h receive/step/packet.h receive/step/write.h
-build_sources_headers send/step/build.h send/step/check.h send/step/done.h send/step/encode.h send/step/file.h send/step/header.h send/step/packet.h send/step/size.h send/step/wait.h
+build_sources_headers send/step/build.h send/step/check.h send/step/done.h send/step/encode.h send/step/encrypt.h send/step/file.h send/step/header.h send/step/packet.h send/step/size.h send/step/wait.h
build_sources_headers-gpgme gpgme.h print/gpgme.h
build_sources_library print/error.c print/message.c print/verbose.c print/warning.c
build_sources_library packet.c process.c receive.c send.c signal.c tacocat.c thread.c
build_sources_library receive/step/check.c receive/step/control.c receive/step/done.c receive/step/extract.c receive/step/find.c receive/step/next.c receive/step/packet.c receive/step/write.c
-build_sources_library send/step/build.c send/step/check.c send/step/done.c send/step/encode.c send/step/file.c send/step/header.c send/step/packet.c send/step/size.c send/step/wait.c
+build_sources_library send/step/build.c send/step/check.c send/step/done.c send/step/encode.c send/step/encrypt.c send/step/file.c send/step/header.c send/step/packet.c send/step/size.c send/step/wait.c
build_sources_library-gpgme gpgme.c print/gpgme.c
#define kt_tacocat_max_buffer_d 0x10000000 // 0x10^0x5 * 0x100 (Which is 256 Megabytes (0x10^0x5 where the base unit is 16 rather than 10 or 2 (maybe call this xytes? Megaxytes?)).
#define kt_tacocat_max_maintain_d 0x100000 // 0x10^5 (Which is 1 Megabyte in base 16 (1 Megaxyte (MX)).
- #define kt_tacocat_packet_headers_d 0x9
+ #define kt_tacocat_packet_headers_d 0xb
#define kt_tacocat_packet_id_length_d 0x20
#define kt_tacocat_packet_minimum_d 0x11
#define kt_tacocat_packet_peek_d 0x40
const f_string_static_t kt_tacocat_classic_s = macro_f_string_static_t_initialize_3(KT_TACOCAT_classic_s, KT_TACOCAT_classic_s_length);
const f_string_static_t kt_tacocat_digit_negative_one_s = macro_f_string_static_t_initialize_3(KT_TACOCAT_digit_negative_one_s, KT_TACOCAT_digit_negative_one_s_length);
const f_string_static_t kt_tacocat_done_s = macro_f_string_static_t_initialize_3(KT_TACOCAT_done_s, KT_TACOCAT_done_s_length);
- const f_string_static_t kt_tacocat_kevux_s = macro_f_string_static_t_initialize_3(KT_TACOCAT_kevux_s, KT_TACOCAT_kevux_s_length);
+ const f_string_static_t kt_tacocat_encrypt_s = macro_f_string_static_t_initialize_3(KT_TACOCAT_encrypt_s, KT_TACOCAT_encrypt_s_length);
const f_string_static_t kt_tacocat_file_s = macro_f_string_static_t_initialize_3(KT_TACOCAT_file_s, KT_TACOCAT_file_s_length);
+ const f_string_static_t kt_tacocat_gpgme_s = macro_f_string_static_t_initialize_3(KT_TACOCAT_gpgme_s, KT_TACOCAT_gpgme_s_length);
+ const f_string_static_t kt_tacocat_kevux_s = macro_f_string_static_t_initialize_3(KT_TACOCAT_kevux_s, KT_TACOCAT_kevux_s_length);
const f_string_static_t kt_tacocat_network_s = macro_f_string_static_t_initialize_3(KT_TACOCAT_network_s, KT_TACOCAT_network_s_length);
const f_string_static_t kt_tacocat_network_or_socket_s = macro_f_string_static_t_initialize_3(KT_TACOCAT_network_or_socket_s, KT_TACOCAT_network_or_socket_s_length);
const f_string_static_t kt_tacocat_next_s = macro_f_string_static_t_initialize_3(KT_TACOCAT_next_s, KT_TACOCAT_next_s_length);
#define KT_TACOCAT_classic_s "classic"
#define KT_TACOCAT_digit_negative_one_s "-1"
#define KT_TACOCAT_done_s "done"
+ #define KT_TACOCAT_encrypt_s "encrypt"
#define KT_TACOCAT_file_s "file"
+ #define KT_TACOCAT_gpgme_s "gpgme"
#define KT_TACOCAT_kevux_s "kevux"
#define KT_TACOCAT_network_s "network"
#define KT_TACOCAT_network_or_socket_s "network / socket"
#define KT_TACOCAT_classic_s_length 7
#define KT_TACOCAT_digit_negative_one_s_length 2
#define KT_TACOCAT_done_s_length 4
+ #define KT_TACOCAT_encrypt_s_length 7
#define KT_TACOCAT_file_s_length 4
+ #define KT_TACOCAT_gpgme_s_length 5
#define KT_TACOCAT_kevux_s_length 5
#define KT_TACOCAT_network_s_length 7
- #define KT_TACOCAT_network_or_socket_s_length 16
+ #define KT_TACOCAT_network_or_socket_s_length 17
#define KT_TACOCAT_next_s_length 4
#define KT_TACOCAT_receive_s_length 7
#define KT_TACOCAT_receive_done_s_length 12
extern const f_string_static_t kt_tacocat_classic_s;
extern const f_string_static_t kt_tacocat_digit_negative_one_s;
extern const f_string_static_t kt_tacocat_done_s;
- extern const f_string_static_t kt_tacocat_kevux_s;
+ extern const f_string_static_t kt_tacocat_encrypt_s;
extern const f_string_static_t kt_tacocat_file_s;
+ extern const f_string_static_t kt_tacocat_gpgme_s;
+ extern const f_string_static_t kt_tacocat_kevux_s;
extern const f_string_static_t kt_tacocat_network_s;
extern const f_string_static_t kt_tacocat_network_or_socket_s;
extern const f_string_static_t kt_tacocat_next_s;
if (!main) return;
fll_program_data_delete(&main->program);
+
kt_tacocat_cache_delete(&main->cache);
kt_tacocat_setting_delete(&main->setting);
+
+ #ifdef _en_gpgme_support_
+ kt_tacocat_gpgme_delete(&main->gpgme);
+ #endif // _en_gpgme_support_
}
#endif // _di_kt_tacocat_main_delete_
if (!gpgme) return;
- gpgme_release(gpgme->control);
-
- // @todo
+ gpgme_release(gpgme->context);
gpgme->version = f_string_empty_s.string;
}
if (array[i].headers.size) {
f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &array[i].headers.array, &array[i].headers.used, &array[i].headers.size, &f_string_maps_delete_callback);
}
+
+ #ifdef _en_gpgme_support_
+ if (array[i].encrypt_read) {
+ gpgme_data_release(array[i].encrypt_read);
+
+ array[i].encrypt_read = 0;
+ }
+
+ if (array[i].encrypt_write) {
+ gpgme_data_release(array[i].encrypt_write);
+
+ array[i].encrypt_write = 0;
+ }
+ #endif // _en_gpgme_support_
} // for
}
*
* - abstruses: The abstruse header map array, used for building the headers when sending a response.
* - headers: The map of the headers after being processed for use when buulding the headers when sending a response.
+ *
+ * - encrypt_read: The encryption payload data, dependent on algorithm, for reading/input.
+ * - encrypt_write: The encryption payload data, dependent on algorithm, for writing/output.
*/
#ifndef _di_kt_tacocat_socket_set_t_
typedef struct {
f_abstruse_maps_t abstruses;
f_string_maps_t headers;
+
+ #ifdef _en_gpgme_support_
+ gpgme_data_t encrypt_read;
+ gpgme_data_t encrypt_write;
+ #else
+ uint8_t encrypt_read;
+ uint8_t encrypt_write;
+ #endif // _en_gpgme_support_
} kt_tacocat_socket_set_t;
#define kt_tacocat_socket_set_t_initialize { \
.write_state = fl_fss_payload_header_state_t_initialize, \
.abstruses = f_abstruse_maps_t_initialize, \
.headers = f_string_maps_t_initialize, \
+ .encrypt_read = 0, \
+ .encrypt_write = 0, \
}
#define macro_kt_tacocat_socket_set_t_initialize_1(size_block_value) { \
.write_state = fl_fss_payload_header_state_t_initialize, \
.abstruses = f_abstruse_maps_t_initialize, \
.headers = f_string_maps_t_initialize, \
+ .encrypt_read = 0, \
+ .encrypt_write = 0, \
}
#define macro_kt_tacocat_socket_set_t_initialize_2(size_block_value, write_state_value) { \
.write_state = write_state_value, \
.abstruses = f_abstruse_maps_t_initialize, \
.headers = f_string_maps_t_initialize, \
+ .encrypt_read = 0, \
+ .encrypt_write = 0, \
}
#endif // _di_kt_tacocat_socket_set_t_
* The GPGME data.
*
* Properties:
- * - control: The GPGME control data.
- * - data: The GPGME regular data.
+ * - context: The GPGME context data.
* - engine: The GPGME engine inforrmation data.
* - error: The GPGME error data.
*
*/
#if defined(_en_gpgme_support_) && !defined(_di_kt_tacocat_gpgme_t_)
typedef struct {
- gpgme_ctx_t control;
- gpgme_data_t data;
+ gpgme_ctx_t context;
gpgme_engine_info_t engine;
gpgme_error_t error;
} kt_tacocat_gpgme_t;
#define kt_tacocat_gpgme_t_initialize { \
- .control = 0, \
- .data = 0, \
+ .context = 0, \
.engine = 0, \
.error = 0, \
.version = f_string_empty_s.string, \
gpgme->version = gpgme_check_version(0);
- gpgme->error = gpgme_new(&gpgme->control);
+ gpgme->error = gpgme_engine_check_version(GPGME_PROTOCOL_OPENPGP);
- if (gpgme->error) {
+ if (gpgme->error != GPG_ERR_NO_ERROR) {
main->setting.state.status = F_status_set_error(F_failure);
kt_tacocat_print_gpgme_error(&main->program.error, F_status_debug_source_d);
return;
}
- gpgme->error = gpgme_engine_check_version(GPGME_PROTOCOL_OPENPGP);
+ gpgme->error = gpgme_get_engine_info(&gpgme->engine);
- if (gpgme->error) {
+ if (gpgme->error != GPG_ERR_NO_ERROR) {
main->setting.state.status = F_status_set_error(F_failure);
kt_tacocat_print_gpgme_error(&main->program.error, F_status_debug_source_d);
return;
}
+ gpgme->error = gpgme_new(&gpgme->context);
+
+ if (gpgme->error != GPG_ERR_NO_ERROR) {
+ main->setting.state.status = F_status_set_error(F_failure);
+
+ kt_tacocat_print_gpgme_error(&main->program.error, F_status_debug_source_d);
+
+ return;
+ }
+
+ // Enable ASCII armor.
+ gpgme_set_armor(gpgme->context, F_true);
+
+ // Disable online access.
+ gpgme_set_offline(gpgme->context, F_true);
+
+ // Is this necessary?
+ //err = gpgme_ctx_set_engine_info(ceofcontext, GPGME_PROTOCOL_OpenPGP, enginfo->file_name, enginfo->home_dir);
+
main->setting.state.status = F_okay;
}
#endif // defined(_en_gpgme_support_) && !defined(_di_kt_tacocat_gpgme_setup_)
f_range_t_initialize,
f_range_t_initialize,
f_range_t_initialize,
+ f_range_t_initialize,
+ f_range_t_initialize,
};
f_status_t status = set->status = F_okay;
f_fss_payload_object_salt_s,
f_fss_payload_object_id_s,
f_fss_payload_object_time_s,
+ f_fss_payload_object_signature_s,
+ kt_tacocat_encrypt_s,
};
for (; i < set->objects_header.used; ++i) {
}
}
+ // @todo convert signature (9).
+
+ // @todo convert encrypt (10).
+
// Convert the length (2), part (3), total (4), and salt (6).
{
f_number_unsigned_t number = 0;
extern "C" {
#endif
-#ifndef _di_kt_tacocat_print_gpgme_error_
+#if defined(_en_gpgme_support_) && !defined(_di_kt_tacocat_print_gpgme_error_)
f_status_t kt_tacocat_print_gpgme_error(fl_print_t * const print, const f_string_t debug) {
if (!print || !print->custom) return F_status_set_error(F_output_not);
fl_print_format(".%]%r", print->to, print->context, f_string_eol_s);
-
f_file_stream_unlock(print->to);
return F_okay;
}
-#endif // _di_kt_tacocat_print_gpgme_error_
+#endif // defined(_en_gpgme_support_) && !defined(_di_kt_tacocat_print_gpgme_error_)
#ifdef __cplusplus
} // extern "C"
*
* @see fll_error_print()
*/
-#ifndef _di_kt_tacocat_print_gpgme_error_
+#if defined(_en_gpgme_support_) && !defined(_di_kt_tacocat_print_gpgme_error_)
extern f_status_t kt_tacocat_print_gpgme_error(fl_print_t * const print, const f_string_t debug);
-#endif // _di_kt_tacocat_print_gpgme_error_
+#endif // defined(_en_gpgme_support_) && !defined(_di_kt_tacocat_print_gpgme_error_)
#ifdef __cplusplus
} // extern "C"
if (F_status_is_error_not(main->setting.state.status)) {
main->setting.state.status = F_okay;
}
-
- #ifdef _en_gpgme_support_
- kt_tacocat_gpgme_delete(&main->gpgme);
- #endif // _en_gpgme_support_
}
#endif // _di_kt_tacocat_process_main_
// Index 9 is the signature.
+ // Index 10 is the encryption.
+ set->abstruses.array[10].key = kt_tacocat_encrypt_s;
+ set->abstruses.array[10].value.type = f_abstruse_dynamic_e;
+ set->abstruses.array[10].value.is.a_dynamic = f_string_empty_s;
+ set->abstruses.array[10].value.is.a_dynamic.size = 0;
+
+ if ((main->setting.flag & kt_tacocat_main_flag_encrypt_d) && (set->flag & kt_tacocat_socket_step_flag_send_d)) {
+ #ifdef _en_gpgme_support_
+ set->abstruses.array[10].value.is.a_dynamic = kt_tacocat_gpgme_s;
+ #endif // _en_gpgme_support_
+ }
+
{
long salt = 0;
--- /dev/null
+#include "../../tacocat.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_en_gpgme_support_) && !defined(_di_kt_tacocat_send_step_encrypt_size_)
+ void kt_tacocat_send_step_encrypt_size(kt_tacocat_main_t * const main, kt_tacocat_socket_set_t * const set) {
+
+ if (!main || !set || F_status_is_error(set->status)) return;
+
+ if (set->encrypt_read) {
+ gpgme_data_release(set->encrypt_read);
+
+ set->encrypt_read = 0;
+ }
+
+ gpgme_error_t error = gpgme_data_new_from_fd(&set->encrypt_read, set->file.id);
+
+ if (error != GPG_ERR_NO_ERROR) {
+ set->status = F_status_set_error(F_memory);
+
+ kt_tacocat_print_error_on_file_send(&main->program.error, F_status_debug_source_d, kt_tacocat_send_s, set->network, set->status, set->name, f_file_operation_read_s);
+
+ return;
+ }
+
+ error = gpgme_data_set_encoding(set->encrypt_read, GPGME_DATA_ENCODING_ARMOR);
+
+ if (error != GPG_ERR_NO_ERROR) {
+ set->status = F_status_set_error(F_failure);
+
+ kt_tacocat_print_error_on_file_send(&main->program.error, F_status_debug_source_d, kt_tacocat_send_s, set->network, set->status, set->name, f_file_operation_read_s);
+
+ return;
+ }
+
+ // Total is used here to explicitly pass a pointer of off_t rather than a pointer of size_t cast to an off_t.
+ // GPGME provides no way to get the file size of the encrypted data, so load the file and determine the file size as it is loading.
+ off_t total = 0;
+ gpgme_ssize_t bytes = 1;
+
+ for (char buffer[set->file.size_read + 1]; bytes > 0 && total <= F_number_t_size_unsigned_d; total += bytes) {
+ bytes = gpgme_data_read(set->encrypt_read, buffer, set->file.size_read);
+ } // for
+
+ if (bytes == -1) {
+ set->status = F_status_set_error(F_failure);
+
+ kt_tacocat_print_error_on_file_send(&main->program.error, F_status_debug_source_d, kt_tacocat_send_s, set->network, set->status, set->name, f_file_operation_read_s);
+
+ return;
+ }
+
+ if ((f_number_unsigned_t) total > F_number_t_size_unsigned_d) {
+ set->status = F_status_set_error(F_too_large);
+
+ kt_tacocat_print_error_on_file_too_large(&main->program.error, set->name, kt_tacocat_send_s, set->network, F_number_t_size_unsigned_d, set->abstruses.array[4].value.is.a_unsigned);
+
+ return;
+ }
+
+ error = gpgme_data_rewind(set->encrypt_read);
+
+ if (error != GPG_ERR_NO_ERROR) {
+ set->status = F_status_set_error(F_failure);
+
+ kt_tacocat_print_error_on_file_send(&main->program.error, F_status_debug_source_d, kt_tacocat_send_s, set->network, set->status, set->name, f_file_operation_read_s);
+
+ return;
+ }
+
+ set->abstruses.array[3].value.is.a_unsigned = 0;
+ set->size_total = (f_number_unsigned_t) total;
+
+ if (total) {
+ if (set->size_total < set->file.size_read) {
+ set->abstruses.array[2].value.is.a_unsigned = set->size_total;
+ set->abstruses.array[4].value.is.a_unsigned = 1;
+ }
+ else {
+ set->abstruses.array[2].value.is.a_unsigned = set->file.size_read;
+ set->abstruses.array[4].value.is.a_unsigned = set->size_total / set->file.size_read;
+
+ if (set->abstruses.array[4].value.is.a_unsigned % set->file.size_read) {
+ ++set->abstruses.array[4].value.is.a_unsigned;
+ }
+ }
+ }
+ else {
+ set->abstruses.array[2].value.is.a_unsigned = set->size_total;
+ set->abstruses.array[4].value.is.a_unsigned = 1;
+ }
+ }
+#endif // defined(_en_gpgme_support_) && !defined(_di_kt_tacocat_send_step_encrypt_size_)
+
+#if !defined(_en_gpgme_support_) && !defined(_di_kt_tacocat_send_step_encrypt_size_)
+ void kt_tacocat_send_step_encrypt_size(kt_tacocat_main_t * const main, kt_tacocat_socket_set_t * const set) {
+
+ set->status = F_status_set_error(F_implement_not);
+
+ // @todo replace this with an error on encryption unsupported.
+ kt_tacocat_print_error_on(&main->program.error, F_status_debug_source_d, kt_tacocat_send_s, set->network, set->status, set->name);
+ }
+#endif // _di_kt_tacocat_send_step_encrypt_
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * Kevux Tools - TacocaT
+ *
+ * Project: Kevux Tools
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Provides send step encrypt functionality.
+ *
+ * This is auto-included and should not need to be explicitly included.
+ */
+#ifndef _kt_tacocat_send_step_encrypt_h
+#define _kt_tacocat_send_step_encrypt_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Perform the size step of a send request using encryption.
+ *
+ * This prints on error.
+ *
+ * @param main
+ * The main program and settings data.
+ *
+ * Must not be NULL.
+ *
+ * This does not alter main.setting.state.status, except on interrupt signal.
+ * @param set
+ * The socket set to process.
+ *
+ * Must not be NULL.
+ *
+ * This alters set.status:
+ * F_okay on success.
+ *
+ * F_done (with error bit) on error that cannot continue, such as out of memory.
+ * F_too_large (with error bit) on file too large.
+ *
+ * Errors (with error bit) from: f_memory_array_increase_by()
+ *
+ * Errors (with error bit) from: gpgme_data_new_from_fd()
+ * Errors (with error bit) from: gpgme_data_read()
+ * Errors (with error bit) from: gpgme_data_set_encoding()
+ *
+ * @see f_memory_array_increase_by()
+ *
+ * @see gpgme_data_new_from_fd()
+ * @see gpgme_data_read()
+ * @see gpgme_data_set_encoding()
+ */
+#ifndef _di_kt_tacocat_send_step_encrypt_size_
+ extern void kt_tacocat_send_step_encrypt_size(kt_tacocat_main_t * const main, kt_tacocat_socket_set_t * const set);
+#endif // _di_kt_tacocat_send_step_encrypt_size_
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // _kt_tacocat_send_step_encrypt_h
if (!main || !set || F_status_is_error(set->status)) return;
+ // @todo if (main->setting.flag & kt_tacocat_main_flag_encrypt_d) {
+
set->status = f_string_dynamic_append(f_fss_payload_object_payload_s, &set->buffer);
if (F_status_is_error_not(set->status)) {
if (!main || !set || F_status_is_error(set->status)) return;
- {
- size_t written = 0;
+ size_t written = 0;
- {
- const size_t original = set->socket.size_write;
+ const size_t original = set->socket.size_write;
- set->socket.size_write = set->buffer.used;
+ set->socket.size_write = set->buffer.used;
- set->status = f_socket_write_stream(&set->socket, f_socket_flag_signal_not_e, (void *) set->buffer.string, &written);
+ set->status = f_socket_write_stream(&set->socket, f_socket_flag_signal_not_e, (void *) set->buffer.string, &written);
- set->socket.size_write = original;
+ set->socket.size_write = original;
- if (F_status_is_error(set->status)) {
- kt_tacocat_print_error_on(&main->program.error, F_status_debug_source_d, kt_tacocat_send_packet_s, set->network, set->status, set->name);
+ if (F_status_is_error(set->status)) {
+ kt_tacocat_print_error_on(&main->program.error, F_status_debug_source_d, kt_tacocat_send_packet_s, set->network, set->status, set->name);
- return;
- }
- }
-
- // @todo handle case when written < set->buffer.used, of which each pass. The entire buffer must be sent. May need another variable for say, set->size_process.
-
- set->size_done += written;
+ return;
}
+ // @todo handle case when written < set->buffer.used, of which each pass. The entire buffer must be sent. May need another variable for say, set->size_process.
+
+ set->size_done += written;
set->step = kt_tacocat_socket_step_send_wait_e;
set->status = F_okay;
}
set->status = f_file_open(set->name, F_file_mode_all_r_d, &set->file);
if (F_status_is_error(set->status)) {
- kt_tacocat_print_error_on_file_receive(&main->program.error, F_status_debug_source_d, kt_tacocat_send_s, set->network, set->status, set->name, f_file_operation_open_s);
+ kt_tacocat_print_error_on_file_send(&main->program.error, F_status_debug_source_d, kt_tacocat_send_s, set->network, set->status, set->name, f_file_operation_open_s);
return;
}
}
- // Total is used here to explicitly pass a pointer of off_t rather than a pointer of size_t cast to an off_t.
- {
+ if (main->setting.flag & kt_tacocat_main_flag_encrypt_d) {
+ kt_tacocat_send_step_encrypt_size(main, set);
+ } else {
+
+ // Total is used here to explicitly pass a pointer of off_t rather than a pointer of size_t cast to an off_t.
off_t total = 0;
set->status = f_file_size_by_id(set->file, &total);
if (F_status_is_error(set->status)) {
- kt_tacocat_print_error_on_file_receive(&main->program.error, F_status_debug_source_d, kt_tacocat_send_size_s, set->network, set->status, set->name, f_file_operation_open_s);
+ kt_tacocat_print_error_on_file_send(&main->program.error, F_status_debug_source_d, kt_tacocat_send_size_s, set->network, set->status, set->name, f_file_operation_open_s);
return;
}
#include <program/kevux/tools/tacocat/main/send/step/check.h>
#include <program/kevux/tools/tacocat/main/send/step/done.h>
#include <program/kevux/tools/tacocat/main/send/step/encode.h>
+#include <program/kevux/tools/tacocat/main/send/step/encrypt.h>
#include <program/kevux/tools/tacocat/main/send/step/file.h>
#include <program/kevux/tools/tacocat/main/send/step/header.h>
#include <program/kevux/tools/tacocat/main/send/step/packet.h>
projects / kevux-tools / commitdiff