From 1b88946a4e4c88005db3b4087c2e3186c0c11806 Mon Sep 17 00:00:00 2001 From: Totto16 Date: Mon, 24 Oct 2022 21:48:58 +0200 Subject: [PATCH 1/2] - Ported the checksum to the async file read functions and bumped the version up to 3.3 --- plugins/checksum/checksum.c | 555 ++++++++++++++++++++++++------------ 1 file changed, 371 insertions(+), 184 deletions(-) diff --git a/plugins/checksum/checksum.c b/plugins/checksum/checksum.c index 6aa64b64..b69ef7da 100644 --- a/plugins/checksum/checksum.c +++ b/plugins/checksum/checksum.c @@ -22,244 +22,431 @@ #include "config.h" -#include -#include -#include #include +#include +#include +#include +#include #include "hexchat-plugin.h" #define BUFSIZE 32768 -#define DEFAULT_LIMIT 256 /* default size is 256 MiB */ +#define DEFAULT_LIMIT 256 /* default size is 256 MiB */ #define SHA256_DIGEST_LENGTH 32 #define SHA256_BUFFER_LENGTH 65 -static hexchat_plugin *ph; /* plugin handle */ +static hexchat_plugin *ph; /* plugin handle */ static char name[] = "Checksum"; static char desc[] = "Calculate checksum for DCC file transfers"; -static char version[] = "3.1"; +static char version[] = "3.3"; -static void -set_limit (char *size) -{ - int limit = atoi (size); +static void set_limit(char *size) { + int limit = atoi(size); - if (limit > 0 && limit < INT_MAX) - { - if (hexchat_pluginpref_set_int (ph, "limit", limit)) - hexchat_printf (ph, "Checksum: File size limit has successfully been set to: %d MiB\n", limit); - else - hexchat_printf (ph, "Checksum: File access error while saving!\n"); - } - else - { - hexchat_printf (ph, "Checksum: Invalid input!\n"); - } + if (limit > 0 && limit < INT_MAX) { + if (hexchat_pluginpref_set_int(ph, "limit", limit)) + hexchat_printf( + ph, + "Checksum: File size limit has successfully been set to: %d MiB\n", + limit); + else + hexchat_printf(ph, "Checksum: File access error while saving!\n"); + } else { + hexchat_printf(ph, "Checksum: Invalid input!\n"); + } } -static int -get_limit (void) -{ - int size = hexchat_pluginpref_get_int (ph, "limit"); +static int get_limit(void) { + int size = hexchat_pluginpref_get_int(ph, "limit"); - if (size <= 0 || size >= INT_MAX) - return DEFAULT_LIMIT; - else - return size; + if (size <= 0 || size >= INT_MAX) + return DEFAULT_LIMIT; + else + return size; } -static gboolean -check_limit (GFile *file) -{ - GFileInfo *file_info; - goffset file_size; +static gboolean check_limit(GFile *file) { + GFileInfo *file_info; + goffset file_size; - file_info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_SIZE, G_FILE_QUERY_INFO_NONE, - NULL, NULL); + file_info = g_file_query_info(file, G_FILE_ATTRIBUTE_STANDARD_SIZE, + G_FILE_QUERY_INFO_NONE, NULL, NULL); - if (!file_info) - return FALSE; + if (!file_info) + return FALSE; - file_size = g_file_info_get_size (file_info); - g_object_unref (file_info); + file_size = g_file_info_get_size(file_info); + g_object_unref(file_info); - if (file_size > get_limit () * 1048576ll) - return FALSE; + if (file_size > get_limit() * 1048576ll) + return FALSE; - return TRUE; + return TRUE; } -static gboolean -sha256_from_stream (GFileInputStream *file_stream, char out_buf[]) -{ - GChecksum *checksum; - gssize bytes_read; - guint8 digest[SHA256_DIGEST_LENGTH]; - gsize digest_len = sizeof(digest); - guchar buffer[BUFSIZE]; - gsize i; +typedef void async_result_cb(gboolean, gpointer); - checksum = g_checksum_new (G_CHECKSUM_SHA256); +typedef struct { + GChecksum *checksum; + async_result_cb *result_callback; + guchar *buffer; + size_t *buffer_size; + char *out_buf; + gpointer bound_data; +} stream_async_cb_data; - while ((bytes_read = g_input_stream_read (G_INPUT_STREAM (file_stream), buffer, sizeof (buffer), NULL, NULL))) - { - if (bytes_read == -1) - { - g_checksum_free (checksum); - return FALSE; - } - - g_checksum_update (checksum, buffer, bytes_read); - } - - g_checksum_get_digest (checksum, digest, &digest_len); - g_checksum_free (checksum); - - for (i = 0; i < SHA256_DIGEST_LENGTH; i++) - { - /* out_buf will be exactly SHA256_BUFFER_LENGTH including null */ - g_sprintf (out_buf + (i * 2), "%02x", digest[i]); - } - - return TRUE; +static void free_user_data(stream_async_cb_data *user_data) { + free(user_data->buffer_size); + free(user_data->buffer); + g_checksum_free(user_data->checksum); + free(user_data); } -static gboolean -sha256_from_file (char *filename, char out_buf[]) -{ - GFileInputStream *file_stream; - char *filename_fs; - GFile *file; +static void stream_async_cb(GObject *source_object, GAsyncResult *res, + gpointer user_data) { + stream_async_cb_data *bound_vars = (void *)user_data; - filename_fs = g_filename_from_utf8 (filename, -1, NULL, NULL, NULL); - if (!filename_fs) - { - hexchat_printf (ph, "Checksum: Invalid filename (%s)\n", filename); - return FALSE; - } + GInputStream *stream = G_INPUT_STREAM(source_object); + GError *error = NULL; + gssize bytes_read = g_input_stream_read_finish(stream, res, &error); - file = g_file_new_for_path (filename_fs); - g_free (filename_fs); - if (!file) - { - hexchat_printf (ph, "Checksum: Failed to open %s\n", filename); - return FALSE; - } + if (bytes_read != 0) { + if (bytes_read == -1 || error) { + async_result_cb *cb = bound_vars->result_callback; + gpointer bound_data = bound_vars->bound_data; + free_user_data(bound_vars); + return cb(FALSE, bound_data); + } - if (!check_limit (file)) - { - hexchat_printf (ph, "Checksum: %s is larger than size limit. You can increase it with /CHECKSUM SET.\n", filename); - g_object_unref (file); - return FALSE; - } + g_checksum_update(bound_vars->checksum, bound_vars->buffer, bytes_read); - file_stream = g_file_read (file, NULL, NULL); - if (!file_stream) - { - hexchat_printf (ph, "Checksum: Failed to read file %s\n", filename); - g_object_unref (file); - return FALSE; - } + return g_input_stream_read_async( + stream, bound_vars->buffer, *bound_vars->buffer_size, + G_PRIORITY_DEFAULT, NULL, stream_async_cb, user_data); + } - if (!sha256_from_stream (file_stream, out_buf)) - { - hexchat_printf (ph, "Checksum: Failed to generate checksum for %s\n", filename); - g_object_unref (file_stream); - g_object_unref (file); - return FALSE; - } + guint8 digest[SHA256_DIGEST_LENGTH]; + gsize digest_len = sizeof(digest); - g_object_unref (file_stream); - g_object_unref (file); - return TRUE; + g_checksum_get_digest(bound_vars->checksum, digest, &digest_len); + gpointer bound_data = bound_vars->bound_data; + char *out_buf = bound_vars->out_buf; + async_result_cb *cb = bound_vars->result_callback; + free_user_data(user_data); + + gsize i; + for (i= 0; i < SHA256_DIGEST_LENGTH; i++) { + /* out_buf will be exactly SHA256_BUFFER_LENGTH including null */ + g_sprintf(out_buf + (i * 2), "%02x", digest[i]); + } + + cb(TRUE, bound_data); } -static int -dccrecv_cb (char *word[], void *userdata) -{ - const char *dcc_completed_dir; - char *filename, checksum[SHA256_BUFFER_LENGTH]; +static void sha256_from_stream_async(GFileInputStream *file_stream, + char out_buf[], async_result_cb *result_cb, + gpointer bound_data) { - /* Print in the privmsg tab of the sender */ - hexchat_set_context (ph, hexchat_find_context (ph, NULL, word[3])); + size_t *buffer_size = malloc(sizeof(size_t)); + if (buffer_size == NULL) { + return result_cb(FALSE, bound_data); + } - if (hexchat_get_prefs (ph, "dcc_completed_dir", &dcc_completed_dir, NULL) == 1 && dcc_completed_dir[0] != '\0') - filename = g_build_filename (dcc_completed_dir, word[1], NULL); - else - filename = g_strdup (word[2]); + *buffer_size = BUFSIZ * sizeof(guchar); + guchar *buffer = malloc(*buffer_size); + if (buffer == NULL) { + free(buffer_size); + return result_cb(FALSE, bound_data); + } - if (sha256_from_file (filename, checksum)) - { - hexchat_printf (ph, "SHA-256 checksum for %s (local): %s\n", word[1], checksum); - } + GChecksum *checksum = g_checksum_new(G_CHECKSUM_SHA256); + if (checksum == NULL) { + free(buffer_size); + free(buffer); + return result_cb(FALSE, bound_data); + } - g_free (filename); - return HEXCHAT_EAT_NONE; + stream_async_cb_data *user_data = malloc(sizeof(stream_async_cb_data)); + if (user_data == NULL) { + free(buffer_size); + free(buffer); + g_checksum_free(checksum); + return result_cb(FALSE, bound_data); + } + + user_data->checksum = checksum; + user_data->result_callback = result_cb; + user_data->buffer = buffer; + user_data->buffer_size = buffer_size; + user_data->out_buf = out_buf; + user_data->bound_data = bound_data; + + g_input_stream_read_async(G_INPUT_STREAM(file_stream), buffer, *buffer_size, + G_PRIORITY_DEFAULT, NULL, stream_async_cb, + (void *)user_data); } -static int -dccoffer_cb (char *word[], void *userdata) -{ - char checksum[SHA256_BUFFER_LENGTH]; +typedef struct { + async_result_cb *result_cb; + GFileInputStream *file_stream; + char *filename; + GFile *file; + gpointer bound_data; +} file_async_cb_data; - /* Print in the privmsg tab of the receiver */ - hexchat_set_context (ph, hexchat_find_context (ph, NULL, word[3])); +static void file_async_cb(gboolean result, gpointer user_data) { - if (sha256_from_file (word[3], checksum)) - { - hexchat_commandf (ph, "quote PRIVMSG %s :SHA-256 checksum for %s (remote): %s", word[2], word[1], checksum); - } + file_async_cb_data *bound_vars = (void *)user_data; - return HEXCHAT_EAT_NONE; + if (!result) { + hexchat_printf(ph, "Checksum: Failed to generate checksum for %s\n", + bound_vars->filename); + } + + g_object_unref(bound_vars->file_stream); + g_object_unref(bound_vars->file); + async_result_cb *cb = bound_vars->result_cb; + gpointer bound_data = bound_vars->bound_data; + free(bound_vars); + + return cb(result, bound_data); } -static int -checksum (char *word[], char *word_eol[], void *userdata) -{ - if (!g_ascii_strcasecmp ("GET", word[2])) - { - hexchat_printf (ph, "File size limit for checksums: %d MiB", get_limit ()); - } - else if (!g_ascii_strcasecmp ("SET", word[2])) - { - set_limit (word[3]); - } - else - { - hexchat_printf (ph, "Usage: /CHECKSUM GET|SET\n"); - hexchat_printf (ph, " GET - print the maximum file size (in MiB) to be hashed\n"); - hexchat_printf (ph, " SET - set the maximum file size (in MiB) to be hashed\n"); - } +static void sha256_from_file_async(char *filename, char out_buf[], + async_result_cb *result_cb, + gpointer bound_data) { + GFileInputStream *file_stream; + char *filename_fs; + GFile *file; - return HEXCHAT_EAT_ALL; + filename_fs = g_filename_from_utf8(filename, -1, NULL, NULL, NULL); + if (!filename_fs) { + hexchat_printf(ph, "Checksum: Invalid filename (%s)\n", filename); + return result_cb(FALSE, bound_data); + } + + file = g_file_new_for_path(filename_fs); + g_free(filename_fs); + if (!file) { + hexchat_printf(ph, "Checksum: Failed to open %s\n", filename); + return result_cb(FALSE, bound_data); + } + + if (!check_limit(file)) { + hexchat_printf(ph, + "Checksum: %s is larger than size limit. You can increase " + "it with /CHECKSUM SET.\n", + filename); + g_object_unref(file); + return result_cb(FALSE, bound_data); + } + + file_stream = g_file_read(file, NULL, NULL); + if (!file_stream) { + hexchat_printf(ph, "Checksum: Failed to read file %s\n", filename); + g_object_unref(file); + return result_cb(FALSE, bound_data); + } + + file_async_cb_data *user_data = malloc(sizeof(file_async_cb_data)); + if (user_data == NULL) { + hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); + g_object_unref(file); + return result_cb(FALSE, bound_data); + } + + user_data->result_cb = result_cb; + user_data->file_stream = file_stream; + user_data->filename = filename; + user_data->file = file; + user_data->bound_data = bound_data; + + sha256_from_stream_async(file_stream, out_buf, file_async_cb, + (void *)user_data); } -int -hexchat_plugin_init (hexchat_plugin *plugin_handle, char **plugin_name, char **plugin_desc, char **plugin_version, char *arg) -{ - ph = plugin_handle; +typedef struct { + char *checksum; + char *word_1; + char *filename; +} dccrecv_async_cb_data; - *plugin_name = name; - *plugin_desc = desc; - *plugin_version = version; +void dccrecv_async_cb(gboolean result, gpointer user_data) { - /* this is required for the very first run */ - if (hexchat_pluginpref_get_int (ph, "limit") == -1) - { - hexchat_pluginpref_set_int (ph, "limit", DEFAULT_LIMIT); - } + dccrecv_async_cb_data *bound_vars = (void *)user_data; - hexchat_hook_command (ph, "CHECKSUM", HEXCHAT_PRI_NORM, checksum, "Usage: /CHECKSUM GET|SET", NULL); - hexchat_hook_print (ph, "DCC RECV Complete", HEXCHAT_PRI_NORM, dccrecv_cb, NULL); - hexchat_hook_print (ph, "DCC Offer", HEXCHAT_PRI_NORM, dccoffer_cb, NULL); + if (result) { + hexchat_printf(ph, "SHA-256 checksum for %s (local): %s\n", + bound_vars->word_1, bound_vars->checksum); + } - hexchat_printf (ph, "%s plugin loaded\n", name); - return 1; + free(bound_vars->word_1); + free(bound_vars->checksum); + g_free(bound_vars->filename); + + free(bound_vars); } -int -hexchat_plugin_deinit (void) -{ - hexchat_printf (ph, "%s plugin unloaded\n", name); - return 1; +static int dccrecv_cb(char *word[], void *userdata) { + const char *dcc_completed_dir; + char *filename; + char *checksum = malloc(SHA256_BUFFER_LENGTH); + if (checksum == NULL) { + hexchat_commandf(ph, "Checksum: Failed to malloc needed memory\n"); + return HEXCHAT_EAT_NONE; + } + + /* Print in the privmsg tab of the sender */ + hexchat_set_context(ph, hexchat_find_context(ph, NULL, word[3])); + + if (hexchat_get_prefs(ph, "dcc_completed_dir", &dcc_completed_dir, NULL) == + 1 && + dcc_completed_dir[0] != '\0') { + filename = g_build_filename(dcc_completed_dir, word[1], NULL); + } else { + filename = g_strdup(word[2]); + } + + dccrecv_async_cb_data *user_data = malloc(sizeof(dccrecv_async_cb_data)); + if (user_data == NULL) { + hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); + free(checksum); + return HEXCHAT_EAT_NONE; + } + + user_data->checksum = checksum; + + char *word_1 = malloc(strlen(word[1]) + 1); + if (word_1 == NULL) { + hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); + free(checksum); + free(user_data); + return HEXCHAT_EAT_NONE; + } + + strcpy(word_1, word[1]); + + user_data->word_1 = word_1; + user_data->filename = filename; + + sha256_from_file_async(filename, checksum, dccrecv_async_cb, + (void *)user_data); + + return HEXCHAT_EAT_NONE; +} + +typedef struct { + char *checksum; + char *word_1; + char *word_2; +} dccoffer_async_cb_data; + +void dccoffer_async_cb(gboolean result, gpointer user_data) { + + dccoffer_async_cb_data *bound_vars = (void *)user_data; + + if (result) { + hexchat_commandf( + ph, "quote PRIVMSG %s :SHA-256 checksum for %s (remote): %s", + bound_vars->word_2, bound_vars->word_1, bound_vars->checksum); + } + + free(bound_vars->word_2); + free(bound_vars->word_1); + free(bound_vars->checksum); + + free(bound_vars); +} + +static int dccoffer_cb(char *word[], void *userdata) { + + /* Print in the privmsg tab of the receiver */ + hexchat_set_context(ph, hexchat_find_context(ph, NULL, word[3])); + + char *checksum = malloc(SHA256_BUFFER_LENGTH); + if (checksum == NULL) { + hexchat_commandf(ph, "Checksum: Failed to malloc needed memory\n"); + return HEXCHAT_EAT_NONE; + } + + dccoffer_async_cb_data *user_data = malloc(sizeof(dccoffer_async_cb_data)); + if (user_data == NULL) { + hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); + free(checksum); + return HEXCHAT_EAT_NONE; + } + + user_data->checksum = checksum; + + char *word_1 = malloc(strlen(word[1]) + 1); + if (word_1 == NULL) { + hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); + free(checksum); + free(user_data); + return HEXCHAT_EAT_NONE; + } + + char *word_2 = malloc(strlen(word[2]) + 1); + if (word_2 == NULL) { + hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); + free(checksum); + free(user_data); + free(word_1); + return HEXCHAT_EAT_NONE; + } + + strcpy(word_1, word[1]); + strcpy(word_2, word[2]); + + user_data->word_1 = word_1; + user_data->word_2 = word_2; + + sha256_from_file_async(word[3], checksum, dccoffer_async_cb, + (void *)user_data); + return HEXCHAT_EAT_NONE; +} + +static int checksum(char *word[], char *word_eol[], void *userdata) { + if (!g_ascii_strcasecmp("GET", word[2])) { + hexchat_printf(ph, "File size limit for checksums: %d MiB", get_limit()); + } else if (!g_ascii_strcasecmp("SET", word[2])) { + set_limit(word[3]); + } else { + hexchat_printf(ph, "Usage: /CHECKSUM GET|SET\n"); + hexchat_printf( + ph, " GET - print the maximum file size (in MiB) to be hashed\n"); + hexchat_printf( + ph, + " SET - set the maximum file size (in MiB) to be hashed\n"); + } + + return HEXCHAT_EAT_ALL; +} + +int hexchat_plugin_init(hexchat_plugin *plugin_handle, char **plugin_name, + char **plugin_desc, char **plugin_version, char *arg) { + ph = plugin_handle; + + *plugin_name = name; + *plugin_desc = desc; + *plugin_version = version; + + /* this is required for the very first run */ + if (hexchat_pluginpref_get_int(ph, "limit") == -1) { + hexchat_pluginpref_set_int(ph, "limit", DEFAULT_LIMIT); + } + + hexchat_hook_command(ph, "CHECKSUM", HEXCHAT_PRI_NORM, checksum, + "Usage: /CHECKSUM GET|SET", NULL); + hexchat_hook_print(ph, "DCC RECV Complete", HEXCHAT_PRI_NORM, dccrecv_cb, + NULL); + hexchat_hook_print(ph, "DCC Offer", HEXCHAT_PRI_NORM, dccoffer_cb, NULL); + + hexchat_printf(ph, "%s plugin loaded\n", name); + return 1; +} + +int hexchat_plugin_deinit(void) { + hexchat_printf(ph, "%s plugin unloaded\n", name); + return 1; } From c87a7c63ed41acc96f45b48c3c0802f11a22878f Mon Sep 17 00:00:00 2001 From: Totto16 Date: Mon, 24 Oct 2022 22:55:53 +0200 Subject: [PATCH 2/2] - fixed malloc and used g_new or g_malloc in all places - i double bumped the version accidentally - undo formatting of not touched code (the other is that different, that it wouldn't be recognizeable anyway) - removed the limit option completely, also resulting in removing the /checksum command - use g_strdup instead of some manual stuff + strcpy --- plugins/checksum/checksum.c | 236 ++++++++---------------------------- 1 file changed, 48 insertions(+), 188 deletions(-) diff --git a/plugins/checksum/checksum.c b/plugins/checksum/checksum.c index b69ef7da..a4a8cd42 100644 --- a/plugins/checksum/checksum.c +++ b/plugins/checksum/checksum.c @@ -22,67 +22,22 @@ #include "config.h" -#include +#include #include #include #include -#include +#include #include "hexchat-plugin.h" #define BUFSIZE 32768 -#define DEFAULT_LIMIT 256 /* default size is 256 MiB */ #define SHA256_DIGEST_LENGTH 32 #define SHA256_BUFFER_LENGTH 65 -static hexchat_plugin *ph; /* plugin handle */ +static hexchat_plugin *ph; /* plugin handle */ static char name[] = "Checksum"; static char desc[] = "Calculate checksum for DCC file transfers"; -static char version[] = "3.3"; - -static void set_limit(char *size) { - int limit = atoi(size); - - if (limit > 0 && limit < INT_MAX) { - if (hexchat_pluginpref_set_int(ph, "limit", limit)) - hexchat_printf( - ph, - "Checksum: File size limit has successfully been set to: %d MiB\n", - limit); - else - hexchat_printf(ph, "Checksum: File access error while saving!\n"); - } else { - hexchat_printf(ph, "Checksum: Invalid input!\n"); - } -} - -static int get_limit(void) { - int size = hexchat_pluginpref_get_int(ph, "limit"); - - if (size <= 0 || size >= INT_MAX) - return DEFAULT_LIMIT; - else - return size; -} - -static gboolean check_limit(GFile *file) { - GFileInfo *file_info; - goffset file_size; - - file_info = g_file_query_info(file, G_FILE_ATTRIBUTE_STANDARD_SIZE, - G_FILE_QUERY_INFO_NONE, NULL, NULL); - - if (!file_info) - return FALSE; - - file_size = g_file_info_get_size(file_info); - g_object_unref(file_info); - - if (file_size > get_limit() * 1048576ll) - return FALSE; - - return TRUE; -} +static char version[] = "3.2"; typedef void async_result_cb(gboolean, gpointer); @@ -96,10 +51,10 @@ typedef struct { } stream_async_cb_data; static void free_user_data(stream_async_cb_data *user_data) { - free(user_data->buffer_size); - free(user_data->buffer); + g_free(user_data->buffer_size); + g_free(user_data->buffer); g_checksum_free(user_data->checksum); - free(user_data); + g_free(user_data); } static void stream_async_cb(GObject *source_object, GAsyncResult *res, @@ -130,12 +85,12 @@ static void stream_async_cb(GObject *source_object, GAsyncResult *res, g_checksum_get_digest(bound_vars->checksum, digest, &digest_len); gpointer bound_data = bound_vars->bound_data; - char *out_buf = bound_vars->out_buf; + char *out_buf = bound_vars->out_buf; async_result_cb *cb = bound_vars->result_callback; free_user_data(user_data); gsize i; - for (i= 0; i < SHA256_DIGEST_LENGTH; i++) { + for (i = 0; i < SHA256_DIGEST_LENGTH; i++) { /* out_buf will be exactly SHA256_BUFFER_LENGTH including null */ g_sprintf(out_buf + (i * 2), "%02x", digest[i]); } @@ -147,32 +102,13 @@ static void sha256_from_stream_async(GFileInputStream *file_stream, char out_buf[], async_result_cb *result_cb, gpointer bound_data) { - size_t *buffer_size = malloc(sizeof(size_t)); - if (buffer_size == NULL) { - return result_cb(FALSE, bound_data); - } + size_t *buffer_size = g_new(size_t, 1); *buffer_size = BUFSIZ * sizeof(guchar); - guchar *buffer = malloc(*buffer_size); - if (buffer == NULL) { - free(buffer_size); - return result_cb(FALSE, bound_data); - } + guchar *buffer = g_malloc(*buffer_size); GChecksum *checksum = g_checksum_new(G_CHECKSUM_SHA256); - if (checksum == NULL) { - free(buffer_size); - free(buffer); - return result_cb(FALSE, bound_data); - } - - stream_async_cb_data *user_data = malloc(sizeof(stream_async_cb_data)); - if (user_data == NULL) { - free(buffer_size); - free(buffer); - g_checksum_free(checksum); - return result_cb(FALSE, bound_data); - } + stream_async_cb_data *user_data = g_new(stream_async_cb_data, 1); user_data->checksum = checksum; user_data->result_callback = result_cb; @@ -207,7 +143,7 @@ static void file_async_cb(gboolean result, gpointer user_data) { g_object_unref(bound_vars->file); async_result_cb *cb = bound_vars->result_cb; gpointer bound_data = bound_vars->bound_data; - free(bound_vars); + g_free(bound_vars); return cb(result, bound_data); } @@ -232,14 +168,6 @@ static void sha256_from_file_async(char *filename, char out_buf[], return result_cb(FALSE, bound_data); } - if (!check_limit(file)) { - hexchat_printf(ph, - "Checksum: %s is larger than size limit. You can increase " - "it with /CHECKSUM SET.\n", - filename); - g_object_unref(file); - return result_cb(FALSE, bound_data); - } file_stream = g_file_read(file, NULL, NULL); if (!file_stream) { @@ -248,12 +176,8 @@ static void sha256_from_file_async(char *filename, char out_buf[], return result_cb(FALSE, bound_data); } - file_async_cb_data *user_data = malloc(sizeof(file_async_cb_data)); - if (user_data == NULL) { - hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); - g_object_unref(file); - return result_cb(FALSE, bound_data); - } + file_async_cb_data *user_data = g_new(file_async_cb_data, 1); + user_data->result_cb = result_cb; user_data->file_stream = file_stream; @@ -280,21 +204,17 @@ void dccrecv_async_cb(gboolean result, gpointer user_data) { bound_vars->word_1, bound_vars->checksum); } - free(bound_vars->word_1); - free(bound_vars->checksum); + g_free(bound_vars->word_1); + g_free(bound_vars->checksum); g_free(bound_vars->filename); - free(bound_vars); + g_free(bound_vars); } static int dccrecv_cb(char *word[], void *userdata) { const char *dcc_completed_dir; char *filename; - char *checksum = malloc(SHA256_BUFFER_LENGTH); - if (checksum == NULL) { - hexchat_commandf(ph, "Checksum: Failed to malloc needed memory\n"); - return HEXCHAT_EAT_NONE; - } + char *checksum = g_malloc(SHA256_BUFFER_LENGTH); /* Print in the privmsg tab of the sender */ hexchat_set_context(ph, hexchat_find_context(ph, NULL, word[3])); @@ -307,24 +227,11 @@ static int dccrecv_cb(char *word[], void *userdata) { filename = g_strdup(word[2]); } - dccrecv_async_cb_data *user_data = malloc(sizeof(dccrecv_async_cb_data)); - if (user_data == NULL) { - hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); - free(checksum); - return HEXCHAT_EAT_NONE; - } + dccrecv_async_cb_data *user_data = g_new(dccrecv_async_cb_data,1); user_data->checksum = checksum; - char *word_1 = malloc(strlen(word[1]) + 1); - if (word_1 == NULL) { - hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); - free(checksum); - free(user_data); - return HEXCHAT_EAT_NONE; - } - - strcpy(word_1, word[1]); + char *word_1 = g_strdup(word[1]); user_data->word_1 = word_1; user_data->filename = filename; @@ -351,11 +258,11 @@ void dccoffer_async_cb(gboolean result, gpointer user_data) { bound_vars->word_2, bound_vars->word_1, bound_vars->checksum); } - free(bound_vars->word_2); - free(bound_vars->word_1); - free(bound_vars->checksum); + g_free(bound_vars->word_2); + g_free(bound_vars->word_1); + g_free(bound_vars->checksum); - free(bound_vars); + g_free(bound_vars); } static int dccoffer_cb(char *word[], void *userdata) { @@ -363,40 +270,15 @@ static int dccoffer_cb(char *word[], void *userdata) { /* Print in the privmsg tab of the receiver */ hexchat_set_context(ph, hexchat_find_context(ph, NULL, word[3])); - char *checksum = malloc(SHA256_BUFFER_LENGTH); - if (checksum == NULL) { - hexchat_commandf(ph, "Checksum: Failed to malloc needed memory\n"); - return HEXCHAT_EAT_NONE; - } + char *checksum = g_malloc(SHA256_BUFFER_LENGTH); + + dccoffer_async_cb_data *user_data = g_new(dccoffer_async_cb_data, 1); - dccoffer_async_cb_data *user_data = malloc(sizeof(dccoffer_async_cb_data)); - if (user_data == NULL) { - hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); - free(checksum); - return HEXCHAT_EAT_NONE; - } user_data->checksum = checksum; - char *word_1 = malloc(strlen(word[1]) + 1); - if (word_1 == NULL) { - hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); - free(checksum); - free(user_data); - return HEXCHAT_EAT_NONE; - } - - char *word_2 = malloc(strlen(word[2]) + 1); - if (word_2 == NULL) { - hexchat_printf(ph, "Checksum: Failed to malloc needed memory\n"); - free(checksum); - free(user_data); - free(word_1); - return HEXCHAT_EAT_NONE; - } - - strcpy(word_1, word[1]); - strcpy(word_2, word[2]); + char *word_1 = g_strdup(word[1]); + char *word_2 = g_strdup(word[2]); user_data->word_1 = word_1; user_data->word_2 = word_2; @@ -406,47 +288,25 @@ static int dccoffer_cb(char *word[], void *userdata) { return HEXCHAT_EAT_NONE; } -static int checksum(char *word[], char *word_eol[], void *userdata) { - if (!g_ascii_strcasecmp("GET", word[2])) { - hexchat_printf(ph, "File size limit for checksums: %d MiB", get_limit()); - } else if (!g_ascii_strcasecmp("SET", word[2])) { - set_limit(word[3]); - } else { - hexchat_printf(ph, "Usage: /CHECKSUM GET|SET\n"); - hexchat_printf( - ph, " GET - print the maximum file size (in MiB) to be hashed\n"); - hexchat_printf( - ph, - " SET - set the maximum file size (in MiB) to be hashed\n"); - } +int +hexchat_plugin_init (hexchat_plugin *plugin_handle, char **plugin_name, char **plugin_desc, char **plugin_version, char *arg) +{ + ph = plugin_handle; - return HEXCHAT_EAT_ALL; + *plugin_name = name; + *plugin_desc = desc; + *plugin_version = version; + + hexchat_hook_print (ph, "DCC RECV Complete", HEXCHAT_PRI_NORM, dccrecv_cb, NULL); + hexchat_hook_print (ph, "DCC Offer", HEXCHAT_PRI_NORM, dccoffer_cb, NULL); + + hexchat_printf (ph, "%s plugin loaded\n", name); + return 1; } -int hexchat_plugin_init(hexchat_plugin *plugin_handle, char **plugin_name, - char **plugin_desc, char **plugin_version, char *arg) { - ph = plugin_handle; - - *plugin_name = name; - *plugin_desc = desc; - *plugin_version = version; - - /* this is required for the very first run */ - if (hexchat_pluginpref_get_int(ph, "limit") == -1) { - hexchat_pluginpref_set_int(ph, "limit", DEFAULT_LIMIT); - } - - hexchat_hook_command(ph, "CHECKSUM", HEXCHAT_PRI_NORM, checksum, - "Usage: /CHECKSUM GET|SET", NULL); - hexchat_hook_print(ph, "DCC RECV Complete", HEXCHAT_PRI_NORM, dccrecv_cb, - NULL); - hexchat_hook_print(ph, "DCC Offer", HEXCHAT_PRI_NORM, dccoffer_cb, NULL); - - hexchat_printf(ph, "%s plugin loaded\n", name); - return 1; -} - -int hexchat_plugin_deinit(void) { - hexchat_printf(ph, "%s plugin unloaded\n", name); - return 1; +int +hexchat_plugin_deinit (void) +{ + hexchat_printf (ph, "%s plugin unloaded\n", name); + return 1; }