iiiypuk/hexchat
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge c87a7c63ed41acc96f45b48c3c0802f11a22878f into c48afe3799e648e0ded2bf07deeb082028b6c5ac

Browse Source
This commit is contained in:
Totto16 2023-03-15 09:30:37 +01:00 committed by GitHub
commit 5b9fdccbac
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 209 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

371
plugins/checksum/checksum.c
View File

@ -24,214 +24,268 @@
#include <stdlib.h> #include <stdlib.h>
#include <glib.h> #include <glib.h>
#include <glib/gerror.h>
#include <glib/gstdio.h> #include <glib/gstdio.h>
#include <gio/gio.h> #include <gio/gio.h>
#include "hexchat-plugin.h" #include "hexchat-plugin.h"
#define BUFSIZE 32768 #define BUFSIZE 32768
#define DEFAULT_LIMIT 256 /* default size is 256 MiB */
#define SHA256_DIGEST_LENGTH 32 #define SHA256_DIGEST_LENGTH 32
#define SHA256_BUFFER_LENGTH 65 #define SHA256_BUFFER_LENGTH 65
static hexchat_plugin *ph; /* plugin handle */ static hexchat_plugin *ph; /* plugin handle */
static char name[] = "Checksum"; static char name[] = "Checksum";
static char desc[] = "Calculate checksum for DCC file transfers"; static char desc[] = "Calculate checksum for DCC file transfers";
static char version[] = "3.1"; static char version[] = "3.2";
static void typedef void async_result_cb(gboolean, gpointer);
set_limit (char *size)
{
int limit = atoi (size);
if (limit > 0 && limit < INT_MAX) typedef struct {
{ GChecksum *checksum;
if (hexchat_pluginpref_set_int (ph, "limit", limit)) async_result_cb *result_callback;
hexchat_printf (ph, "Checksum: File size limit has successfully been set to: %d MiB\n", limit); guchar *buffer;
else size_t *buffer_size;
hexchat_printf (ph, "Checksum: File access error while saving!\n"); char *out_buf;
} gpointer bound_data;
else } stream_async_cb_data;
{
hexchat_printf (ph, "Checksum: Invalid input!\n"); static void free_user_data(stream_async_cb_data *user_data) {
} g_free(user_data->buffer_size);
g_free(user_data->buffer);
g_checksum_free(user_data->checksum);
g_free(user_data);
} }
static int static void stream_async_cb(GObject *source_object, GAsyncResult *res,
get_limit (void) gpointer user_data) {
{ stream_async_cb_data *bound_vars = (void *)user_data;
int size = hexchat_pluginpref_get_int (ph, "limit");
if (size <= 0 || size >= INT_MAX) GInputStream *stream = G_INPUT_STREAM(source_object);
return DEFAULT_LIMIT; GError *error = NULL;
else gssize bytes_read = g_input_stream_read_finish(stream, res, &error);
return size;
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);
}
g_checksum_update(bound_vars->checksum, bound_vars->buffer, bytes_read);
return g_input_stream_read_async(
stream, bound_vars->buffer, *bound_vars->buffer_size,
G_PRIORITY_DEFAULT, NULL, stream_async_cb, user_data);
}
guint8 digest[SHA256_DIGEST_LENGTH];
gsize digest_len = sizeof(digest);
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 gboolean static void sha256_from_stream_async(GFileInputStream *file_stream,
check_limit (GFile *file) char out_buf[], async_result_cb *result_cb,
{ gpointer bound_data) {
GFileInfo *file_info;
goffset file_size;
file_info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_SIZE, G_FILE_QUERY_INFO_NONE, size_t *buffer_size = g_new(size_t, 1);
NULL, NULL);
if (!file_info) *buffer_size = BUFSIZ * sizeof(guchar);
return FALSE;
file_size = g_file_info_get_size (file_info); guchar *buffer = g_malloc(*buffer_size);
g_object_unref (file_info); GChecksum *checksum = g_checksum_new(G_CHECKSUM_SHA256);
stream_async_cb_data *user_data = g_new(stream_async_cb_data, 1);
if (file_size > get_limit () * 1048576ll) user_data->checksum = checksum;
return FALSE; 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;
return TRUE; g_input_stream_read_async(G_INPUT_STREAM(file_stream), buffer, *buffer_size,
G_PRIORITY_DEFAULT, NULL, stream_async_cb,
(void *)user_data);
} }
static gboolean typedef struct {
sha256_from_stream (GFileInputStream *file_stream, char out_buf[]) async_result_cb *result_cb;
{ GFileInputStream *file_stream;
GChecksum *checksum; char *filename;
gssize bytes_read; GFile *file;
guint8 digest[SHA256_DIGEST_LENGTH]; gpointer bound_data;
gsize digest_len = sizeof(digest); } file_async_cb_data;
guchar buffer[BUFSIZE];
gsize i;
checksum = g_checksum_new (G_CHECKSUM_SHA256); static void file_async_cb(gboolean result, gpointer user_data) {
while ((bytes_read = g_input_stream_read (G_INPUT_STREAM (file_stream), buffer, sizeof (buffer), NULL, NULL))) file_async_cb_data *bound_vars = (void *)user_data;
{
if (bytes_read == -1)
{
g_checksum_free (checksum);
return FALSE;
}
g_checksum_update (checksum, buffer, bytes_read); if (!result) {
} hexchat_printf(ph, "Checksum: Failed to generate checksum for %s\n",
bound_vars->filename);
}
g_checksum_get_digest (checksum, digest, &digest_len); g_object_unref(bound_vars->file_stream);
g_checksum_free (checksum); g_object_unref(bound_vars->file);
async_result_cb *cb = bound_vars->result_cb;
gpointer bound_data = bound_vars->bound_data;
g_free(bound_vars);
for (i = 0; i < SHA256_DIGEST_LENGTH; i++) return cb(result, bound_data);
{
/* out_buf will be exactly SHA256_BUFFER_LENGTH including null */
g_sprintf (out_buf + (i * 2), "%02x", digest[i]);
}
return TRUE;
} }
static gboolean static void sha256_from_file_async(char *filename, char out_buf[],
sha256_from_file (char *filename, char out_buf[]) async_result_cb *result_cb,
{ gpointer bound_data) {
GFileInputStream *file_stream; GFileInputStream *file_stream;
char *filename_fs; char *filename_fs;
GFile *file; GFile *file;
filename_fs = g_filename_from_utf8 (filename, -1, NULL, NULL, NULL); filename_fs = g_filename_from_utf8(filename, -1, NULL, NULL, NULL);
if (!filename_fs) if (!filename_fs) {
{ hexchat_printf(ph, "Checksum: Invalid filename (%s)\n", filename);
hexchat_printf (ph, "Checksum: Invalid filename (%s)\n", filename); return result_cb(FALSE, bound_data);
return FALSE; }
}
file = g_file_new_for_path (filename_fs); file = g_file_new_for_path(filename_fs);
g_free (filename_fs); g_free(filename_fs);
if (!file) if (!file) {
{ hexchat_printf(ph, "Checksum: Failed to open %s\n", filename);
hexchat_printf (ph, "Checksum: Failed to open %s\n", filename); return result_cb(FALSE, bound_data);
return FALSE; }
}
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;
}
file_stream = g_file_read (file, NULL, NULL); file_stream = g_file_read(file, NULL, NULL);
if (!file_stream) if (!file_stream) {
{ hexchat_printf(ph, "Checksum: Failed to read file %s\n", filename);
hexchat_printf (ph, "Checksum: Failed to read file %s\n", filename); g_object_unref(file);
g_object_unref (file); return result_cb(FALSE, bound_data);
return FALSE; }
}
if (!sha256_from_stream (file_stream, out_buf)) file_async_cb_data *user_data = g_new(file_async_cb_data, 1);
{
hexchat_printf (ph, "Checksum: Failed to generate checksum for %s\n", filename);
g_object_unref (file_stream);
g_object_unref (file);
return FALSE;
}
g_object_unref (file_stream);
g_object_unref (file); user_data->result_cb = result_cb;
return TRUE; 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);
} }
static int typedef struct {
dccrecv_cb (char *word[], void *userdata) char *checksum;
{ char *word_1;
const char *dcc_completed_dir; char *filename;
char *filename, checksum[SHA256_BUFFER_LENGTH]; } dccrecv_async_cb_data;
/* Print in the privmsg tab of the sender */ void dccrecv_async_cb(gboolean result, gpointer user_data) {
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') dccrecv_async_cb_data *bound_vars = (void *)user_data;
filename = g_build_filename (dcc_completed_dir, word[1], NULL);
else
filename = g_strdup (word[2]);
if (sha256_from_file (filename, checksum)) if (result) {
{ hexchat_printf(ph, "SHA-256 checksum for %s (local): %s\n",
hexchat_printf (ph, "SHA-256 checksum for %s (local): %s\n", word[1], checksum); bound_vars->word_1, bound_vars->checksum);
} }
g_free (filename); g_free(bound_vars->word_1);
return HEXCHAT_EAT_NONE; g_free(bound_vars->checksum);
g_free(bound_vars->filename);
g_free(bound_vars);
} }
static int static int dccrecv_cb(char *word[], void *userdata) {
dccoffer_cb (char *word[], void *userdata) const char *dcc_completed_dir;
{ char *filename;
char checksum[SHA256_BUFFER_LENGTH]; char *checksum = g_malloc(SHA256_BUFFER_LENGTH);
/* Print in the privmsg tab of the receiver */ /* Print in the privmsg tab of the sender */
hexchat_set_context (ph, hexchat_find_context (ph, NULL, word[3])); hexchat_set_context(ph, hexchat_find_context(ph, NULL, word[3]));
if (sha256_from_file (word[3], checksum)) if (hexchat_get_prefs(ph, "dcc_completed_dir", &dcc_completed_dir, NULL) ==
{ 1 &&
hexchat_commandf (ph, "quote PRIVMSG %s :SHA-256 checksum for %s (remote): %s", word[2], word[1], checksum); dcc_completed_dir[0] != '\0') {
} filename = g_build_filename(dcc_completed_dir, word[1], NULL);
} else {
filename = g_strdup(word[2]);
}
return HEXCHAT_EAT_NONE; dccrecv_async_cb_data *user_data = g_new(dccrecv_async_cb_data,1);
user_data->checksum = checksum;
char *word_1 = g_strdup(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;
} }
static int typedef struct {
checksum (char *word[], char *word_eol[], void *userdata) char *checksum;
{ char *word_1;
if (!g_ascii_strcasecmp ("GET", word[2])) char *word_2;
{ } dccoffer_async_cb_data;
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 <filesize> - set the maximum file size (in MiB) to be hashed\n");
}
return HEXCHAT_EAT_ALL; 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);
}
g_free(bound_vars->word_2);
g_free(bound_vars->word_1);
g_free(bound_vars->checksum);
g_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 = g_malloc(SHA256_BUFFER_LENGTH);
dccoffer_async_cb_data *user_data = g_new(dccoffer_async_cb_data, 1);
user_data->checksum = checksum;
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;
sha256_from_file_async(word[3], checksum, dccoffer_async_cb,
(void *)user_data);
return HEXCHAT_EAT_NONE;
} }
int int
@ -243,13 +297,6 @@ hexchat_plugin_init (hexchat_plugin *plugin_handle, char **plugin_name, char **p
*plugin_desc = desc; *plugin_desc = desc;
*plugin_version = version; *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 RECV Complete", HEXCHAT_PRI_NORM, dccrecv_cb, NULL);
hexchat_hook_print (ph, "DCC Offer", HEXCHAT_PRI_NORM, dccoffer_cb, NULL); hexchat_hook_print (ph, "DCC Offer", HEXCHAT_PRI_NORM, dccoffer_cb, NULL);