GNUnet debian-0.24.3-29-g453fda2cf
 
Loading...
Searching...
No Matches
crypto_hash_file.c File Reference

incremental hashing of files More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include <gcrypt.h>
Include dependency graph for crypto_hash_file.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_CRYPTO_FileHashContext
 Context used when hashing a file. More...
 

Macros

#define LOG(kind, ...)
 
#define LOG_STRERROR_FILE(kind, syscall, filename)
 

Functions

static void file_hash_finish (struct GNUNET_CRYPTO_FileHashContext *fhc, const struct GNUNET_HashCode *res)
 Report result of hash computation to callback and free associated resources.
 
static void file_hash_task (void *cls)
 File hashing task.
 
struct GNUNET_CRYPTO_FileHashContextGNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority, const char *filename, size_t blocksize, GNUNET_CRYPTO_HashCompletedCallback callback, void *callback_cls)
 Compute the hash of an entire file.
 
void GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc)
 Cancel a file hashing operation.
 

Detailed Description

incremental hashing of files

Author
Christian Grothoff

Definition in file crypto_hash_file.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)
Value:
GNUNET_log_from (kind, "util-crypto-hash-file", \
__VA_ARGS__)
#define GNUNET_log_from(kind, comp,...)

Definition at line 31 of file crypto_hash_file.c.

44{
49
53 void *callback_cls;
54
58 unsigned char *buffer;
59
63 char *filename;
64
68 struct GNUNET_DISK_FileHandle *fh;
69
73 gcry_md_hd_t md;
74
78 uint64_t fsize;
79
83 uint64_t offset;
84
88 struct GNUNET_SCHEDULER_Task *task;
89
94
98 size_t bsize;
99};
100
101
106static void
108 const struct GNUNET_HashCode *res)
109{
110 fhc->callback (fhc->callback_cls, res);
111 GNUNET_free (fhc->filename);
112 if (! GNUNET_DISK_handle_invalid (fhc->fh))
114 gcry_md_close (fhc->md);
115 GNUNET_free (fhc); /* also frees fhc->buffer */
116}
117
118
124static void
125file_hash_task (void *cls)
126{
127 struct GNUNET_CRYPTO_FileHashContext *fhc = cls;
128 struct GNUNET_HashCode *res;
129 size_t delta;
130 ssize_t sret;
131
132 fhc->task = NULL;
133 GNUNET_assert (fhc->offset <= fhc->fsize);
134 delta = fhc->bsize;
135 if (fhc->fsize - fhc->offset < delta)
136 delta = fhc->fsize - fhc->offset;
137 sret = GNUNET_DISK_file_read (fhc->fh,
138 fhc->buffer,
139 delta);
140 if ((sret < 0) ||
141 (delta != (size_t) sret))
142 {
144 "read",
145 fhc->filename);
146 file_hash_finish (fhc,
147 NULL);
148 return;
149 }
150 gcry_md_write (fhc->md,
151 fhc->buffer,
152 delta);
153 fhc->offset += delta;
154 if (fhc->offset == fhc->fsize)
155 {
156 res = (struct GNUNET_HashCode *) gcry_md_read (fhc->md,
157 GCRY_MD_SHA512);
158 file_hash_finish (fhc, res);
159 return;
160 }
163 fhc);
164}
165
166
169 const char *filename,
170 size_t blocksize,
172 void *callback_cls)
173{
175
176 GNUNET_assert (blocksize > 0);
177 GNUNET_assert (blocksize <= (SIZE_MAX - sizeof (*fhc)));
178 fhc =
179 GNUNET_malloc (sizeof(*fhc) + blocksize);
180 fhc->callback = callback;
182 fhc->buffer = (unsigned char *) &fhc[1];
184 if (GPG_ERR_NO_ERROR != gcry_md_open (&fhc->md, GCRY_MD_SHA512, 0))
185 {
186 GNUNET_break (0);
187 GNUNET_free (fhc->filename);
188 GNUNET_free (fhc);
189 return NULL;
190 }
191 fhc->bsize = blocksize;
192 if (GNUNET_OK !=
194 &fhc->fsize,
195 GNUNET_NO,
196 GNUNET_YES))
197 {
198 GNUNET_free (fhc->filename);
199 GNUNET_free (fhc);
200 return NULL;
201 }
205 if (! fhc->fh)
206 {
207 GNUNET_free (fhc->filename);
208 GNUNET_free (fhc);
209 return NULL;
210 }
211 fhc->priority = priority;
214 fhc);
215 return fhc;
216}
217
218
224void
226{
228 GNUNET_free (fhc->filename);
231 gcry_md_close (fhc->md);
232 GNUNET_free (fhc);
233}
234
235
236/* end of crypto_hash_file.c */
static void file_hash_task(void *cls)
File hashing task.
static void file_hash_finish(struct GNUNET_CRYPTO_FileHashContext *fhc, const struct GNUNET_HashCode *res)
Report result of hash computation to callback and free associated resources.
#define LOG_STRERROR_FILE(kind, syscall, filename)
static char * filename
static char * res
Currently read line or NULL on EOF.
static unsigned int bsize
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition disk.c:1258
enum GNUNET_GenericReturnValue GNUNET_DISK_file_size(const char *filename, uint64_t *size, int include_symbolic_links, int single_file_mode)
Get the size of the file (or directory) of the given file (in bytes).
Definition disk.c:235
enum GNUNET_GenericReturnValue GNUNET_DISK_handle_invalid(const struct GNUNET_DISK_FileHandle *h)
Checks whether a handle is invalid.
Definition disk.c:199
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition disk.c:1332
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition disk.c:673
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_PERM_NONE
Nobody is allowed to do anything to the file.
struct GNUNET_CRYPTO_FileHashContext * GNUNET_CRYPTO_hash_file(enum GNUNET_SCHEDULER_Priority priority, const char *filename, size_t blocksize, GNUNET_CRYPTO_HashCompletedCallback callback, void *callback_cls)
Compute the hash of an entire file.
void(* GNUNET_CRYPTO_HashCompletedCallback)(void *cls, const struct GNUNET_HashCode *res)
Function called once the hash computation over the specified file has completed.
void GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
Cancel a file hashing operation.
GNUNET_SCHEDULER_Priority
Valid task priorities.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_WARNING
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition scheduler.c:980
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified priority.
Definition scheduler.c:1231
#define SIZE_MAX
Definition platform.h:209
static struct GNUNET_TIME_Relative delta
Definition speedup.c:36
Context used when hashing a file.
uint64_t fsize
Size of the file.
gcry_md_hd_t md
Cumulated hash.
unsigned char * buffer
IO buffer.
GNUNET_CRYPTO_HashCompletedCallback callback
Function to call upon completion.
struct GNUNET_DISK_FileHandle * fh
File descriptor.
void * callback_cls
Closure for callback.
uint64_t offset
Current offset.
struct GNUNET_SCHEDULER_Task * task
Current task for hashing.
char * filename
Name of the file we are hashing.
enum GNUNET_SCHEDULER_Priority priority
Priority we use.
Handle used to access files (and pipes).
A 512-bit hashcode.
Entry in list of pending tasks.
Definition scheduler.c:136
enum GNUNET_SCHEDULER_Priority priority
Task priority.
Definition scheduler.c:204

◆ LOG_STRERROR_FILE

#define LOG_STRERROR_FILE (   kind,
  syscall,
  filename 
)
Value:
"util-crypto-hash-file", \
syscall, \
#define GNUNET_log_from_strerror_file(level, component, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...

Definition at line 34 of file crypto_hash_file.c.

Function Documentation

◆ file_hash_finish()

static void file_hash_finish ( struct GNUNET_CRYPTO_FileHashContext fhc,
const struct GNUNET_HashCode res 
)
static

Report result of hash computation to callback and free associated resources.

Definition at line 108 of file crypto_hash_file.c.

110{
111 fhc->callback (fhc->callback_cls, res);
112 GNUNET_free (fhc->filename);
113 if (! GNUNET_DISK_handle_invalid (fhc->fh))
115 gcry_md_close (fhc->md);
116 GNUNET_free (fhc); /* also frees fhc->buffer */
117}

References GNUNET_CRYPTO_FileHashContext::callback, GNUNET_CRYPTO_FileHashContext::callback_cls, GNUNET_CRYPTO_FileHashContext::fh, GNUNET_CRYPTO_FileHashContext::filename, GNUNET_break, GNUNET_DISK_file_close(), GNUNET_DISK_handle_invalid(), GNUNET_free, GNUNET_OK, GNUNET_CRYPTO_FileHashContext::md, and res.

Referenced by file_hash_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ file_hash_task()

static void file_hash_task ( void *  cls)
static

File hashing task.

Parameters
clsclosure

Definition at line 126 of file crypto_hash_file.c.

127{
128 struct GNUNET_CRYPTO_FileHashContext *fhc = cls;
129 struct GNUNET_HashCode *res;
130 size_t delta;
131 ssize_t sret;
132
133 fhc->task = NULL;
134 GNUNET_assert (fhc->offset <= fhc->fsize);
135 delta = fhc->bsize;
136 if (fhc->fsize - fhc->offset < delta)
137 delta = fhc->fsize - fhc->offset;
138 sret = GNUNET_DISK_file_read (fhc->fh,
139 fhc->buffer,
140 delta);
141 if ((sret < 0) ||
142 (delta != (size_t) sret))
143 {
145 "read",
146 fhc->filename);
147 file_hash_finish (fhc,
148 NULL);
149 return;
150 }
151 gcry_md_write (fhc->md,
152 fhc->buffer,
153 delta);
154 fhc->offset += delta;
155 if (fhc->offset == fhc->fsize)
156 {
157 res = (struct GNUNET_HashCode *) gcry_md_read (fhc->md,
158 GCRY_MD_SHA512);
159 file_hash_finish (fhc, res);
160 return;
161 }
164 fhc);
165}

References GNUNET_CRYPTO_FileHashContext::bsize, GNUNET_CRYPTO_FileHashContext::buffer, delta, GNUNET_CRYPTO_FileHashContext::fh, file_hash_finish(), file_hash_task(), GNUNET_CRYPTO_FileHashContext::filename, GNUNET_CRYPTO_FileHashContext::fsize, GNUNET_assert, GNUNET_DISK_file_read(), GNUNET_ERROR_TYPE_WARNING, GNUNET_SCHEDULER_add_with_priority(), LOG_STRERROR_FILE, GNUNET_CRYPTO_FileHashContext::md, GNUNET_CRYPTO_FileHashContext::offset, GNUNET_CRYPTO_FileHashContext::priority, res, and GNUNET_CRYPTO_FileHashContext::task.

Referenced by file_hash_task(), and GNUNET_CRYPTO_hash_file().

Here is the call graph for this function:
Here is the caller graph for this function: