GNUnet 0.21.0
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...
 
void 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_file_read_non_blocking (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 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 416 of file gnunet_disk_lib.h.

417{
418
423
428
433
439
440};
@ 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 185 of file disk.c.

186{
187 return ((! h) || (h->fd == -1)) ? GNUNET_YES : GNUNET_NO;
188}
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
@ 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 482 of file disk.c.

483{
484 return file_test_internal (fil, F_OK);
485}
static enum GNUNET_GenericReturnValue file_test_internal(const char *fil, int amode)
Check if fil can be accessed using amode.
Definition: disk.c:443

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(), GNUNET_CONFIGURATION_default(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_DISK_file_open(), GNUNET_FS_download_start_task_(), GNUNET_HOSTLIST_client_start(), GNUNET_PQ_exec_sql(), GNUNET_PROGRAM_run2(), GNUNET_SERVICE_main(), GNUNET_SERVICE_run_(), GNUNET_TESTING_get_topo_from_file(), GNUNET_TRANSPORT_TESTING_start_peer(), hostkeys_load(), 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(), 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 489 of file disk.c.

490{
491 return file_test_internal (fil, R_OK);
492}

References file_test_internal().

Referenced by GNUNET_CONFIGURATION_default_filename(), and handle_inline().

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

◆ GNUNET_DISK_file_backup()

void 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

Definition at line 359 of file disk.c.

360{
361 size_t slen;
362 char *target;
363 unsigned int num;
364
365 slen = strlen (fil) + 20;
366 target = GNUNET_malloc (slen);
367 num = 0;
368 do
369 {
370 GNUNET_snprintf (target, slen, "%s.%u~", fil, num++);
371 }
372 while (0 == access (target, F_OK));
373 if (0 != rename (fil, target))
375 GNUNET_free (target);
376}
#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.
#define GNUNET_free(ptr)
Wrapper around free.

References GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_strerror_file, GNUNET_malloc, and GNUNET_snprintf().

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 205 of file disk.c.

208{
209 static int t[] = { SEEK_SET, SEEK_CUR, SEEK_END };
210
211 if (h == NULL)
212 {
213 errno = EINVAL;
214 return GNUNET_SYSERR;
215 }
216 return lseek (h->fd, offset, t[whence]);
217}
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 221 of file disk.c.

225{
226 struct GetFileSizeData gfsd;
228
229 GNUNET_assert (size != NULL);
230 gfsd.total = 0;
231 gfsd.include_sym_links = include_symbolic_links;
232 gfsd.single_file_mode = single_file_mode;
233 ret = get_size_rec (&gfsd, filename);
234 *size = gfsd.total;
235 return ret;
236}
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:145
static int ret
Final status code.
Definition: gnunet-arm.c:94
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:82
int single_file_mode
GNUNET_YES if mode is file-only (return total == -1 for directories).
Definition: disk.c:96

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(), GNUNET_CONFIGURATION_parse(), GNUNET_CRYPTO_hash_file(), GNUNET_DISK_file_copy(), GNUNET_FS_file_information_create_from_file(), GNUNET_FS_unindex_start(), GNUNET_TESTING_get_topo_from_file(), hostkeys_load(), 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 240 of file disk.c.

243{
244#if HAVE_STAT
245 {
246 struct stat sbuf;
247
248 if (0 != stat (filename, &sbuf))
249 {
250 return GNUNET_SYSERR;
251 }
252 *ino = (uint64_t) sbuf.st_ino;
253 }
254#else
255 *ino = 0;
256#endif
257#if HAVE_STATVFS
258 {
259 struct statvfs fbuf;
260
261 if (0 != statvfs (filename, &fbuf))
262 {
263 return GNUNET_SYSERR;
264 }
265 *dev = (uint64_t) fbuf.f_fsid;
266 }
267#elif HAVE_STATFS
268 {
269 struct statfs fbuf;
270
271 if (0 != statfs (filename, &fbuf))
272 {
273 return GNUNET_SYSERR;
274 }
275 *dev =
276 ((uint64_t) fbuf.f_fsid.val[0]) << 32 || ((uint64_t) fbuf.f_fsid.val[1]);
277 }
278#else
279 *dev = 0;
280#endif
281 return GNUNET_OK;
282}
@ 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 380 of file disk.c.

381{
382 int fd;
383 char *fn;
384 mode_t omask;
385
386 omask = umask (S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
387 fn = mktemp_name (t);
388 if (-1 == (fd = mkstemp (fn)))
389 {
391 GNUNET_free (fn);
392 umask (omask);
393 return NULL;
394 }
395 umask (omask);
396 if (0 != close (fd))
398 return fn;
399}
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: disk.c:35
static char * mktemp_name(const char *t)
Create the name for a temporary file or directory from a template.
Definition: disk.c:292
@ GNUNET_ERROR_TYPE_WARNING

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(), make_serialization_file_name_in_dir(), and testing_main().

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 339 of file disk.c.

340{
341 char *fn;
342 mode_t omask;
343
344 omask = umask (S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
345 fn = mktemp_name (t);
346 if (fn != mkdtemp (fn))
347 {
349 GNUNET_free (fn);
350 umask (omask);
351 return NULL;
352 }
353 umask (omask);
354 return fn;
355}

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

Referenced by create_response(), and GNUNET_TESTING_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 1237 of file disk.c.

1240{
1241 char *expfn;
1243
1244 int oflags;
1245 int mode;
1246 int fd;
1247
1248 expfn = GNUNET_STRINGS_filename_expand (fn);
1249 if (NULL == expfn)
1250 return NULL;
1251
1252 mode = 0;
1254 oflags = O_RDWR; /* note: O_RDWR is NOT always O_RDONLY | O_WRONLY */
1255 else if (flags & GNUNET_DISK_OPEN_READ)
1256 oflags = O_RDONLY;
1257 else if (flags & GNUNET_DISK_OPEN_WRITE)
1258 oflags = O_WRONLY;
1259 else
1260 {
1261 GNUNET_break (0);
1262 GNUNET_free (expfn);
1263 return NULL;
1264 }
1266 oflags |= (O_CREAT | O_EXCL);
1267 if (flags & GNUNET_DISK_OPEN_TRUNCATE)
1268 oflags |= O_TRUNC;
1269 if (flags & GNUNET_DISK_OPEN_APPEND)
1270 oflags |= O_APPEND;
1271 if (GNUNET_NO == GNUNET_DISK_file_test (fn))
1272 {
1273 if (flags & GNUNET_DISK_OPEN_CREATE)
1274 {
1276 oflags |= O_CREAT;
1277 mode = translate_unix_perms (perm);
1278 }
1279 }
1280
1281 fd = open (expfn,
1282 oflags
1283#if O_CLOEXEC
1284 | O_CLOEXEC
1285#endif
1286 | O_LARGEFILE,
1287 mode);
1288 if (fd == -1)
1289 {
1290 if (0 == (flags & GNUNET_DISK_OPEN_FAILIFEXISTS))
1292 else
1294 GNUNET_free (expfn);
1295 return NULL;
1296 }
1297
1299
1300 ret->fd = fd;
1301
1302 GNUNET_free (expfn);
1303 return ret;
1304}
static int translate_unix_perms(enum GNUNET_DISK_AccessPermissions perm)
Translate GNUnet-internal permission bitmap to UNIX file access permission bitmap.
Definition: disk.c:108
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:482
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:582
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ 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:495
#define O_LARGEFILE
Definition: platform.h:212
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 create_hostkeys(), 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_TESTING_peer_configure(), GNUNET_TIME_absolute_get_monotonic(), hostkeys_load(), 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 192 of file disk.c.

194{
195 struct stat sbuf;
196
197 if (0 != fstat (fh->fd, &sbuf))
198 return GNUNET_SYSERR;
199 *size = sbuf.st_size;
200 return GNUNET_OK;
201}
static struct GNUNET_DISK_FileHandle * fh
File handle to STDIN, for reading restart/quit commands.

References GNUNET_DISK_FileHandle::fd, fh, 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 1444 of file disk.c.

1445{
1446 int fd[2];
1447
1448 if (-1 == pipe (fd))
1449 {
1450 int eno = errno;
1451
1453 errno = eno;
1454 return NULL;
1455 }
1456 return GNUNET_DISK_pipe_from_fd (pf, fd);
1457}
#define LOG_STRERROR(kind, syscall)
Definition: disk.c:32
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:1461

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 1461 of file disk.c.

1463{
1464 struct GNUNET_DISK_PipeHandle *p;
1465 int ret = 0;
1466 int flags;
1467 int eno = 0; /* make gcc happy */
1468
1470 if (fd[0] >= 0)
1471 {
1472 p->fd[0] = GNUNET_new (struct GNUNET_DISK_FileHandle);
1473 p->fd[0]->fd = fd[0];
1474 if (0 == (GNUNET_DISK_PF_BLOCKING_READ & pf))
1475 {
1476 flags = fcntl (fd[0], F_GETFL);
1477 flags |= O_NONBLOCK;
1478 if (0 > fcntl (fd[0], F_SETFL, flags))
1479 {
1480 ret = -1;
1481 eno = errno;
1482 }
1483 }
1484 flags = fcntl (fd[0], F_GETFD);
1485 flags |= FD_CLOEXEC;
1486 if (0 > fcntl (fd[0], F_SETFD, flags))
1487 {
1488 ret = -1;
1489 eno = errno;
1490 }
1491 }
1492
1493 if (fd[1] >= 0)
1494 {
1495 p->fd[1] = GNUNET_new (struct GNUNET_DISK_FileHandle);
1496 p->fd[1]->fd = fd[1];
1497 if (0 == (GNUNET_DISK_PF_BLOCKING_WRITE & pf))
1498 {
1499 flags = fcntl (fd[1], F_GETFL);
1500 flags |= O_NONBLOCK;
1501 if (0 > fcntl (fd[1], F_SETFL, flags))
1502 {
1503 ret = -1;
1504 eno = errno;
1505 }
1506 }
1507 flags = fcntl (fd[1], F_GETFD);
1508 flags |= FD_CLOEXEC;
1509 if (0 > fcntl (fd[1], F_SETFD, flags))
1510 {
1511 ret = -1;
1512 eno = errno;
1513 }
1514 }
1515 if (ret == -1)
1516 {
1517 errno = eno;
1519 if (p->fd[0]->fd >= 0)
1520 GNUNET_break (0 == close (p->fd[0]->fd));
1521 if (p->fd[1]->fd >= 0)
1522 GNUNET_break (0 == close (p->fd[1]->fd));
1523 GNUNET_free (p->fd[0]);
1524 GNUNET_free (p->fd[1]);
1525 GNUNET_free (p);
1526 errno = eno;
1527 return NULL;
1528 }
1529 return p;
1530}
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
Handle used to manage a pipe.
Definition: disk.c:68
struct GNUNET_DISK_FileHandle * fd[2]
File descriptors for the pipe.
Definition: disk.c:73

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 1587 of file disk.c.

1588{
1590 enum GNUNET_GenericReturnValue read_end_close;
1591 enum GNUNET_GenericReturnValue write_end_close;
1592 int read_end_close_errno;
1593 int write_end_close_errno;
1594
1596 read_end_close_errno = errno;
1598 write_end_close_errno = errno;
1599 GNUNET_free (p);
1600
1601 if (GNUNET_OK != read_end_close)
1602 {
1603 errno = read_end_close_errno;
1604 ret = read_end_close;
1605 }
1606 else if (GNUNET_OK != write_end_close)
1607 {
1608 errno = write_end_close_errno;
1609 ret = write_end_close;
1610 }
1611
1612 return ret;
1613}
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:1534

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 1534 of file disk.c.

1536{
1538
1540 {
1541 if (p->fd[0])
1542 {
1543 ret = GNUNET_DISK_file_close (p->fd[0]);
1544 p->fd[0] = NULL;
1545 }
1546 }
1547 else if (end == GNUNET_DISK_PIPE_END_WRITE)
1548 {
1549 if (p->fd[1])
1550 {
1551 ret = GNUNET_DISK_file_close (p->fd[1]);
1552 p->fd[1] = NULL;
1553 }
1554 }
1555 return ret;
1556}
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1308

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 1560 of file disk.c.

1562{
1563 struct GNUNET_DISK_FileHandle *ret = NULL;
1564
1566 {
1567 if (p->fd[0])
1568 {
1569 ret = p->fd[0];
1570 p->fd[0] = NULL;
1571 }
1572 }
1573 else if (end == GNUNET_DISK_PIPE_END_WRITE)
1574 {
1575 if (p->fd[1])
1576 {
1577 ret = p->fd[1];
1578 p->fd[1] = NULL;
1579 }
1580 }
1581
1582 return ret;
1583}

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 1308 of file disk.c.

1309{
1311
1312 if (NULL == h)
1313 {
1314 errno = EINVAL;
1315 return GNUNET_SYSERR;
1316 }
1317
1318 ret = GNUNET_OK;
1319 if (0 != close (h->fd))
1320 {
1323 }
1324 GNUNET_free (h);
1325 return ret;
1326}

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

Referenced by check_completed(), cleanup(), clear_message_store(), close_files_iter(), create_hostkeys(), 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_TESTING_peer_configure(), GNUNET_TIME_absolute_get_monotonic(), hostkeys_load(), 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 1617 of file disk.c.

1619{
1620 switch (n)
1621 {
1624 return p->fd[n];
1625
1626 default:
1627 GNUNET_break (0);
1628 return NULL;
1629 }
1630}

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 320 of file disk.c.

323{
324 mode_t mode;
325
326 if (GNUNET_YES == require_uid_match)
327 mode = S_IRUSR | S_IWUSR | S_IXUSR;
328 else if (GNUNET_YES == require_gid_match)
329 mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP;
330 else
331 mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH
332 | S_IWOTH | S_IXOTH;
333 if (0 != chmod (fn, mode))
335}

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 1330 of file disk.c.

1331{
1332 struct GNUNET_DISK_FileHandle *fh;
1333
1334 if ((((off_t) -1) == lseek (fno, 0, SEEK_CUR)) && (EBADF == errno))
1335 return NULL; /* invalid FD */
1336
1338
1339 fh->fd = fno;
1340
1341 return fh;
1342}

References GNUNET_DISK_FileHandle::fd, fh, 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 1346 of file disk.c.

1347{
1348 int fno;
1349
1350 fno = fileno (fd);
1351 if (-1 == fno)
1352 return NULL;
1354}
struct GNUNET_DISK_FileHandle * GNUNET_DISK_get_handle_from_int_fd(int fno)
Get a handle from a native integer FD.
Definition: disk.c:1330

References GNUNET_DISK_FileHandle::fd, and GNUNET_DISK_get_handle_from_int_fd().

Referenced by run(), and testing_main().

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 622 of file disk.c.

625{
626 if (NULL == h)
627 {
628 errno = EINVAL;
629 return GNUNET_SYSERR;
630 }
631 return read (h->fd, result, len);
632}
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_file_read_non_blocking()

ssize_t GNUNET_DISK_file_read_non_blocking ( const struct GNUNET_DISK_FileHandle h,
void *  result,
size_t  len 
)

Read the contents of a binary file into a buffer.

Guarantees not to block (returns GNUNET_SYSERR and sets errno to EAGAIN when no data can be read).

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 636 of file disk.c.

639{
640 int flags;
641 ssize_t ret;
642
643 if (NULL == h)
644 {
645 errno = EINVAL;
646 return GNUNET_SYSERR;
647 }
648 /* set to non-blocking, read, then set back */
649 flags = fcntl (h->fd, F_GETFL);
650 if (0 == (flags & O_NONBLOCK))
651 (void) fcntl (h->fd, F_SETFL, flags | O_NONBLOCK);
652 ret = read (h->fd, result, len);
653 if (0 == (flags & O_NONBLOCK))
654 {
655 int eno = errno;
656 (void) fcntl (h->fd, F_SETFL, flags);
657 errno = eno;
658 }
659 return ret;
660}

References GNUNET_SYSERR, h, result, and ret.

◆ 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 664 of file disk.c.

667{
669 ssize_t ret;
670 int eno;
671
675 if (NULL == fh)
676 return GNUNET_SYSERR;
678 eno = errno;
680 errno = eno;
681 return ret;
682}
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:1237
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:622

References fh, 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(), GNUNET_CONFIGURATION_parse(), GNUNET_TESTING_get_topo_from_file(), 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 686 of file disk.c.

689{
690 if (NULL == h)
691 {
692 errno = EINVAL;
693 return GNUNET_SYSERR;
694 }
695
696 return write (h->fd, buffer, n);
697}

References GNUNET_SYSERR, and h.

Referenced by create_hostkeys(), 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_TESTING_peer_configure(), GNUNET_TIME_absolute_get_monotonic(), helper_write(), incrementBit(), iterate_save_entries(), iterate_save_links(), iterate_save_member_session_history_hentries(), iterate_save_messages(), iterate_save_peers(), process_result_with_request(), publicize_rm(), regex_found_handler(), run(), 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 701 of file disk.c.

704{
705 int flags;
706 ssize_t ret;
707
708 if (NULL == h)
709 {
710 errno = EINVAL;
711 return GNUNET_SYSERR;
712 }
713 /* set to blocking, write, then set back */
714 flags = fcntl (h->fd, F_GETFL);
715 if (0 != (flags & O_NONBLOCK))
716 (void) fcntl (h->fd, F_SETFL, flags - O_NONBLOCK);
717 ret = write (h->fd, buffer, n);
718 if (0 == (flags & O_NONBLOCK))
719 (void) fcntl (h->fd, F_SETFL, flags);
720 return ret;
721}

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 725 of file disk.c.

729{
730 char *tmpl;
731 int fd;
732
733 if (GNUNET_OK !=
735 {
737 "mkstemp",
738 fn);
739 return GNUNET_SYSERR;
740 }
741 {
742 char *dname;
743
744 dname = GNUNET_strdup (fn);
745 GNUNET_asprintf (&tmpl,
746 "%s/XXXXXX",
747 dirname (dname));
748 GNUNET_free (dname);
749 }
750 fd = mkstemp (tmpl);
751 if (-1 == fd)
752 {
754 "mkstemp",
755 tmpl);
756 GNUNET_free (tmpl);
757 return GNUNET_SYSERR;
758 }
759
760 if (0 != fchmod (fd,
762 {
764 "chmod",
765 tmpl);
766 GNUNET_assert (0 == close (fd));
767 if (0 != unlink (tmpl))
769 "unlink",
770 tmpl);
771 GNUNET_free (tmpl);
772 return GNUNET_SYSERR;
773 }
774 if (buf_size !=
775 write (fd,
776 buf,
777 buf_size))
778 {
780 "write",
781 tmpl);
782 GNUNET_assert (0 == close (fd));
783 if (0 != unlink (tmpl))
785 "unlink",
786 tmpl);
787 GNUNET_free (tmpl);
788 return GNUNET_SYSERR;
789 }
790 GNUNET_assert (0 == close (fd));
791
792 if (0 != link (tmpl,
793 fn))
794 {
795 if (0 != unlink (tmpl))
797 "unlink",
798 tmpl);
799 GNUNET_free (tmpl);
800 return GNUNET_NO;
801 }
802 if (0 != unlink (tmpl))
804 "unlink",
805 tmpl);
806 GNUNET_free (tmpl);
807 return GNUNET_OK;
808
809
810}
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 1126 of file disk.c.

1128{
1129 char *buf;
1130 uint64_t pos;
1131 uint64_t size;
1132 size_t len;
1133 ssize_t sret;
1134 struct GNUNET_DISK_FileHandle *in;
1135 struct GNUNET_DISK_FileHandle *out;
1136
1138 {
1140 return GNUNET_SYSERR;
1141 }
1142 pos = 0;
1143 in =
1145 if (! in)
1146 {
1148 return GNUNET_SYSERR;
1149 }
1150 out =
1158 if (! out)
1159 {
1162 return GNUNET_SYSERR;
1163 }
1165 while (pos < size)
1166 {
1167 len = COPY_BLK_SIZE;
1168 if (len > size - pos)
1169 len = size - pos;
1170 sret = GNUNET_DISK_file_read (in, buf, len);
1171 if ((sret < 0) || (len != (size_t) sret))
1172 goto FAIL;
1173 sret = GNUNET_DISK_file_write (out, buf, len);
1174 if ((sret < 0) || (len != (size_t) sret))
1175 goto FAIL;
1176 pos += len;
1177 }
1178 GNUNET_free (buf);
1181 return GNUNET_OK;
1182 FAIL:
1183 GNUNET_free (buf);
1186 return GNUNET_SYSERR;
1187}
#define COPY_BLK_SIZE
Block size for IO for copying files.
Definition: disk.c:41
@ 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:686
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:221

References COPY_BLK_SIZE, FAIL, 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 814 of file disk.c.

817{
818 DIR *dinfo;
819 struct dirent *finfo;
820 struct stat istat;
821 int count = 0;
823 char *name;
824 char *dname;
825 unsigned int name_len;
826 unsigned int n_size;
827
828 GNUNET_assert (NULL != dir_name);
830 if (NULL == dname)
831 return GNUNET_SYSERR;
832 while ((strlen (dname) > 0) && (dname[strlen (dname) - 1] == DIR_SEPARATOR))
833 dname[strlen (dname) - 1] = '\0';
834 if (0 != stat (dname, &istat))
835 {
837 GNUNET_free (dname);
838 return GNUNET_SYSERR;
839 }
840 if (! S_ISDIR (istat.st_mode))
841 {
843 _ ("Expected `%s' to be a directory!\n"),
844 dir_name);
845 GNUNET_free (dname);
846 return GNUNET_SYSERR;
847 }
848 errno = 0;
849 dinfo = opendir (dname);
850 if ((EACCES == errno) || (NULL == dinfo))
851 {
853 if (NULL != dinfo)
854 closedir (dinfo);
855 GNUNET_free (dname);
856 return GNUNET_SYSERR;
857 }
858 name_len = 256;
859 n_size = strlen (dname) + name_len + strlen (DIR_SEPARATOR_STR) + 1;
860 name = GNUNET_malloc (n_size);
861 while (NULL != (finfo = readdir (dinfo)))
862 {
863 if ((0 == strcmp (finfo->d_name, ".")) ||
864 (0 == strcmp (finfo->d_name, "..")))
865 continue;
866 if (NULL != callback)
867 {
868 if (name_len < strlen (finfo->d_name))
869 {
871 name_len = strlen (finfo->d_name);
872 n_size = strlen (dname) + name_len + strlen (DIR_SEPARATOR_STR) + 1;
873 name = GNUNET_malloc (n_size);
874 }
875 /* dname can end in "/" only if dname == "/";
876 * if dname does not end in "/", we need to add
877 * a "/" (otherwise, we must not!) */
879 n_size,
880 "%s%s%s",
881 dname,
882 (0 == strcmp (dname, DIR_SEPARATOR_STR))
883 ? ""
885 finfo->d_name);
886 ret = callback (callback_cls, name);
887 if (GNUNET_OK != ret)
888 {
889 closedir (dinfo);
891 GNUNET_free (dname);
892 if (GNUNET_NO == ret)
893 return count;
894 return GNUNET_SYSERR;
895 }
896 }
897 count++;
898 }
899 closedir (dinfo);
901 GNUNET_free (dname);
902 return count;
903}
#define LOG(kind,...)
Definition: disk.c:30
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:165
#define DIR_SEPARATOR_STR
Definition: platform.h:166
#define _(String)
GNU gettext support macro.
Definition: platform.h:178

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, 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 1009 of file disk.c.

1012{
1013 char *mypat = GNUNET_strdup (glob_pattern);
1014 char *sep;
1015 int ret;
1016
1017 if ( (NULL != strrchr (glob_pattern, '+')) ||
1018 (NULL != strrchr (glob_pattern, '[')) ||
1019 (NULL != strrchr (glob_pattern, '+')) ||
1020 (NULL != strrchr (glob_pattern, '~')) )
1021 {
1023 "unsupported glob pattern: '%s'\n",
1024 glob_pattern);
1025 GNUNET_free (mypat);
1026 return -1;
1027 }
1028
1029 sep = strrchr (mypat, DIR_SEPARATOR);
1030 if (NULL == sep)
1031 {
1032 GNUNET_free (mypat);
1033 return -1;
1034 }
1035
1036 *sep = '\0';
1037
1038 if (NULL != strchr (mypat, '*'))
1039 {
1040 GNUNET_free (mypat);
1041 GNUNET_break (0);
1043 "glob pattern may only contain '*' in the final path component\n");
1044 return -1;
1045 }
1046
1047 {
1048 struct GlobClosure gc = {
1049 .glob = sep + 1,
1050 .cb = callback,
1051 .cls = callback_cls,
1052 .nres = 0,
1053 };
1055 "scanning directory '%s' for glob matches on '%s'\n",
1056 mypat,
1057 gc.glob);
1059 glob_cb,
1060 &gc
1061 );
1062 GNUNET_free (mypat);
1063 return (ret < 0) ? ret : gc.nres;
1064 }
1065}
static enum GNUNET_GenericReturnValue glob_cb(void *cls, const char *filename)
Function called with a filename.
Definition: disk.c:978
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:814
int nres
Number of files that actually matched the glob pattern.
Definition: disk.c:965
const char * glob
Definition: disk.c:958

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 582 of file disk.c.

583{
584 char *rdir;
585 size_t len;
586 int eno;
588
590 if (NULL == rdir)
591 {
592 errno = EINVAL;
593 return GNUNET_SYSERR;
594 }
595 if (0 == access (rdir, W_OK))
596 {
597 GNUNET_free (rdir);
598 return GNUNET_OK;
599 }
600 len = strlen (rdir);
601 while ((len > 0) && (rdir[len] != DIR_SEPARATOR))
602 len--;
603 rdir[len] = '\0';
604 /* The empty path is invalid and in this case refers to / */
605 if (0 == len)
606 {
607 GNUNET_free (rdir);
608 rdir = GNUNET_strdup ("/");
609 }
611 if ( (GNUNET_OK == res) &&
612 (0 != access (rdir, W_OK)) )
613 res = GNUNET_NO;
614 eno = errno;
615 GNUNET_free (rdir);
616 errno = eno;
617 return res;
618}
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:496

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 create_hostkeys(), 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 403 of file disk.c.

404{
405 struct stat filestat;
406 int ret;
407
408 ret = stat (fil, &filestat);
409 if (ret != 0)
410 {
411 if (errno != ENOENT)
413 return GNUNET_SYSERR;
414 }
415 if (! S_ISDIR (filestat.st_mode))
416 {
418 "A file already exits with the same name %s\n",
419 fil);
420 return GNUNET_NO;
421 }
422 if (GNUNET_YES == is_readable)
423 ret = access (fil, R_OK | X_OK);
424 else
425 ret = access (fil, X_OK);
426 if (ret < 0)
427 {
429 return GNUNET_NO;
430 }
431 return GNUNET_YES;
432}
@ 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 1087 of file disk.c.

1088{
1089 struct stat istat;
1090
1091 if (NULL == filename)
1092 {
1093 GNUNET_break (0);
1094 return GNUNET_SYSERR;
1095 }
1096 if (0 != lstat (filename, &istat))
1097 return GNUNET_NO; /* file may not exist... */
1098 (void) chmod (filename,
1099 S_IWUSR | S_IRUSR | S_IXUSR);
1100 if (0 == unlink (filename))
1101 return GNUNET_OK;
1102 if ( (errno != EISDIR) &&
1103 /* EISDIR is not sufficient in all cases, e.g.
1104 * sticky /tmp directory may result in EPERM on BSD.
1105 * So we also explicitly check "isDirectory" */
1106 (GNUNET_YES !=
1108 GNUNET_YES)) )
1109 {
1111 return GNUNET_SYSERR;
1112 }
1113 if (GNUNET_SYSERR ==
1115 return GNUNET_SYSERR;
1116 if (0 != rmdir (filename))
1117 {
1119 return GNUNET_SYSERR;
1120 }
1121 return GNUNET_OK;
1122}
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:1077
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:403

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_TESTING_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 char *  cfg_filename,
const char *  option 
)

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

Parameters
cfg_filenameconfiguration file to parse
optionoption with the dir name to purge

Definition at line 1679 of file disk.c.

1681{
1685 (void *) option));
1686}
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:1655
static char * cfg_filename
Name of the configuration file.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_parse_and_run(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 496 of file disk.c.

497{
498 char *rdir;
499 unsigned int len;
500 unsigned int pos;
501 unsigned int pos2;
502 int ret = GNUNET_OK;
503
505 if (rdir == NULL)
506 {
507 GNUNET_break (0);
508 return GNUNET_SYSERR;
509 }
510
511 len = strlen (rdir);
512
513 pos = 1; /* skip heading '/' */
514
515 /* Check which low level directories already exist */
516 pos2 = len;
517 rdir[len] = DIR_SEPARATOR;
518 while (pos <= pos2)
519 {
520 if (DIR_SEPARATOR == rdir[pos2])
521 {
522 rdir[pos2] = '\0';
524 if (GNUNET_NO == ret)
525 {
527 "Creating directory `%s' failed",
528 rdir);
529 GNUNET_free (rdir);
530 return GNUNET_SYSERR;
531 }
532 rdir[pos2] = DIR_SEPARATOR;
533 if (GNUNET_YES == ret)
534 {
535 pos2++;
536 break;
537 }
538 }
539 pos2--;
540 }
541 rdir[len] = '\0';
542 if (pos < pos2)
543 pos = pos2;
544 /* Start creating directories */
545 while (pos <= len)
546 {
547 if ((rdir[pos] == DIR_SEPARATOR) || (pos == len))
548 {
549 rdir[pos] = '\0';
551 if (GNUNET_NO == ret)
552 {
554 "Creating directory `%s' failed",
555 rdir);
556 GNUNET_free (rdir);
557 return GNUNET_SYSERR;
558 }
559 if (GNUNET_SYSERR == ret)
560 {
561 ret = mkdir (rdir,
562 S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH
563 | S_IXOTH); /* 755 */
564
565 if ((ret != 0) && (errno != EEXIST))
566 {
568 GNUNET_free (rdir);
569 return GNUNET_SYSERR;
570 }
571 }
572 rdir[pos] = DIR_SEPARATOR;
573 }
574 pos++;
575 }
576 GNUNET_free (rdir);
577 return GNUNET_OK;
578}
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89
#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 1191 of file disk.c.

1192{
1193 char *idx;
1194 char c;
1195
1196 for (idx = fn; *idx; idx++)
1197 {
1198 c = *idx;
1199
1200 if ((c == '/') || (c == '\\') || (c == ':') || (c == '*') || (c == '?') ||
1201 (c ==
1202 '"')
1203 ||
1204 (c == '<') || (c == '>') || (c == '|') )
1205 {
1206 *idx = '_';
1207 }
1208 }
1209}

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 1213 of file disk.c.

1215{
1216 struct passwd *pws;
1217
1218 pws = getpwnam (user);
1219 if (NULL == pws)
1220 {
1222 _ ("Cannot obtain information about user `%s': %s\n"),
1223 user,
1224 strerror (errno));
1225 return GNUNET_SYSERR;
1226 }
1227 if (0 != chown (filename, pws->pw_uid, pws->pw_gid))
1228 {
1230 return GNUNET_SYSERR;
1231 }
1232 return GNUNET_OK;
1233}

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 1380 of file disk.c.

1384{
1385 int prot;
1386
1387 if (NULL == h)
1388 {
1389 errno = EINVAL;
1390 return NULL;
1391 }
1392 prot = 0;
1393 if (access & GNUNET_DISK_MAP_TYPE_READ)
1394 prot = PROT_READ;
1395 if (access & GNUNET_DISK_MAP_TYPE_WRITE)
1396 prot |= PROT_WRITE;
1398 (*m)->addr = mmap (NULL, len, prot, MAP_SHARED, h->fd, 0);
1399 GNUNET_assert (NULL != (*m)->addr);
1400 if (MAP_FAILED == (*m)->addr)
1401 {
1402 GNUNET_free (*m);
1403 return NULL;
1404 }
1405 (*m)->len = len;
1406 return (*m)->addr;
1407}
#define MAP_FAILED
Definition: disk.c:1375
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
Handle for a memory-mapping operation.
Definition: disk.c:1361

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(), hostkeys_load(), 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 1411 of file disk.c.

1412{
1414
1415 if (NULL == h)
1416 {
1417 errno = EINVAL;
1418 return GNUNET_SYSERR;
1419 }
1420 ret = munmap (h->addr, h->len) != -1 ? GNUNET_OK : GNUNET_SYSERR;
1421 GNUNET_free (h);
1422 return ret;
1423}

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

Referenced by database_setup(), full_recursive_download(), GNUNET_TIME_absolute_get_monotonic(), hostkeys_unload(), 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 1427 of file disk.c.

1428{
1429 if (h == NULL)
1430 {
1431 errno = EINVAL;
1432 return GNUNET_SYSERR;
1433 }
1434
1435#if ! defined(__linux__) || ! defined(GNU)
1436 return fsync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
1437#else
1438 return fdatasync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
1439#endif
1440}

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: