GNUnet debian-0.24.3-3-g2b3c3659e
Disk library

Disk IO APIs. More...

Collaboration diagram for Disk library:

Data Structures

struct  GNUNET_DISK_FileHandle
 Handle used to access files (and pipes). More...
 

Enumerations

enum  GNUNET_FILE_Type { GNUNET_DISK_HANLDE_TYPE_EVENT , GNUNET_DISK_HANLDE_TYPE_FILE , GNUNET_DISK_HANLDE_TYPE_PIPE }
 Type of a handle. More...
 
enum  GNUNET_DISK_OpenFlags {
  GNUNET_DISK_OPEN_READ = 1 , GNUNET_DISK_OPEN_WRITE = 2 , GNUNET_DISK_OPEN_READWRITE = 3 , GNUNET_DISK_OPEN_FAILIFEXISTS = 4 ,
  GNUNET_DISK_OPEN_TRUNCATE = 8 , GNUNET_DISK_OPEN_CREATE = 16 , GNUNET_DISK_OPEN_APPEND = 32
}
 Specifies how a file should be opened. More...
 
enum  GNUNET_DISK_MapType { GNUNET_DISK_MAP_TYPE_READ = 1 , GNUNET_DISK_MAP_TYPE_WRITE = 2 , GNUNET_DISK_MAP_TYPE_READWRITE = 3 }
 Specifies what type of memory map is desired. More...
 
enum  GNUNET_DISK_AccessPermissions {
  GNUNET_DISK_PERM_NONE = 0 , GNUNET_DISK_PERM_USER_READ = 1 , GNUNET_DISK_PERM_USER_WRITE = 2 , GNUNET_DISK_PERM_USER_EXEC = 4 ,
  GNUNET_DISK_PERM_GROUP_READ = 8 , GNUNET_DISK_PERM_GROUP_WRITE = 16 , GNUNET_DISK_PERM_GROUP_EXEC = 32 , GNUNET_DISK_PERM_OTHER_READ = 64 ,
  GNUNET_DISK_PERM_OTHER_WRITE = 128 , GNUNET_DISK_PERM_OTHER_EXEC = 256
}
 File access permissions, UNIX-style. More...
 
enum  GNUNET_DISK_Seek { GNUNET_DISK_SEEK_SET = 0 , GNUNET_DISK_SEEK_CUR = 1 , GNUNET_DISK_SEEK_END = 2 }
 Constants for specifying how to seek. More...
 
enum  GNUNET_DISK_PipeEnd { GNUNET_DISK_PIPE_END_READ = 0 , GNUNET_DISK_PIPE_END_WRITE = 1 }
 Enumeration identifying the two ends of a pipe. More...
 
enum  GNUNET_DISK_PipeFlags { GNUNET_DISK_PF_NONE , GNUNET_DISK_PF_BLOCKING_READ = 1 , GNUNET_DISK_PF_BLOCKING_WRITE = 2 , GNUNET_DISK_PF_BLOCKING_RW }
 Flags for GNUNET_DISK_pipe(). More...
 

Functions

enum GNUNET_GenericReturnValue GNUNET_DISK_handle_invalid (const struct GNUNET_DISK_FileHandle *h)
 Checks whether a handle is invalid. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test (const char *fil)
 Check that fil corresponds to a filename (of a file that exists and that is not a directory). More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test_read (const char *fil)
 Check that fil corresponds to a filename and the file has read permissions. More...
 
char * GNUNET_DISK_file_backup (const char *fil)
 Move a file out of the way (create a backup) by renaming it to "orig.NUM~" where NUM is the smallest number that is not used yet. More...
 
off_t GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h, off_t offset, enum GNUNET_DISK_Seek whence)
 Move the read/write pointer in a file. More...
 
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). More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_file_get_identifiers (const char *filename, uint64_t *dev, uint64_t *ino)
 Obtain some unique identifiers for the given file that can be used to identify it in the local system. More...
 
char * GNUNET_DISK_mktemp (const char *t)
 Create an (empty) temporary file on disk. More...
 
char * GNUNET_DISK_mkdtemp (const char *t)
 Create an (empty) temporary directory on disk. More...
 
struct GNUNET_DISK_FileHandleGNUNET_DISK_file_open (const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
 Open a file. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_file_handle_size (struct GNUNET_DISK_FileHandle *fh, off_t *size)
 Get the size of an open file. More...
 
struct GNUNET_DISK_PipeHandleGNUNET_DISK_pipe (enum GNUNET_DISK_PipeFlags pf)
 Creates an interprocess channel. More...
 
struct GNUNET_DISK_PipeHandleGNUNET_DISK_pipe_from_fd (enum GNUNET_DISK_PipeFlags pf, int fd[2])
 Creates a pipe object from a couple of file descriptors. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p)
 Closes an interprocess channel. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close_end (struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd end)
 Closes one half of an interprocess channel. More...
 
struct GNUNET_DISK_FileHandleGNUNET_DISK_pipe_detach_end (struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd end)
 Detaches one of the ends from the pipe. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close (struct GNUNET_DISK_FileHandle *h)
 Close an open file. More...
 
const struct GNUNET_DISK_FileHandleGNUNET_DISK_pipe_handle (const struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd n)
 Get the handle to a particular pipe end. More...
 
void GNUNET_DISK_fix_permissions (const char *fn, int require_uid_match, int require_gid_match)
 Update POSIX permissions mask of a file on disk. More...
 
struct GNUNET_DISK_FileHandleGNUNET_DISK_get_handle_from_int_fd (int fno)
 Get a handle from a native integer FD. More...
 
struct GNUNET_DISK_FileHandleGNUNET_DISK_get_handle_from_native (FILE *fd)
 Get a handle from a native FD. More...
 
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. More...
 
ssize_t GNUNET_DISK_fn_read (const char *fn, void *result, size_t len)
 Read the contents of a binary file into a buffer. More...
 
ssize_t GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
 Write a buffer to a file. More...
 
ssize_t GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
 Write a buffer to a file, blocking, if necessary. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_fn_write (const char *fn, const void *buf, size_t buf_size, enum GNUNET_DISK_AccessPermissions mode)
 Write a buffer to a file atomically. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_file_copy (const char *src, const char *dst)
 Copy a file. More...
 
int GNUNET_DISK_directory_scan (const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
 Scan a directory for files. More...
 
int GNUNET_DISK_glob (const char *glob_pattern, GNUNET_FileNameCallback callback, void *callback_cls)
 Find all files matching a glob pattern. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file (const char *filename)
 Create the directory structure for storing a file. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test (const char *fil, int is_readable)
 Test if fil is a directory and listable. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove (const char *filename)
 Remove all files in a directory (rm -rf). More...
 
void GNUNET_DISK_purge_cfg_dir (const struct GNUNET_OS_ProjectData *pd, const char *cfg_filename, const char *option)
 Remove the directory given under option in section [PATHS] in configuration under cfg_filename. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create (const char *dir)
 Implementation of "mkdir -p". More...
 
void GNUNET_DISK_filename_canonicalize (char *fn)
 Removes special characters as ':' from a filename. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_file_change_owner (const char *filename, const char *user)
 Change owner of a file. More...
 
void * GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h, struct GNUNET_DISK_MapHandle **m, enum GNUNET_DISK_MapType access, size_t len)
 Map a file into memory. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_file_unmap (struct GNUNET_DISK_MapHandle *h)
 Unmap a file. More...
 
enum GNUNET_GenericReturnValue GNUNET_DISK_file_sync (const struct GNUNET_DISK_FileHandle *h)
 Write file changes to disk. More...
 

Detailed Description

Disk IO APIs.

Enumeration Type Documentation

◆ GNUNET_FILE_Type

Type of a handle.

Enumerator
GNUNET_DISK_HANLDE_TYPE_EVENT 

Handle represents an event.

GNUNET_DISK_HANLDE_TYPE_FILE 

Handle represents a file.

GNUNET_DISK_HANLDE_TYPE_PIPE 

Handle represents a pipe.

Definition at line 50 of file gnunet_disk_lib.h.

51{
56
61
66};
@ GNUNET_DISK_HANLDE_TYPE_FILE
Handle represents a file.
@ GNUNET_DISK_HANLDE_TYPE_PIPE
Handle represents a pipe.
@ GNUNET_DISK_HANLDE_TYPE_EVENT
Handle represents an event.

◆ GNUNET_DISK_OpenFlags

Specifies how a file should be opened.

Enumerator
GNUNET_DISK_OPEN_READ 

Open the file for reading.

GNUNET_DISK_OPEN_WRITE 

Open the file for writing.

GNUNET_DISK_OPEN_READWRITE 

Open the file for both reading and writing.

GNUNET_DISK_OPEN_FAILIFEXISTS 

Fail if file already exists.

GNUNET_DISK_OPEN_TRUNCATE 

Truncate file if it exists.

GNUNET_DISK_OPEN_CREATE 

Create file if it doesn't exist.

GNUNET_DISK_OPEN_APPEND 

Append to the file.

Definition at line 101 of file gnunet_disk_lib.h.

102{
107
112
117
122
127
132
137};
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_OPEN_FAILIFEXISTS
Fail if file already exists.
@ GNUNET_DISK_OPEN_WRITE
Open the file for writing.
@ GNUNET_DISK_OPEN_TRUNCATE
Truncate file if it exists.
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.
@ GNUNET_DISK_OPEN_APPEND
Append to the file.
@ GNUNET_DISK_OPEN_READWRITE
Open the file for both reading and writing.

◆ GNUNET_DISK_MapType

Specifies what type of memory map is desired.

Enumerator
GNUNET_DISK_MAP_TYPE_READ 

Read-only memory map.

GNUNET_DISK_MAP_TYPE_WRITE 

Write-able memory map.

GNUNET_DISK_MAP_TYPE_READWRITE 

Read-write memory map.

Definition at line 142 of file gnunet_disk_lib.h.

143{
148
153
158};
@ GNUNET_DISK_MAP_TYPE_WRITE
Write-able memory map.
@ GNUNET_DISK_MAP_TYPE_READ
Read-only memory map.
@ GNUNET_DISK_MAP_TYPE_READWRITE
Read-write memory map.

◆ GNUNET_DISK_AccessPermissions

File access permissions, UNIX-style.

Enumerator
GNUNET_DISK_PERM_NONE 

Nobody is allowed to do anything to the file.

GNUNET_DISK_PERM_USER_READ 

Owner can read.

GNUNET_DISK_PERM_USER_WRITE 

Owner can write.

GNUNET_DISK_PERM_USER_EXEC 

Owner can execute.

GNUNET_DISK_PERM_GROUP_READ 

Group can read.

GNUNET_DISK_PERM_GROUP_WRITE 

Group can write.

GNUNET_DISK_PERM_GROUP_EXEC 

Group can execute.

GNUNET_DISK_PERM_OTHER_READ 

Everybody can read.

GNUNET_DISK_PERM_OTHER_WRITE 

Everybody can write.

GNUNET_DISK_PERM_OTHER_EXEC 

Everybody can execute.

Definition at line 164 of file gnunet_disk_lib.h.

165{
170
175
180
185
190
195
200
205
210
215};
@ GNUNET_DISK_PERM_OTHER_EXEC
Everybody can execute.
@ GNUNET_DISK_PERM_USER_EXEC
Owner can execute.
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_NONE
Nobody is allowed to do anything to the file.
@ GNUNET_DISK_PERM_GROUP_READ
Group can read.
@ GNUNET_DISK_PERM_GROUP_EXEC
Group can execute.
@ GNUNET_DISK_PERM_GROUP_WRITE
Group can write.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
@ GNUNET_DISK_PERM_OTHER_READ
Everybody can read.
@ GNUNET_DISK_PERM_OTHER_WRITE
Everybody can write.

◆ GNUNET_DISK_Seek

Constants for specifying how to seek.

Do not change values or order, some of the code depends on the specific numeric values!

Enumerator
GNUNET_DISK_SEEK_SET 

Seek an absolute position (from the start of the file).

GNUNET_DISK_SEEK_CUR 

Seek a relative position (from the current offset).

GNUNET_DISK_SEEK_END 

Seek an absolute position from the end of the file.

Definition at line 222 of file gnunet_disk_lib.h.

223{
228
233
238};
@ GNUNET_DISK_SEEK_SET
Seek an absolute position (from the start of the file).
@ GNUNET_DISK_SEEK_CUR
Seek a relative position (from the current offset).
@ GNUNET_DISK_SEEK_END
Seek an absolute position from the end of the file.

◆ GNUNET_DISK_PipeEnd

Enumeration identifying the two ends of a pipe.

Enumerator
GNUNET_DISK_PIPE_END_READ 

The reading-end of a pipe.

GNUNET_DISK_PIPE_END_WRITE 

The writing-end of a pipe.

Definition at line 244 of file gnunet_disk_lib.h.

245{
250
255};
@ GNUNET_DISK_PIPE_END_WRITE
The writing-end of a pipe.
@ GNUNET_DISK_PIPE_END_READ
The reading-end of a pipe.

◆ GNUNET_DISK_PipeFlags

Flags for GNUNET_DISK_pipe().

Enumerator
GNUNET_DISK_PF_NONE 

No special options, use non-blocking read/write operations.

GNUNET_DISK_PF_BLOCKING_READ 

Configure read end to block when reading if set.

GNUNET_DISK_PF_BLOCKING_WRITE 

Configure write end to block when writing if set.

GNUNET_DISK_PF_BLOCKING_RW 

Configure both pipe ends for blocking operations if set.

Definition at line 419 of file gnunet_disk_lib.h.

420{
421
426
431
436
442
443};
@ GNUNET_DISK_PF_NONE
No special options, use non-blocking read/write operations.
@ GNUNET_DISK_PF_BLOCKING_WRITE
Configure write end to block when writing if set.
@ GNUNET_DISK_PF_BLOCKING_RW
Configure both pipe ends for blocking operations if set.
@ GNUNET_DISK_PF_BLOCKING_READ
Configure read end to block when reading if set.

Function Documentation

◆ GNUNET_DISK_handle_invalid()

enum GNUNET_GenericReturnValue GNUNET_DISK_handle_invalid ( const struct GNUNET_DISK_FileHandle h)

Checks whether a handle is invalid.

Parameters
hhandle to check
Returns
GNUNET_YES if invalid, GNUNET_NO if valid

Definition at line 199 of file disk.c.

200{
201 return ((! h) || (h->fd == -1)) ? GNUNET_YES : GNUNET_NO;
202}
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:98
@ GNUNET_YES
@ GNUNET_NO

References GNUNET_NO, GNUNET_YES, and h.

Referenced by decrementBit(), file_hash_finish(), incrementBit(), maint_child_death(), and shutdown_pipe_cb().

Here is the caller graph for this function:

◆ GNUNET_DISK_file_test()

enum GNUNET_GenericReturnValue GNUNET_DISK_file_test ( const char *  fil)

Check that fil corresponds to a filename (of a file that exists and that is not a directory).

Parameters
filfilename to check
Returns
GNUNET_YES if yes, GNUNET_NO if not a file, GNUNET_SYSERR if something else (will print an error message in that case, too).

Definition at line 533 of file disk.c.

534{
535 return file_test_internal (fil, F_OK);
536}
static enum GNUNET_GenericReturnValue file_test_internal(const char *fil, int amode)
Check if fil can be accessed using amode.
Definition: disk.c:494

References file_test_internal().

Referenced by callback_scan_for_operations(), create_download_context(), create_unique_cfgs(), database_connect(), database_setup(), ego_callback(), get_path_from_PATH(), get_topo_string_from_file(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_DISK_file_open(), GNUNET_FS_download_start_task_(), GNUNET_HOSTLIST_client_start(), GNUNET_PROGRAM_conf_and_options(), GNUNET_PROGRAM_run2(), GNUNET_SERVICE_run_(), GNUNET_TRANSPORT_TESTING_start_peer(), hosts_directory_scan_callback(), load_hostlist_file(), load_list_messages(), load_list_tunnels(), load_member(), load_member_session(), load_member_session_history(), load_member_session_next(), load_message_store(), load_peer_store(), load_search_strings(), main(), PABC_load_public_parameters(), print_key(), read_file(), read_index_list(), read_update_information_graph(), restore_valid_peers(), run(), and start_peer_run().

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

◆ GNUNET_DISK_file_test_read()

enum GNUNET_GenericReturnValue GNUNET_DISK_file_test_read ( const char *  fil)

Check that fil corresponds to a filename and the file has read permissions.

Parameters
filfilename to check
Returns
GNUNET_YES if yes, GNUNET_NO if file doesn't exist or has no read permissions, GNUNET_SYSERR if something else (will print an error message in that case, too).

Definition at line 540 of file disk.c.

541{
542 return file_test_internal (fil, R_OK);
543}

References file_test_internal().

Referenced by GNUNET_CONFIGURATION_default_filename(), GNUNET_PQ_exec_sql(), and handle_inline().

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

◆ GNUNET_DISK_file_backup()

char * GNUNET_DISK_file_backup ( const char *  fil)

Move a file out of the way (create a backup) by renaming it to "orig.NUM~" where NUM is the smallest number that is not used yet.

Parameters
filname of the file to back up
Returns
the backup file name (must be freed by caller)

Definition at line 373 of file disk.c.

374{
375 size_t slen;
376 char *target;
377 unsigned int num;
378
379 slen = strlen (fil) + 20;
380 target = GNUNET_malloc (slen);
381 num = 0;
382
383#if HAVE_RENAMEAT2
384 {
385 int fd;
386
387 do
388 {
389 GNUNET_snprintf (target,
390 slen,
391 "%s.%u~",
392 fil,
393 num++);
394 fd = open (target,
395 O_CREAT | O_EXCL,
397 } while (-1 == fd);
398 if (0 != renameat2 (AT_FDCWD,
399 fil,
400 AT_FDCWD,
401 target,
402 RENAME_EXCHANGE))
403 {
405 "renameat2",
406 fil);
407 GNUNET_break (0 ==
408 close (fd));
409 return NULL;
410 }
411 GNUNET_break (0 ==
412 close (fd));
413 }
414#else
415 do
416 {
417 GNUNET_snprintf (target, slen, "%s.%u~", fil, num++);
418 }
419 while (0 == access (target, F_OK));
420 if (0 != rename (fil, target))
421 {
423 return NULL;
424 }
425#endif
426 return target;
427}
static int translate_unix_perms(enum GNUNET_DISK_AccessPermissions perm)
Translate GNUnet-internal permission bitmap to UNIX file access permission bitmap.
Definition: disk.c:109
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_ERROR
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_malloc(size)
Wrapper around malloc.

References GNUNET_break, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_ERROR, GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_snprintf(), and translate_unix_perms().

Here is the call graph for this function:

◆ GNUNET_DISK_file_seek()

off_t GNUNET_DISK_file_seek ( const struct GNUNET_DISK_FileHandle h,
off_t  offset,
enum GNUNET_DISK_Seek  whence 
)

Move the read/write pointer in a file.

Parameters
hhandle of an open file
offsetposition to move to
whencespecification to which position the offset parameter relates to
Returns
the new position on success, GNUNET_SYSERR otherwise

Definition at line 219 of file disk.c.

222{
223 static int t[] = { SEEK_SET, SEEK_CUR, SEEK_END };
224
225 if (h == NULL)
226 {
227 errno = EINVAL;
228 return GNUNET_SYSERR;
229 }
230 return lseek (h->fd, offset, t[whence]);
231}
static struct GNUNET_SCHEDULER_Task * t
Main task.
@ GNUNET_SYSERR

References GNUNET_SYSERR, h, and t.

Referenced by decrementBit(), delete_store_message(), fh_reader(), get_store_message(), GNUNET_FS_data_reader_file_(), GNUNET_FS_handle_on_demand_block(), incrementBit(), iterate_save_messages(), load_list_messages(), load_list_tunnels(), load_member_session_history(), load_peer_store(), process_result_with_request(), read_file(), save_list_messages(), save_list_tunnels(), save_member_session_history(), save_message_store(), save_peer_store(), try_top_down_reconstruction(), and unindex_reader().

Here is the caller graph for this function:

◆ GNUNET_DISK_file_size()

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).

Parameters
filenamename of the file or directory
sizeset to the size of the file (or, in the case of directories, the sum of all sizes of files in the directory)
include_symbolic_linksshould symbolic links be included?
single_file_modeGNUNET_YES to only get size of one file and return GNUNET_SYSERR for directories.
Returns
GNUNET_SYSERR on error, GNUNET_OK on success

Definition at line 235 of file disk.c.

239{
240 struct GetFileSizeData gfsd;
242
243 GNUNET_assert (size != NULL);
244 gfsd.total = 0;
245 gfsd.include_sym_links = include_symbolic_links;
246 gfsd.single_file_mode = single_file_mode;
247 ret = get_size_rec (&gfsd, filename);
248 *size = gfsd.total;
249 return ret;
250}
static enum GNUNET_GenericReturnValue get_size_rec(void *cls, const char *fn)
Iterate over all files in the given directory and accumulate their size.
Definition: disk.c:146
static int ret
Final status code.
Definition: gnunet-arm.c:93
static char * filename
GNUNET_GenericReturnValue
Named constants for return values.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static unsigned int size
Size of the "table".
Definition: peer.c:68
Closure for the recursion to determine the file size of a directory.
Definition: disk.c:83
int single_file_mode
GNUNET_YES if mode is file-only (return total == -1 for directories).
Definition: disk.c:97

References filename, get_size_rec(), GNUNET_assert, GetFileSizeData::include_sym_links, ret, GetFileSizeData::single_file_mode, size, and GetFileSizeData::total.

Referenced by create_download_context(), database_setup(), get_topo_string_from_file(), GNUNET_CONFIGURATION_parse(), GNUNET_CRYPTO_hash_file(), GNUNET_DISK_file_copy(), GNUNET_FS_file_information_create_from_file(), GNUNET_FS_unindex_start(), load(), load_file(), load_search_strings(), preprocess_file(), print_key(), and run().

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

◆ GNUNET_DISK_file_get_identifiers()

enum GNUNET_GenericReturnValue GNUNET_DISK_file_get_identifiers ( const char *  filename,
uint64_t *  dev,
uint64_t *  ino 
)

Obtain some unique identifiers for the given file that can be used to identify it in the local system.

This function is used between GNUnet processes to quickly check if two files with the same absolute path are actually identical. The two processes represent the same peer but may communicate over the network (and the file may be on an NFS volume). This function may not be supported on all operating systems.

Parameters
filenamename of the file
devset to the device ID
inoset to the inode ID
Returns
GNUNET_OK on success

Definition at line 254 of file disk.c.

257{
258#if HAVE_STAT
259 {
260 struct stat sbuf;
261
262 if (0 != stat (filename, &sbuf))
263 {
264 return GNUNET_SYSERR;
265 }
266 *ino = (uint64_t) sbuf.st_ino;
267 }
268#else
269 *ino = 0;
270#endif
271#if HAVE_STATVFS
272 {
273 struct statvfs fbuf;
274
275 if (0 != statvfs (filename, &fbuf))
276 {
277 return GNUNET_SYSERR;
278 }
279 *dev = (uint64_t) fbuf.f_fsid;
280 }
281#elif HAVE_STATFS
282 {
283 struct statfs fbuf;
284
285 if (0 != statfs (filename, &fbuf))
286 {
287 return GNUNET_SYSERR;
288 }
289 *dev =
290 ((uint64_t) fbuf.f_fsid.val[0]) << 32 || ((uint64_t) fbuf.f_fsid.val[1]);
291 }
292#else
293 *dev = 0;
294#endif
295 return GNUNET_OK;
296}
@ GNUNET_OK

References filename, GNUNET_OK, and GNUNET_SYSERR.

Referenced by handle_client_index_start(), and hash_for_index_cb().

Here is the caller graph for this function:

◆ GNUNET_DISK_mktemp()

char * GNUNET_DISK_mktemp ( const char *  t)

Create an (empty) temporary file on disk.

If the given name is not an absolute path, the current 'TMPDIR' will be prepended. In any case, 6 random characters will be appended to the name to create a unique filename.

Parameters
tcomponent to use for the name; does NOT contain "XXXXXX" or "/tmp/".
Returns
NULL on error, otherwise name of fresh file on disk in directory for temporary files

Definition at line 431 of file disk.c.

432{
433 int fd;
434 char *fn;
435 mode_t omask;
436
437 omask = umask (S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
438 fn = mktemp_name (t);
439 if (-1 == (fd = mkstemp (fn)))
440 {
442 GNUNET_free (fn);
443 umask (omask);
444 return NULL;
445 }
446 umask (omask);
447 if (0 != close (fd))
449 return fn;
450}
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: disk.c:36
static char * mktemp_name(const char *t)
Create the name for a temporary file or directory from a template.
Definition: disk.c:306
@ GNUNET_ERROR_TYPE_WARNING
#define GNUNET_free(ptr)
Wrapper around free.

References GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, LOG_STRERROR_FILE, mktemp_name(), and t.

Referenced by create_download_context(), GNUNET_DATACACHE_create(), GNUNET_FS_download_sync_(), libgnunet_plugin_datacache_sqlite_init(), make_serialization_file_name(), and make_serialization_file_name_in_dir().

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

◆ GNUNET_DISK_mkdtemp()

char * GNUNET_DISK_mkdtemp ( const char *  t)

Create an (empty) temporary directory on disk.

If the given name is not an absolute path, the current 'TMPDIR' will be prepended. In any case, 6 random characters will be appended to the name to create a unique name.

Parameters
tcomponent to use for the name; does NOT contain "XXXXXX" or "/tmp/".
Returns
NULL on error, otherwise name of freshly created directory

Definition at line 353 of file disk.c.

354{
355 char *fn;
356 mode_t omask;
357
358 omask = umask (S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
359 fn = mktemp_name (t);
360 if (fn != mkdtemp (fn))
361 {
363 GNUNET_free (fn);
364 umask (omask);
365 return NULL;
366 }
367 umask (omask);
368 return fn;
369}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_free, LOG_STRERROR_FILE, mktemp_name(), and t.

Referenced by create_response(), and GNUNET_TESTBED_system_create_with_portrange().

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

◆ GNUNET_DISK_file_open()

struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open ( const char *  fn,
enum GNUNET_DISK_OpenFlags  flags,
enum GNUNET_DISK_AccessPermissions  perm 
)

Open a file.

Note that the access permissions will only be used if a new file is created and if the underlying operating system supports the given permissions.

Parameters
fnfile name to be opened
flagsopening flags, a combination of GNUNET_DISK_OPEN_xxx bit flags
permpermissions for the newly created file, use GNUNET_DISK_PERM_NONE if a file could not be created by this call (because of flags)
Returns
IO handle on success, NULL on error

Definition at line 1258 of file disk.c.

1261{
1262 char *expfn;
1264
1265 int oflags;
1266 int mode;
1267 int fd;
1268
1269 expfn = GNUNET_STRINGS_filename_expand (fn);
1270 if (NULL == expfn)
1271 return NULL;
1272
1273 mode = 0;
1275 oflags = O_RDWR; /* note: O_RDWR is NOT always O_RDONLY | O_WRONLY */
1276 else if (flags & GNUNET_DISK_OPEN_READ)
1277 oflags = O_RDONLY;
1278 else if (flags & GNUNET_DISK_OPEN_WRITE)
1279 oflags = O_WRONLY;
1280 else
1281 {
1282 GNUNET_break (0);
1283 GNUNET_free (expfn);
1284 return NULL;
1285 }
1287 oflags |= (O_CREAT | O_EXCL);
1288 if (flags & GNUNET_DISK_OPEN_TRUNCATE)
1289 oflags |= O_TRUNC;
1290 if (flags & GNUNET_DISK_OPEN_APPEND)
1291 oflags |= O_APPEND;
1292 if (GNUNET_NO == GNUNET_DISK_file_test (fn))
1293 {
1294 if (flags & GNUNET_DISK_OPEN_CREATE)
1295 {
1297 oflags |= O_CREAT;
1298 mode = translate_unix_perms (perm);
1299 }
1300 }
1301
1302 // Setting O_CLOEXEC after pipe() may introduce
1303 // race conditions: https://bugs.gnunet.org/view.php?id=9311
1304 // This is no problem if the platform supports pipe2
1305 fd = open (expfn,
1306 oflags
1307#if O_CLOEXEC
1308 | O_CLOEXEC
1309#endif
1310 | O_LARGEFILE,
1311 mode);
1312 if (fd == -1)
1313 {
1314 if (0 == (flags & GNUNET_DISK_OPEN_FAILIFEXISTS))
1316 else
1318 GNUNET_free (expfn);
1319 return NULL;
1320 }
1321
1323
1324 ret->fd = fd;
1325
1326 GNUNET_free (expfn);
1327 return ret;
1328}
static enum @44 mode
Should we do a PUT (mode = 0) or GET (mode = 1);.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:533
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:633
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:506
#define O_LARGEFILE
Definition: platform.h:213
Handle used to access files (and pipes).
int fd
File handle on Unix-like systems.

References GNUNET_DISK_FileHandle::fd, GNUNET_break, GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_file_test(), GNUNET_DISK_OPEN_APPEND, GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_FAILIFEXISTS, GNUNET_DISK_OPEN_READ, GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_OPEN_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_new, GNUNET_NO, GNUNET_STRINGS_filename_expand(), LOG_STRERROR_FILE, mode, O_LARGEFILE, ret, and translate_unix_perms().

Referenced by database_setup(), database_shutdown(), full_recursive_download(), get_file_handle(), GNUNET_BIO_read_open_file(), GNUNET_BIO_write_open_file(), GNUNET_CONFIGURATION_write(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_CRYPTO_hash_file(), GNUNET_DISK_file_copy(), GNUNET_DISK_fn_read(), GNUNET_FS_data_reader_file_(), GNUNET_FS_download_start_task_(), GNUNET_FS_handle_on_demand_block(), GNUNET_FS_unindex_do_remove_(), GNUNET_TIME_absolute_get_monotonic(), load_etc_hosts(), load_list_messages(), load_list_tunnels(), load_member_session_history(), load_message_store(), load_message_store_entries(), load_message_store_links(), load_peer_store(), lookup_dns_servers(), open_static_resource(), print_key(), process_result_with_request(), read_file(), read_from_log(), REGEX_TEST_read_from_file(), restore_valid_peers(), run(), save_list_messages(), save_list_tunnels(), save_member_session_history(), save_message_store(), save_peer_store(), start_dump(), start_insert(), store_valid_peers(), to_file_raw(), try_match_block(), write_benchmark_data(), and write_file().

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

◆ GNUNET_DISK_file_handle_size()

enum GNUNET_GenericReturnValue GNUNET_DISK_file_handle_size ( struct GNUNET_DISK_FileHandle fh,
off_t *  size 
)

Get the size of an open file.

Parameters
fhopen file handle
sizewhere to write size of the file
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 206 of file disk.c.

208{
209 struct stat sbuf;
210
211 if (0 != fstat (fh->fd, &sbuf))
212 return GNUNET_SYSERR;
213 *size = sbuf.st_size;
214 return GNUNET_OK;
215}

References GNUNET_DISK_FileHandle::fd, GNUNET_OK, GNUNET_SYSERR, and size.

Referenced by GNUNET_CONTAINER_bloomfilter_load(), GNUNET_TIME_absolute_get_monotonic(), load_etc_hosts(), lookup_dns_servers(), open_static_resource(), REGEX_TEST_read_from_file(), and restore_valid_peers().

Here is the caller graph for this function:

◆ GNUNET_DISK_pipe()

struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe ( enum GNUNET_DISK_PipeFlags  pf)

Creates an interprocess channel.

Parameters
pfhow to configure the pipe
Returns
handle to the new pipe, NULL on error

Definition at line 1468 of file disk.c.

1469{
1470 int fd[2];
1471
1472#if HAVE_PIPE2 && O_CLOEXEC
1473 if (-1 == pipe2 (fd, O_CLOEXEC))
1474#else
1475 if (-1 == pipe (fd))
1476#endif
1477 {
1478 int eno = errno;
1479
1481 errno = eno;
1482 return NULL;
1483 }
1484 return GNUNET_DISK_pipe_from_fd (pf, fd);
1485}
#define LOG_STRERROR(kind, syscall)
Definition: disk.c:33
struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe_from_fd(enum GNUNET_DISK_PipeFlags pf, int fd[2])
Creates a pipe object from a couple of file descriptors.
Definition: disk.c:1489

References GNUNET_DISK_PipeHandle::fd, GNUNET_DISK_pipe_from_fd(), GNUNET_ERROR_TYPE_ERROR, and LOG_STRERROR.

Referenced by child_management_start(), GNUNET_ARM_request_service_start(), GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_OS_command_run(), GNUNET_SCHEDULER_driver_init(), main(), restart_nat_server(), run(), start_helper(), and start_process().

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

◆ GNUNET_DISK_pipe_from_fd()

struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe_from_fd ( enum GNUNET_DISK_PipeFlags  pf,
int  fd[2] 
)

Creates a pipe object from a couple of file descriptors.

Useful for wrapping existing pipe FDs.

Parameters
pfhow to configure the pipe
fdan array of two fd values. One of them may be -1 for read-only or write-only pipes
Returns
handle to the new pipe, NULL on error

Definition at line 1489 of file disk.c.

1491{
1492 struct GNUNET_DISK_PipeHandle *p;
1493 int ret = 0;
1494 int flags;
1495 int eno = 0; /* make gcc happy */
1496
1498 if (fd[0] >= 0)
1499 {
1500 p->fd[0] = GNUNET_new (struct GNUNET_DISK_FileHandle);
1501 p->fd[0]->fd = fd[0];
1502 if (0 == (GNUNET_DISK_PF_BLOCKING_READ & pf))
1503 {
1504 flags = fcntl (fd[0], F_GETFL);
1505 flags |= O_NONBLOCK;
1506 if (0 > fcntl (fd[0], F_SETFL, flags))
1507 {
1508 ret = -1;
1509 eno = errno;
1510 }
1511 }
1512 flags = fcntl (fd[0], F_GETFD);
1513 flags |= FD_CLOEXEC;
1514 if (0 > fcntl (fd[0], F_SETFD, flags))
1515 {
1516 ret = -1;
1517 eno = errno;
1518 }
1519 }
1520
1521 if (fd[1] >= 0)
1522 {
1523 p->fd[1] = GNUNET_new (struct GNUNET_DISK_FileHandle);
1524 p->fd[1]->fd = fd[1];
1525 if (0 == (GNUNET_DISK_PF_BLOCKING_WRITE & pf))
1526 {
1527 flags = fcntl (fd[1], F_GETFL);
1528 flags |= O_NONBLOCK;
1529 if (0 > fcntl (fd[1], F_SETFL, flags))
1530 {
1531 ret = -1;
1532 eno = errno;
1533 }
1534 }
1535 flags = fcntl (fd[1], F_GETFD);
1536 flags |= FD_CLOEXEC;
1537 if (0 > fcntl (fd[1], F_SETFD, flags))
1538 {
1539 ret = -1;
1540 eno = errno;
1541 }
1542 }
1543 if (ret == -1)
1544 {
1545 errno = eno;
1547 if (p->fd[0]->fd >= 0)
1548 GNUNET_break (0 == close (p->fd[0]->fd));
1549 if (p->fd[1]->fd >= 0)
1550 GNUNET_break (0 == close (p->fd[1]->fd));
1551 GNUNET_free (p->fd[0]);
1552 GNUNET_free (p->fd[1]);
1553 GNUNET_free (p);
1554 errno = eno;
1555 return NULL;
1556 }
1557 return p;
1558}
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
Handle used to manage a pipe.
Definition: disk.c:69
struct GNUNET_DISK_FileHandle * fd[2]
File descriptors for the pipe.
Definition: disk.c:74

References GNUNET_DISK_PipeHandle::fd, GNUNET_break, GNUNET_DISK_PF_BLOCKING_READ, GNUNET_DISK_PF_BLOCKING_WRITE, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_new, LOG_STRERROR, p, and ret.

Referenced by GNUNET_DISK_pipe().

Here is the caller graph for this function:

◆ GNUNET_DISK_pipe_close()

enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close ( struct GNUNET_DISK_PipeHandle p)

Closes an interprocess channel.

Parameters
ppipe
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1615 of file disk.c.

1616{
1618 enum GNUNET_GenericReturnValue read_end_close;
1619 enum GNUNET_GenericReturnValue write_end_close;
1620 int read_end_close_errno;
1621 int write_end_close_errno;
1622
1624 read_end_close_errno = errno;
1626 write_end_close_errno = errno;
1627 GNUNET_free (p);
1628
1629 if (GNUNET_OK != read_end_close)
1630 {
1631 errno = read_end_close_errno;
1632 ret = read_end_close;
1633 }
1634 else if (GNUNET_OK != write_end_close)
1635 {
1636 errno = write_end_close_errno;
1637 ret = write_end_close;
1638 }
1639
1640 return ret;
1641}
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd end)
Closes one half of an interprocess channel.
Definition: disk.c:1562

References GNUNET_DISK_pipe_close_end(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, GNUNET_free, GNUNET_OK, p, and ret.

Referenced by child_management_done(), GN_stop_gnunet_nat_server_(), GNUNET_ARM_request_service_start(), GNUNET_HELPER_kill(), GNUNET_HELPER_wait(), GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_NAT_mini_get_external_ipv4_cancel_(), GNUNET_OS_command_run(), GNUNET_OS_command_stop(), GNUNET_SCHEDULER_driver_done(), main(), nat_server_read(), restart_nat_server(), shutdown_task(), and start_process().

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

◆ GNUNET_DISK_pipe_close_end()

enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close_end ( struct GNUNET_DISK_PipeHandle p,
enum GNUNET_DISK_PipeEnd  end 
)

Closes one half of an interprocess channel.

Parameters
ppipe to close end of
endwhich end of the pipe to close
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1562 of file disk.c.

1564{
1566
1568 {
1569 if (p->fd[0])
1570 {
1571 ret = GNUNET_DISK_file_close (p->fd[0]);
1572 p->fd[0] = NULL;
1573 }
1574 }
1575 else if (end == GNUNET_DISK_PIPE_END_WRITE)
1576 {
1577 if (p->fd[1])
1578 {
1579 ret = GNUNET_DISK_file_close (p->fd[1]);
1580 p->fd[1] = NULL;
1581 }
1582 }
1583 return ret;
1584}
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:33
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1332

References end, GNUNET_DISK_file_close(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, GNUNET_OK, p, and ret.

Referenced by GNUNET_DISK_pipe_close(), GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_OS_command_run(), restart_nat_server(), and start_helper().

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

◆ GNUNET_DISK_pipe_detach_end()

struct GNUNET_DISK_FileHandle * GNUNET_DISK_pipe_detach_end ( struct GNUNET_DISK_PipeHandle p,
enum GNUNET_DISK_PipeEnd  end 
)

Detaches one of the ends from the pipe.

Detached end is a fully-functional FileHandle, it will not be affected by anything you do with the pipe afterwards. Each end of a pipe can only be detched from it once (i.e. it is not duplicated).

Parameters
ppipe to detach an end from
endwhich end of the pipe to detach
Returns
Detached end on success, NULL on failure (or if that end is not present or is closed).

Definition at line 1588 of file disk.c.

1590{
1591 struct GNUNET_DISK_FileHandle *ret = NULL;
1592
1594 {
1595 if (p->fd[0])
1596 {
1597 ret = p->fd[0];
1598 p->fd[0] = NULL;
1599 }
1600 }
1601 else if (end == GNUNET_DISK_PIPE_END_WRITE)
1602 {
1603 if (p->fd[1])
1604 {
1605 ret = p->fd[1];
1606 p->fd[1] = NULL;
1607 }
1608 }
1609
1610 return ret;
1611}

References end, GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, p, and ret.

Referenced by GNUNET_ARM_request_service_start(), and start_process().

Here is the caller graph for this function:

◆ GNUNET_DISK_file_close()

enum GNUNET_GenericReturnValue GNUNET_DISK_file_close ( struct GNUNET_DISK_FileHandle h)

Close an open file.

Parameters
hfile handle
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1332 of file disk.c.

1333{
1335
1336 if (NULL == h)
1337 {
1338 errno = EINVAL;
1339 return GNUNET_SYSERR;
1340 }
1341
1342 ret = GNUNET_OK;
1343 if (0 != close (h->fd))
1344 {
1347 }
1348 GNUNET_free (h);
1349 return ret;
1350}

References GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_OK, GNUNET_SYSERR, h, LOG_STRERROR, and ret.

Referenced by check_completed(), clear_message_store(), close_files_iter(), database_setup(), database_shutdown(), do_shutdown(), file_hash_finish(), full_recursive_download(), get_cb(), GNUNET_ARM_operation_cancel(), GNUNET_ARM_request_service_start(), GNUNET_BIO_flush(), GNUNET_BIO_read_close(), GNUNET_BIO_write_close(), GNUNET_CONFIGURATION_write(), GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_CRYPTO_hash_file_cancel(), GNUNET_DISK_file_copy(), GNUNET_DISK_fn_read(), GNUNET_DISK_pipe_close_end(), GNUNET_FS_data_reader_file_(), GNUNET_FS_download_signal_suspend_(), GNUNET_FS_download_start_task_(), GNUNET_FS_handle_on_demand_block(), GNUNET_FS_unindex_signal_suspend_(), GNUNET_FS_unindex_stop(), GNUNET_OS_process_destroy(), GNUNET_TIME_absolute_get_monotonic(), load_etc_hosts(), load_list_messages(), load_list_tunnels(), load_member_session_history(), load_message_store(), load_message_store_entries(), load_message_store_links(), load_peer_store(), lookup_dns_servers(), notify_starting(), open_static_resource(), parent_control_handler(), print_key(), process_result_with_request(), read_file(), reconstruct_cont(), REGEX_TEST_read_from_file(), restore_valid_peers(), run(), save_list_messages(), save_list_tunnels(), save_member_session_history(), save_message_store(), save_peer_store(), shutdown_pch(), shutdown_task(), start_process(), store_valid_peers(), to_file_raw(), try_match_block(), unindex_finish(), write_benchmark_data(), and write_file().

◆ GNUNET_DISK_pipe_handle()

const struct GNUNET_DISK_FileHandle * GNUNET_DISK_pipe_handle ( const struct GNUNET_DISK_PipeHandle p,
enum GNUNET_DISK_PipeEnd  n 
)

Get the handle to a particular pipe end.

Parameters
ppipe
nend to access
Returns
handle for the respective end

Definition at line 1645 of file disk.c.

1647{
1648 switch (n)
1649 {
1652 return p->fd[n];
1653
1654 default:
1655 GNUNET_break (0);
1656 return NULL;
1657 }
1658}

References GNUNET_break, GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, and p.

Referenced by GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_OS_command_run(), GNUNET_SCHEDULER_driver_init(), GNUNET_wait_child(), initiate_put_from_pipe_trigger(), maint_child_death(), restart_nat_server(), run(), shutdown_pipe_cb(), sighandler_child_death(), sighandler_shutdown(), sign_worker(), start_helper(), start_process(), and work().

Here is the caller graph for this function:

◆ GNUNET_DISK_fix_permissions()

void GNUNET_DISK_fix_permissions ( const char *  fn,
int  require_uid_match,
int  require_gid_match 
)

Update POSIX permissions mask of a file on disk.

If both arguments are GNUNET_NO, the file is made world-read-write-executable (777). Does nothing on W32.

Parameters
fnname of the file to update
require_uid_matchGNUNET_YES means 700
require_gid_matchGNUNET_YES means 770 unless require_uid_match is set

Definition at line 334 of file disk.c.

337{
338 mode_t mode;
339
340 if (GNUNET_YES == require_uid_match)
341 mode = S_IRUSR | S_IWUSR | S_IXUSR;
342 else if (GNUNET_YES == require_gid_match)
343 mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP;
344 else
345 mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH
346 | S_IWOTH | S_IXOTH;
347 if (0 != chmod (fn, mode))
349}

References GNUNET_ERROR_TYPE_WARNING, GNUNET_log_strerror_file, GNUNET_YES, and mode.

Referenced by create_listen_socket().

Here is the caller graph for this function:

◆ GNUNET_DISK_get_handle_from_int_fd()

struct GNUNET_DISK_FileHandle * GNUNET_DISK_get_handle_from_int_fd ( int  fno)

Get a handle from a native integer FD.

Parameters
fnonative integer file descriptor
Returns
file handle corresponding to the descriptor

Definition at line 1354 of file disk.c.

1355{
1356 struct GNUNET_DISK_FileHandle *fh;
1357
1358 if ((((off_t) -1) == lseek (fno, 0, SEEK_CUR)) && (EBADF == errno))
1359 return NULL; /* invalid FD */
1360
1361 fh = GNUNET_new (struct GNUNET_DISK_FileHandle);
1362
1363 fh->fd = fno;
1364
1365 return fh;
1366}

References GNUNET_DISK_FileHandle::fd, and GNUNET_new.

Referenced by extract_handles(), GNUNET_DISK_get_handle_from_native(), GNUNET_OS_install_parent_control_handler(), main(), start_dump(), and start_insert().

Here is the caller graph for this function:

◆ GNUNET_DISK_get_handle_from_native()

struct GNUNET_DISK_FileHandle * GNUNET_DISK_get_handle_from_native ( FILE *  fd)

Get a handle from a native FD.

Parameters
fdnative file descriptor
Returns
file handle corresponding to the descriptor

Definition at line 1370 of file disk.c.

1371{
1372 int fno;
1373
1374 fno = fileno (fd);
1375 if (-1 == fno)
1376 return NULL;
1378}
struct GNUNET_DISK_FileHandle * GNUNET_DISK_get_handle_from_int_fd(int fno)
Get a handle from a native integer FD.
Definition: disk.c:1354

References GNUNET_DISK_FileHandle::fd, and GNUNET_DISK_get_handle_from_int_fd().

Referenced by run().

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

◆ GNUNET_DISK_file_read()

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.

Parameters
hhandle to an open file
resultthe buffer to write the result to
lenthe maximum number of bytes to read
Returns
the number of bytes read on success, GNUNET_SYSERR on failure

Definition at line 673 of file disk.c.

676{
677 if (NULL == h)
678 {
679 errno = EINVAL;
680 return GNUNET_SYSERR;
681 }
682 return read (h->fd, result, len);
683}
static int result
Global testing status.

References GNUNET_SYSERR, h, and result.

Referenced by cmd_read(), database_setup(), decrementBit(), fh_reader(), file_hash_task(), get_store_message(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_DISK_file_copy(), GNUNET_DISK_fn_read(), GNUNET_FS_data_reader_file_(), GNUNET_FS_handle_on_demand_block(), helper_read(), incrementBit(), initiate_put_from_pipe_trigger(), load_list_messages(), load_list_tunnels(), load_member_session_history(), load_peer_store(), maint_child_death(), nat_server_read(), parent_control_handler(), print_key(), put_cb(), read_external_ipv4(), read_file(), read_from_file(), read_task(), REGEX_TEST_read_from_file(), restore_valid_peers(), run(), shutdown_pipe_cb(), start_insert(), try_top_down_reconstruction(), and unindex_reader().

Here is the caller graph for this function:

◆ GNUNET_DISK_fn_read()

ssize_t GNUNET_DISK_fn_read ( const char *  fn,
void *  result,
size_t  len 
)

Read the contents of a binary file into a buffer.

Parameters
fnfile name
resultthe buffer to write the result to
lenthe maximum number of bytes to read
Returns
number of bytes read, GNUNET_SYSERR on failure

Definition at line 687 of file disk.c.

690{
691 struct GNUNET_DISK_FileHandle *fh;
692 ssize_t ret;
693 int eno;
694
695 fh = GNUNET_DISK_file_open (fn,
698 if (NULL == fh)
699 return GNUNET_SYSERR;
700 ret = GNUNET_DISK_file_read (fh, result, len);
701 eno = errno;
704 errno = eno;
705 return ret;
706}
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
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

References GNUNET_assert, GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_OK, GNUNET_SYSERR, result, and ret.

Referenced by ego_callback(), get_topo_string_from_file(), GNUNET_CONFIGURATION_parse(), hosts_directory_scan_callback(), load_file(), load_search_strings(), and run().

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

◆ GNUNET_DISK_file_write()

ssize_t GNUNET_DISK_file_write ( const struct GNUNET_DISK_FileHandle h,
const void *  buffer,
size_t  n 
)

Write a buffer to a file.

Parameters
hhandle to open file
bufferthe data to write
nnumber of bytes to write
Returns
number of bytes written on success, GNUNET_SYSERR on error

Definition at line 710 of file disk.c.

713{
714 if (NULL == h)
715 {
716 errno = EINVAL;
717 return GNUNET_SYSERR;
718 }
719 return write (h->fd,
720 buffer,
721 n);
722}

References GNUNET_SYSERR, and h.

Referenced by database_shutdown(), decrementBit(), delete_store_message(), do_shutdown(), get_cb(), GNUNET_BIO_flush(), GNUNET_CONFIGURATION_write(), GNUNET_DISK_file_copy(), GNUNET_OS_process_kill(), GNUNET_TIME_absolute_get_monotonic(), helper_write(), incrementBit(), iterate_save_member_session_history_hentries(), iterate_save_messages(), iterate_save_peers(), process_result_with_request(), publicize_rm(), regex_found_handler(), save_list_messages(), save_list_tunnels(), sighandler_child_death(), sighandler_shutdown(), sign_worker(), start_dump(), stats_iterator(), store_and_free_entries(), store_peer_presistently_iterator(), to_file_raw(), try_match_block(), write_file(), and write_task().

Here is the caller graph for this function:

◆ GNUNET_DISK_file_write_blocking()

ssize_t GNUNET_DISK_file_write_blocking ( const struct GNUNET_DISK_FileHandle h,
const void *  buffer,
size_t  n 
)

Write a buffer to a file, blocking, if necessary.

Parameters
hhandle to open file
bufferthe data to write
nnumber of bytes to write
Returns
number of bytes written on success, GNUNET_SYSERR on error

Definition at line 726 of file disk.c.

729{
730 int flags;
731 ssize_t ret;
732
733 if (NULL == h)
734 {
735 errno = EINVAL;
736 return GNUNET_SYSERR;
737 }
738 /* set to blocking, write, then set back */
739 flags = fcntl (h->fd, F_GETFL);
740 if (0 != (flags & O_NONBLOCK))
741 (void) fcntl (h->fd, F_SETFL, flags - O_NONBLOCK);
742 ret = write (h->fd, buffer, n);
743 if (0 == (flags & O_NONBLOCK))
744 (void) fcntl (h->fd, F_SETFL, flags);
745 return ret;
746}

References GNUNET_SYSERR, h, and ret.

Referenced by write_benchmark_data().

Here is the caller graph for this function:

◆ GNUNET_DISK_fn_write()

enum GNUNET_GenericReturnValue GNUNET_DISK_fn_write ( const char *  fn,
const void *  buf,
size_t  buf_size,
enum GNUNET_DISK_AccessPermissions  mode 
)

Write a buffer to a file atomically.

The directory is created if necessary. Fail if filename already exists or if not exactly buf with buf_size bytes could be written to filename.

Parameters
fnfile name
bufthe data to write
buf_sizenumber of bytes to write from buf
modefile permissions
Returns
GNUNET_OK on success, GNUNET_NO if a file existed under filename GNUNET_SYSERR on failure

Definition at line 750 of file disk.c.

754{
755 char *tmpl;
756 int fd;
757
758 if (GNUNET_OK !=
760 {
762 "mkstemp",
763 fn);
764 return GNUNET_SYSERR;
765 }
766 {
767 char *dname;
768
769 dname = GNUNET_strdup (fn);
770 GNUNET_asprintf (&tmpl,
771 "%s/XXXXXX",
772 dirname (dname));
773 GNUNET_free (dname);
774 }
775 fd = mkstemp (tmpl);
776 if (-1 == fd)
777 {
779 "mkstemp",
780 tmpl);
781 GNUNET_free (tmpl);
782 return GNUNET_SYSERR;
783 }
784
785 if (0 != fchmod (fd,
787 {
789 "chmod",
790 tmpl);
791 GNUNET_assert (0 == close (fd));
792 if (0 != unlink (tmpl))
794 "unlink",
795 tmpl);
796 GNUNET_free (tmpl);
797 return GNUNET_SYSERR;
798 }
799 if (buf_size !=
800 write (fd,
801 buf,
802 buf_size))
803 {
805 "write",
806 tmpl);
807 GNUNET_assert (0 == close (fd));
808 if (0 != unlink (tmpl))
810 "unlink",
811 tmpl);
812 GNUNET_free (tmpl);
813 return GNUNET_SYSERR;
814 }
815 GNUNET_assert (0 == close (fd));
816
817 if (0 != link (tmpl,
818 fn))
819 {
820 if (0 != unlink (tmpl))
822 "unlink",
823 tmpl);
824 GNUNET_free (tmpl);
825 return GNUNET_NO;
826 }
827 if (0 != unlink (tmpl))
829 "unlink",
830 tmpl);
831 GNUNET_free (tmpl);
832 return GNUNET_OK;
833
834
835}
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.

References GNUNET_DISK_FileHandle::fd, GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_directory_create_for_file(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror_file, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, mode, and translate_unix_perms().

Referenced by calculate_pow(), clean_task(), GNUNET_CRYPTO_ecdsa_key_from_file(), GNUNET_CRYPTO_eddsa_key_from_file(), handle_create_message(), run(), shutdown_task(), sync_pow(), and write_proof().

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

◆ GNUNET_DISK_file_copy()

enum GNUNET_GenericReturnValue GNUNET_DISK_file_copy ( const char *  src,
const char *  dst 
)

Copy a file.

Parameters
srcfile to copy
dstdestination file name
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1143 of file disk.c.

1145{
1146 char *buf;
1147 uint64_t pos;
1148 uint64_t size;
1149 size_t len;
1150 ssize_t sret;
1151 struct GNUNET_DISK_FileHandle *in;
1152 struct GNUNET_DISK_FileHandle *out;
1153
1155 {
1157 return GNUNET_SYSERR;
1158 }
1159 pos = 0;
1160 in =
1162 if (! in)
1163 {
1165 return GNUNET_SYSERR;
1166 }
1167 out =
1175 if (! out)
1176 {
1179 return GNUNET_SYSERR;
1180 }
1182 while (pos < size)
1183 {
1184 len = COPY_BLK_SIZE;
1185 if (len > size - pos)
1186 len = size - pos;
1187 sret = GNUNET_DISK_file_read (in, buf, len);
1188 if ((sret < 0) || (len != (size_t) sret))
1189 goto FAIL;
1190 sret = GNUNET_DISK_file_write (out, buf, len);
1191 if ((sret < 0) || (len != (size_t) sret))
1192 goto FAIL;
1193 pos += len;
1194 }
1195 GNUNET_free (buf);
1200 return GNUNET_OK;
1201FAIL:
1202 GNUNET_free (buf);
1207 return GNUNET_SYSERR;
1208}
#define COPY_BLK_SIZE
Block size for IO for copying files.
Definition: disk.c:42
@ FAIL
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:710
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

References COPY_BLK_SIZE, FAIL, GNUNET_break, GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_file_size(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_FAILIFEXISTS, GNUNET_DISK_OPEN_READ, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_GROUP_WRITE, GNUNET_DISK_PERM_NONE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, and size.

Here is the call graph for this function:

◆ GNUNET_DISK_directory_scan()

int GNUNET_DISK_directory_scan ( const char *  dir_name,
GNUNET_FileNameCallback  callback,
void *  callback_cls 
)

Scan a directory for files.

Parameters
dir_namethe name of the directory
callbackthe method to call for each file
callback_clsclosure for callback
Returns
the number of files found, -1 on error

Definition at line 839 of file disk.c.

842{
843 DIR *dinfo;
844 struct dirent *finfo;
845 int count = 0;
847 char *name;
848 char *dname;
849 unsigned int name_len;
850 unsigned int n_size;
851
852 GNUNET_assert (NULL != dir_name);
854 if (NULL == dname)
855 return GNUNET_SYSERR;
856 while ( (strlen (dname) > 0) &&
857 (dname[strlen (dname) - 1] == DIR_SEPARATOR) )
858 dname[strlen (dname) - 1] = '\0';
859 dinfo = opendir (dname);
860 if (NULL == dinfo)
861 {
863 "opendir",
864 dname);
865 GNUNET_free (dname);
866 return GNUNET_SYSERR;
867 }
868 name_len = 256;
869 n_size = strlen (dname) + name_len + strlen (DIR_SEPARATOR_STR) + 1;
870 name = GNUNET_malloc (n_size);
871 while (NULL != (finfo = readdir (dinfo)))
872 {
873 if ((0 == strcmp (finfo->d_name, ".")) ||
874 (0 == strcmp (finfo->d_name, "..")))
875 continue;
876 if (NULL != callback)
877 {
878 if (name_len < strlen (finfo->d_name))
879 {
881 name_len = strlen (finfo->d_name);
882 n_size = strlen (dname) + name_len + strlen (DIR_SEPARATOR_STR) + 1;
883 name = GNUNET_malloc (n_size);
884 }
885 /* dname can end in "/" only if dname == "/";
886 * if dname does not end in "/", we need to add
887 * a "/" (otherwise, we must not!) */
889 n_size,
890 "%s%s%s",
891 dname,
892 (0 == strcmp (dname,
894 ? ""
896 finfo->d_name);
897 ret = callback (callback_cls,
898 name);
899 if (GNUNET_OK != ret)
900 {
901 closedir (dinfo);
903 GNUNET_free (dname);
904 if (GNUNET_NO == ret)
905 return count;
906 return GNUNET_SYSERR;
907 }
908 }
909 count++;
910 }
911 closedir (dinfo);
913 GNUNET_free (dname);
914 return count;
915}
static const char * dir_name
Top-level directory we monitor to auto-publish.
static char * name
Name (label) of the records to list.
#define DIR_SEPARATOR
Definition: platform.h:166
#define DIR_SEPARATOR_STR
Definition: platform.h:167

References dir_name, DIR_SEPARATOR, DIR_SEPARATOR_STR, GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_malloc, GNUNET_NO, GNUNET_OK, GNUNET_snprintf(), GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, LOG_STRERROR_FILE, name, and ret.

Referenced by deserialization_master(), deserialize_download(), deserialize_search(), determine_id(), discover_testbed_nodes(), get_size_rec(), GNUNET_CONFIGURATION_load_from(), GNUNET_DISK_directory_remove(), GNUNET_DISK_glob(), GNUNET_PLUGIN_load_all(), iter_testbed_path(), load_member(), load_member_store(), load_operation_store(), preprocess_file(), run(), and scan().

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

◆ GNUNET_DISK_glob()

int GNUNET_DISK_glob ( const char *  glob_pattern,
GNUNET_FileNameCallback  callback,
void *  callback_cls 
)

Find all files matching a glob pattern.

Currently, the glob_pattern only supports asterisks in the last path component.

Parameters
glob_patternthe glob pattern to search for
callbackthe method to call for each file
callback_clsclosure for callback
Returns
the number of files found, -1 on error

Definition at line 1021 of file disk.c.

1024{
1025 char *mypat = GNUNET_strdup (glob_pattern);
1026 char *sep;
1027 int ret;
1028
1029 if ( (NULL != strrchr (glob_pattern, '+')) ||
1030 (NULL != strrchr (glob_pattern, '[')) ||
1031 (NULL != strrchr (glob_pattern, '~')) )
1032 {
1034 "unsupported glob pattern: '%s'\n",
1035 glob_pattern);
1036 GNUNET_free (mypat);
1037 return -1;
1038 }
1039
1040 sep = strrchr (mypat, DIR_SEPARATOR);
1041 if (NULL == sep)
1042 {
1043 GNUNET_free (mypat);
1044 return -1;
1045 }
1046
1047 *sep = '\0';
1048
1049 if (NULL != strchr (mypat, '*'))
1050 {
1051 GNUNET_free (mypat);
1052 GNUNET_break (0);
1054 "glob pattern may only contain '*' in the final path component\n");
1055 return -1;
1056 }
1057
1058 {
1059 struct GlobClosure gc = {
1060 .glob = sep + 1,
1061 .cb = callback,
1062 .cls = callback_cls,
1063 .nres = 0,
1064 };
1066 "scanning directory '%s' for glob matches on '%s'\n",
1067 mypat,
1068 gc.glob);
1070 glob_cb,
1071 &gc
1072 );
1073 GNUNET_free (mypat);
1074 return (ret < 0) ? ret : gc.nres;
1075 }
1076}
static enum GNUNET_GenericReturnValue glob_cb(void *cls, const char *filename)
Function called with a filename.
Definition: disk.c:990
#define LOG(kind,...)
Definition: disk.c:31
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:839
int nres
Number of files that actually matched the glob pattern.
Definition: disk.c:977
const char * glob
Definition: disk.c:970

References DIR_SEPARATOR, GlobClosure::glob, glob_cb(), GNUNET_break, GNUNET_DISK_directory_scan(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_strdup, LOG, GlobClosure::nres, and ret.

Referenced by handle_inline().

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

◆ GNUNET_DISK_directory_create_for_file()

enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file ( const char *  filename)

Create the directory structure for storing a file.

Parameters
filenamename of a file in the directory
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure, GNUNET_NO if directory exists but is not writeable

Definition at line 633 of file disk.c.

634{
635 char *rdir;
636 size_t len;
637 int eno;
639
641 if (NULL == rdir)
642 {
643 errno = EINVAL;
644 return GNUNET_SYSERR;
645 }
646 if (0 == access (rdir, W_OK))
647 {
648 GNUNET_free (rdir);
649 return GNUNET_OK;
650 }
651 len = strlen (rdir);
652 while ((len > 0) && (rdir[len] != DIR_SEPARATOR))
653 len--;
654 rdir[len] = '\0';
655 /* The empty path is invalid and in this case refers to / */
656 if (0 == len)
657 {
658 GNUNET_free (rdir);
659 rdir = GNUNET_strdup ("/");
660 }
662 if ( (GNUNET_OK == res) &&
663 (0 != access (rdir, W_OK)) )
664 res = GNUNET_NO;
665 eno = errno;
666 GNUNET_free (rdir);
667 errno = eno;
668 return res;
669}
static char * res
Currently read line or NULL on EOF.
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create(const char *dir)
Implementation of "mkdir -p".
Definition: disk.c:547

References DIR_SEPARATOR, filename, GNUNET_DISK_directory_create(), GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, and res.

Referenced by database_connect(), database_setup(), get_server_addresses(), GNUNET_CONFIGURATION_write(), GNUNET_DISK_file_open(), GNUNET_DISK_fn_write(), GNUNET_FS_download_sync_(), make_serialization_file_name(), make_serialization_file_name_in_dir(), run(), save(), save_hostlist_file(), setup_log_file(), store_valid_peers(), and trigger_recursive_download().

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

◆ GNUNET_DISK_directory_test()

enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test ( const char *  fil,
int  is_readable 
)

Test if fil is a directory and listable.

Optionally, also check if the directory is readable. Will not print an error message if the directory does not exist. Will log errors if GNUNET_SYSERR is returned (i.e., a file exists with the same name).

Parameters
filfilename to test
is_readableGNUNET_YES to additionally check if fil is readable; GNUNET_NO to disable this check
Returns
GNUNET_YES if yes, GNUNET_NO if not; GNUNET_SYSERR if it does not exist or stated

Definition at line 454 of file disk.c.

455{
456 struct stat filestat;
457 int ret;
458
459 ret = stat (fil, &filestat);
460 if (ret != 0)
461 {
462 if (errno != ENOENT)
464 return GNUNET_SYSERR;
465 }
466 if (! S_ISDIR (filestat.st_mode))
467 {
469 "A file already exits with the same name %s\n",
470 fil);
471 return GNUNET_NO;
472 }
473 if (GNUNET_YES == is_readable)
474 ret = access (fil, R_OK | X_OK);
475 else
476 ret = access (fil, X_OK);
477 if (ret < 0)
478 {
480 return GNUNET_NO;
481 }
482 return GNUNET_YES;
483}
@ GNUNET_ERROR_TYPE_INFO

References GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, LOG, LOG_STRERROR_FILE, and ret.

Referenced by callback_scan_for_members(), callback_scan_for_sessions(), create_service(), deserialization_master(), deserialize_download(), deserialize_search(), GNUNET_CONFIGURATION_load(), GNUNET_DISK_directory_create(), GNUNET_DISK_directory_remove(), GNUNET_FS_remove_sync_dir_(), GNUNET_OS_installation_get_path(), iterate_load_next_member_sessions(), iterate_load_next_session(), iterate_save_members(), iterate_save_session(), load_member(), load_member_store(), load_operation_store(), load_srv_room(), PABC_load_public_parameters(), remove_srv_room(), run(), save_member(), save_member_store(), save_operation_store(), and save_srv_room().

Here is the caller graph for this function:

◆ GNUNET_DISK_directory_remove()

enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove ( const char *  filename)

Remove all files in a directory (rm -rf).

Call with caution.

Parameters
filenamethe file to remove
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1098 of file disk.c.

1099{
1100 struct stat istat;
1101
1102 if (NULL == filename)
1103 {
1104 GNUNET_break (0);
1105 return GNUNET_SYSERR;
1106 }
1107 if (0 != lstat (filename, &istat))
1108 return GNUNET_NO; /* file may not exist... */
1109 (void) chmod (filename,
1110 S_IWUSR | S_IRUSR | S_IXUSR);
1111 if (0 == unlink (filename))
1112 return GNUNET_OK;
1113 if ( (errno != EISDIR) &&
1114 /* EISDIR is not sufficient in all cases, e.g.
1115 * sticky /tmp directory may result in EPERM on BSD.
1116 * So we also explicitly check "isDirectory" */
1117 (GNUNET_YES !=
1119 GNUNET_YES)) )
1120 {
1122 "rmdir",
1123 filename);
1124 return GNUNET_SYSERR;
1125 }
1126 if (GNUNET_SYSERR ==
1129 NULL))
1130 return GNUNET_SYSERR;
1131 if (0 != rmdir (filename))
1132 {
1134 "rmdir",
1135 filename);
1136 return GNUNET_SYSERR;
1137 }
1138 return GNUNET_OK;
1139}
static enum GNUNET_GenericReturnValue remove_helper(void *unused, const char *fn)
Function that removes the given directory by calling GNUNET_DISK_directory_remove().
Definition: disk.c:1088
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:454

References filename, GNUNET_break, GNUNET_DISK_directory_scan(), GNUNET_DISK_directory_test(), GNUNET_ERROR_TYPE_WARNING, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, LOG_STRERROR_FILE, and remove_helper().

Referenced by calculate_pow(), clean_task(), create_response(), delete_files(), GNUNET_CONFIGURATION_write(), GNUNET_FS_remove_sync_dir_(), GNUNET_TESTBED_system_destroy(), purge_cfg_dir(), remove_helper(), remove_room_member_session(), remove_srv_room(), and write_proof().

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

◆ GNUNET_DISK_purge_cfg_dir()

void GNUNET_DISK_purge_cfg_dir ( const struct GNUNET_OS_ProjectData pd,
const char *  cfg_filename,
const char *  option 
)

Remove the directory given under option in section [PATHS] in configuration under cfg_filename.

Parameters
pdproject data to use to determine paths
cfg_filenameconfiguration file to parse
optionoption with the dir name to purge

Definition at line 1712 of file disk.c.

1715{
1720 (void *) option));
1721}
static enum GNUNET_GenericReturnValue purge_cfg_dir(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Helper function for GNUNET_DISK_purge_cfg_dir.
Definition: disk.c:1680
static char * cfg_filename
Name of the configuration file.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_parse_and_run(const struct GNUNET_OS_ProjectData *pd, const char *filename, GNUNET_CONFIGURATION_Callback cb, void *cb_cls)
Parse a configuration file filename and run the function cb with the resulting configuration object.

References cfg_filename, GNUNET_break, GNUNET_CONFIGURATION_parse_and_run(), GNUNET_OK, and purge_cfg_dir().

Here is the call graph for this function:

◆ GNUNET_DISK_directory_create()

enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create ( const char *  dir)

Implementation of "mkdir -p".

Parameters
dirthe directory to create
Returns
GNUNET_SYSERR on failure, GNUNET_OK otherwise

Definition at line 547 of file disk.c.

548{
549 char *rdir;
550 unsigned int len;
551 unsigned int pos;
552 unsigned int pos2;
553 int ret = GNUNET_OK;
554
556 if (rdir == NULL)
557 {
558 GNUNET_break (0);
559 return GNUNET_SYSERR;
560 }
561
562 len = strlen (rdir);
563
564 pos = 1; /* skip heading '/' */
565
566 /* Check which low level directories already exist */
567 pos2 = len;
568 rdir[len] = DIR_SEPARATOR;
569 while (pos <= pos2)
570 {
571 if (DIR_SEPARATOR == rdir[pos2])
572 {
573 rdir[pos2] = '\0';
575 if (GNUNET_NO == ret)
576 {
578 "Creating directory `%s' failed\n",
579 rdir);
580 GNUNET_free (rdir);
581 return GNUNET_SYSERR;
582 }
583 rdir[pos2] = DIR_SEPARATOR;
584 if (GNUNET_YES == ret)
585 {
586 pos2++;
587 break;
588 }
589 }
590 pos2--;
591 }
592 rdir[len] = '\0';
593 if (pos < pos2)
594 pos = pos2;
595 /* Start creating directories */
596 while (pos <= len)
597 {
598 if ((rdir[pos] == DIR_SEPARATOR) || (pos == len))
599 {
600 rdir[pos] = '\0';
602 if (GNUNET_NO == ret)
603 {
605 "Creating directory `%s' failed\n",
606 rdir);
607 GNUNET_free (rdir);
608 return GNUNET_SYSERR;
609 }
610 if (GNUNET_SYSERR == ret)
611 {
612 ret = mkdir (rdir,
613 S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH
614 | S_IXOTH); /* 755 */
615
616 if ((ret != 0) && (errno != EEXIST))
617 {
619 GNUNET_free (rdir);
620 return GNUNET_SYSERR;
621 }
622 }
623 rdir[pos] = DIR_SEPARATOR;
624 }
625 pos++;
626 }
627 GNUNET_free (rdir);
628 return GNUNET_OK;
629}
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:88
#define GNUNET_log(kind,...)

References dir, DIR_SEPARATOR, GNUNET_break, GNUNET_DISK_directory_test(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, GNUNET_YES, LOG_STRERROR_FILE, and ret.

Referenced by create_service(), ensure_folder_exist(), GNUNET_DISK_directory_create_for_file(), init_pabc_dir(), iterate_save_members(), iterate_save_session(), jwks_endpoint(), run(), save_member(), save_member_store(), save_operation_store(), save_srv_room(), token_endpoint(), and write_benchmark_data().

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

◆ GNUNET_DISK_filename_canonicalize()

void GNUNET_DISK_filename_canonicalize ( char *  fn)

Removes special characters as ':' from a filename.

Parameters
fnthe filename to canonicalize

Definition at line 1212 of file disk.c.

1213{
1214 char *idx;
1215 char c;
1216
1217 for (idx = fn; *idx; idx++)
1218 {
1219 c = *idx;
1220
1221 if ((c == '/') || (c == '\\') || (c == ':') || (c == '*') || (c == '?') ||
1222 (c ==
1223 '"')
1224 ||
1225 (c == '<') || (c == '>') || (c == '|') )
1226 {
1227 *idx = '_';
1228 }
1229 }
1230}

Referenced by progress_cb().

Here is the caller graph for this function:

◆ GNUNET_DISK_file_change_owner()

enum GNUNET_GenericReturnValue GNUNET_DISK_file_change_owner ( const char *  filename,
const char *  user 
)

Change owner of a file.

Parameters
filenamefile to change
usernew owner of the file
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1234 of file disk.c.

1236{
1237 struct passwd *pws;
1238
1239 pws = getpwnam (user);
1240 if (NULL == pws)
1241 {
1243 _ ("Cannot obtain information about user `%s': %s\n"),
1244 user,
1245 strerror (errno));
1246 return GNUNET_SYSERR;
1247 }
1248 if (0 != chown (filename, pws->pw_uid, pws->pw_gid))
1249 {
1251 return GNUNET_SYSERR;
1252 }
1253 return GNUNET_OK;
1254}
#define _(String)
GNU gettext support macro.
Definition: platform.h:179

References _, filename, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_OK, GNUNET_SYSERR, LOG, and LOG_STRERROR_FILE.

◆ GNUNET_DISK_file_map()

void * GNUNET_DISK_file_map ( const struct GNUNET_DISK_FileHandle h,
struct GNUNET_DISK_MapHandle **  m,
enum GNUNET_DISK_MapType  access,
size_t  len 
)

Map a file into memory.

Parameters
hopen file handle
mhandle to the new mapping (will be set)
accessaccess specification, GNUNET_DISK_MAP_TYPE_xxx
lensize of the mapping
Returns
pointer to the mapped memory region, NULL on failure

Definition at line 1404 of file disk.c.

1408{
1409 int prot;
1410
1411 if (NULL == h)
1412 {
1413 errno = EINVAL;
1414 return NULL;
1415 }
1416 prot = 0;
1417 if (access & GNUNET_DISK_MAP_TYPE_READ)
1418 prot = PROT_READ;
1419 if (access & GNUNET_DISK_MAP_TYPE_WRITE)
1420 prot |= PROT_WRITE;
1422 (*m)->addr = mmap (NULL, len, prot, MAP_SHARED, h->fd, 0);
1423 GNUNET_assert (NULL != (*m)->addr);
1424 if (MAP_FAILED == (*m)->addr)
1425 {
1426 GNUNET_free (*m);
1427 return NULL;
1428 }
1429 (*m)->len = len;
1430 return (*m)->addr;
1431}
#define MAP_FAILED
Definition: disk.c:1399
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:103
Handle for a memory-mapping operation.
Definition: disk.c:1385

References GNUNET_assert, GNUNET_DISK_MAP_TYPE_READ, GNUNET_DISK_MAP_TYPE_WRITE, GNUNET_free, GNUNET_new, h, m, and MAP_FAILED.

Referenced by database_setup(), full_recursive_download(), GNUNET_TIME_absolute_get_monotonic(), load_etc_hosts(), lookup_dns_servers(), and run().

Here is the caller graph for this function:

◆ GNUNET_DISK_file_unmap()

enum GNUNET_GenericReturnValue GNUNET_DISK_file_unmap ( struct GNUNET_DISK_MapHandle h)

Unmap a file.

Parameters
hmapping handle
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1435 of file disk.c.

1436{
1438
1439 if (NULL == h)
1440 {
1441 errno = EINVAL;
1442 return GNUNET_SYSERR;
1443 }
1444 ret = munmap (h->addr, h->len) != -1 ? GNUNET_OK : GNUNET_SYSERR;
1445 GNUNET_free (h);
1446 return ret;
1447}

References GNUNET_free, GNUNET_OK, GNUNET_SYSERR, h, and ret.

Referenced by database_setup(), full_recursive_download(), GNUNET_TIME_absolute_get_monotonic(), load_etc_hosts(), lookup_dns_servers(), and run().

Here is the caller graph for this function:

◆ GNUNET_DISK_file_sync()

enum GNUNET_GenericReturnValue GNUNET_DISK_file_sync ( const struct GNUNET_DISK_FileHandle h)

Write file changes to disk.

Parameters
hhandle to an open file
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1451 of file disk.c.

1452{
1453 if (h == NULL)
1454 {
1455 errno = EINVAL;
1456 return GNUNET_SYSERR;
1457 }
1458
1459#if ! defined(__linux__) || ! defined(GNU)
1460 return fsync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
1461#else
1462 return fdatasync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
1463#endif
1464}

References GNUNET_OK, GNUNET_SYSERR, and h.

Referenced by delete_store_message(), publicize_rm(), save_list_messages(), save_list_tunnels(), save_member_session_history(), save_message_store(), and save_peer_store().

Here is the caller graph for this function: