GNUnet  0.11.x
Data Structures | Enumerations | Functions
Disk library

Disk IO APIs. More...

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 41 of file gnunet_disk_lib.h.

42 {
47 
52 
57 };
@ 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 91 of file gnunet_disk_lib.h.

92 {
97 
102 
107 
112 
117 
122 
127 };
@ 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 132 of file gnunet_disk_lib.h.

133 {
138 
143 
148 };
@ 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 154 of file gnunet_disk_lib.h.

155 {
160 
165 
170 
175 
180 
185 
190 
195 
200 
205 };
@ 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 212 of file gnunet_disk_lib.h.

213 {
218 
223 
228 };
@ 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 234 of file gnunet_disk_lib.h.

235 {
240 
245 };
@ 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 406 of file gnunet_disk_lib.h.

407 {
408 
413 
418 
423 
429 
430 };
@ 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 109 of file disk.c.

187 {
188  return ((! h) || (h->fd == -1)) ? GNUNET_YES : GNUNET_NO;
189 }
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94

Referenced by decrementBit(), file_hash_finish(), incrementBit(), maint_child_death(), make_empty_file(), 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 381 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

Referenced by callback_scan_for_operations(), callback_scan_for_rooms(), create_download_context(), create_unique_cfgs(), database_setup(), ego_callback(), gen_topo_from_file(), get_path_from_PATH(), GNUNET_CONFIGURATION_default(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_DISK_file_close(), GNUNET_FRIENDS_parse(), GNUNET_FRIENDS_write_start(), GNUNET_FS_download_start_task_(), GNUNET_HOSTLIST_client_start(), GNUNET_SERVICE_run_(), GNUNET_TESTBED_hosts_load_from_file(), GNUNET_TESTING_get_topo_from_file(), GNUNET_TRANSPORT_TESTING_start_peer(), hostkeys_load(), hosts_directory_scan_callback(), LEGACY_SERVICE_run(), 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_search_strings(), policy_filename_cb(), print_key(), read_host_file(), read_index_list(), read_update_information_graph(), restore_valid_peers(), run(), and start_peer_run().

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

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

Referenced by GNUNET_CONFIGURATION_default_filename().

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

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

Referenced by GNUNET_FRIENDS_write_start().

Here is the call graph for this function:
Here is the caller 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 206 of file disk.c.

209 {
210  static int t[] = { SEEK_SET, SEEK_CUR, SEEK_END };
211 
212  if (h == NULL)
213  {
214  errno = EINVAL;
215  return GNUNET_SYSERR;
216  }
217  return lseek (h->fd, offset, t[whence]);
218 }
static struct GNUNET_SCHEDULER_Task * t
Main task.
@ GNUNET_SYSERR
Definition: gnunet_common.h:93

Referenced by decrementBit(), 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(), make_empty_file(), process_result_with_request(), save_list_messages(), save_list_tunnels(), save_member_session_history(), save_message_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 206 of file disk.c.

226 {
227  struct GetFileSizeData gfsd;
229 
230  GNUNET_assert (size != NULL);
231  gfsd.total = 0;
232  gfsd.include_sym_links = include_symbolic_links;
233  gfsd.single_file_mode = single_file_mode;
234  ret = get_size_rec (&gfsd, filename);
235  *size = gfsd.total;
236  return ret;
237 }
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
Return value of the commandline.
Definition: gnunet-abd.c:81
static char * filename
GNUNET_GenericReturnValue
Named constants for return values.
Definition: gnunet_common.h:92
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static unsigned int size
Size of the "table".
Definition: peer.c:67
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

Referenced by create_download_context(), database_setup(), discard_hosts_helper(), gen_topo_from_file(), GNUNET_CRYPTO_hash_file(), GNUNET_FRIENDS_parse(), GNUNET_FS_file_information_create_from_file(), GNUNET_FS_unindex_start(), GNUNET_TESTBED_hosts_load_from_file(), GNUNET_TESTING_get_topo_from_file(), hostkeys_load(), load(), load_file(), load_keys(), load_search_strings(), main(), policy_filename_cb(), preprocess_file(), print_key(), run(), and setup_ac().

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

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

References GNUNET_SYSERR, h, and t.

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

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

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

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

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

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

Referenced by access_handler_callback(), 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 1235 of file disk.c.

1238 {
1239  char *expfn;
1240  struct GNUNET_DISK_FileHandle *ret;
1241 
1242  int oflags;
1243  int mode;
1244  int fd;
1245 
1247  if (NULL == expfn)
1248  return NULL;
1249 
1250  mode = 0;
1252  oflags = O_RDWR; /* note: O_RDWR is NOT always O_RDONLY | O_WRONLY */
1253  else if (flags & GNUNET_DISK_OPEN_READ)
1254  oflags = O_RDONLY;
1255  else if (flags & GNUNET_DISK_OPEN_WRITE)
1256  oflags = O_WRONLY;
1257  else
1258  {
1259  GNUNET_break (0);
1260  GNUNET_free (expfn);
1261  return NULL;
1262  }
1263  if (flags & GNUNET_DISK_OPEN_FAILIFEXISTS)
1264  oflags |= (O_CREAT | O_EXCL);
1265  if (flags & GNUNET_DISK_OPEN_TRUNCATE)
1266  oflags |= O_TRUNC;
1267  if (flags & GNUNET_DISK_OPEN_APPEND)
1268  oflags |= O_APPEND;
1270  {
1271  if (flags & GNUNET_DISK_OPEN_CREATE)
1272  {
1274  oflags |= O_CREAT;
1275  mode = translate_unix_perms (perm);
1276  }
1277  }
1278 
1279  fd = open (expfn,
1280  oflags
1281 #if O_CLOEXEC
1282  | O_CLOEXEC
1283 #endif
1284  | O_LARGEFILE,
1285  mode);
1286  if (fd == -1)
1287  {
1288  if (0 == (flags & GNUNET_DISK_OPEN_FAILIFEXISTS))
1290  else
1291  LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_DEBUG, "open", expfn);
1292  GNUNET_free (expfn);
1293  return NULL;
1294  }
1295 
1297 
1298  ret->fd = fd;
1299 
1300  GNUNET_free (expfn);
1301  return ret;
1302 }
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
static enum @8 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:482
#define O_LARGEFILE
Definition: platform.h:211
Handle used to access files (and pipes).
int fd
File handle on Unix-like systems.

Referenced by create_hostkeys(), database_setup(), database_shutdown(), full_recursive_download(), get_file_handle(), GNUNET_ATS_solver_logging_write_to_disk(), GNUNET_BIO_read_open_file(), GNUNET_BIO_write_open_file(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_CRYPTO_hash_file(), GNUNET_DISK_fn_read(), GNUNET_FRIENDS_write_start(), 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(), hostkeys_load(), iface_proc(), load_etc_hosts(), load_keys(), load_list_messages(), load_list_tunnels(), load_member_session_history(), load_message_store(), load_message_store_entries(), load_message_store_links(), lookup_dns_servers(), main(), open_static_page(), print_key(), process_result_with_request(), publish_fs_connect_complete_cb(), REGEX_TEST_read_from_file(), restore_valid_peers(), run(), save_list_messages(), save_list_tunnels(), save_member_session_history(), save_message_store(), start_dump(), start_insert(), store_valid_peers(), to_file_raw(), tofile_(), try_match_block(), and write_benchmark_data().

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

195 {
196  struct stat sbuf;
197 
198  if (0 != fstat (fh->fd, &sbuf))
199  return GNUNET_SYSERR;
200  *size = sbuf.st_size;
201  return GNUNET_OK;
202 }
static int fh
Handle to the unique file.

References GNUNET_DISK_PERM_GROUP_EXEC, GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_GROUP_WRITE, GNUNET_DISK_PERM_OTHER_EXEC, GNUNET_DISK_PERM_OTHER_READ, GNUNET_DISK_PERM_OTHER_WRITE, GNUNET_DISK_PERM_USER_EXEC, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, and mode.

Referenced by GNUNET_CONTAINER_bloomfilter_load(), load_etc_hosts(), lookup_dns_servers(), open_static_page(), 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 1442 of file disk.c.

1443 {
1444  int fd[2];
1445 
1446  if (-1 == pipe (fd))
1447  {
1448  int eno = errno;
1449 
1451  errno = eno;
1452  return NULL;
1453  }
1454  return GNUNET_DISK_pipe_from_fd (pf, fd);
1455 }
#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:1459

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(), gnunet_uri(), main(), restart_nat_server(), 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 1459 of file disk.c.

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

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

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

References end, GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, 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(), maint_child_death(), nat_server_read(), restart_nat_server(), and start_process().

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

1534 {
1536 
1538  {
1539  if (p->fd[0])
1540  {
1541  ret = GNUNET_DISK_file_close (p->fd[0]);
1542  p->fd[0] = NULL;
1543  }
1544  }
1545  else if (end == GNUNET_DISK_PIPE_END_WRITE)
1546  {
1547  if (p->fd[1])
1548  {
1549  ret = GNUNET_DISK_file_close (p->fd[1]);
1550  p->fd[1] = NULL;
1551  }
1552  }
1553  return ret;
1554 }
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:1306

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_NAT_mini_get_external_ipv4_(), GNUNET_OS_command_run(), restart_nat_server(), and start_helper().

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

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

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

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

References GNUNET_DISK_FileHandle::fd, fn, 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 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_ATS_solver_logging_write_to_disk(), GNUNET_BIO_flush(), GNUNET_BIO_read_close(), GNUNET_BIO_write_close(), GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_CRYPTO_hash_file_cancel(), GNUNET_DISK_fn_read(), GNUNET_FRIENDS_write_stop(), 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(), 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(), lookup_dns_servers(), main(), open_static_page(), parent_control_handler(), print_key(), process_result_with_request(), publish_fs_connect_complete_cb(), reconstruct_cont(), REGEX_TEST_read_from_file(), restore_valid_peers(), run(), save_list_messages(), save_list_tunnels(), save_member_session_history(), save_message_store(), shutdown_pch(), shutdown_task(), start_process(), store_valid_peers(), to_file_raw(), tofile_(), try_match_block(), unindex_finish(), unload_keys(), and write_benchmark_data().

Here is the call graph for this function:

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

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

Referenced by child_death_task(), GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_OS_command_run(), GNUNET_SCHEDULER_driver_init(), gnunet_uri(), GNUNET_wait_child(), maint_child_death(), restart_nat_server(), run(), shutdown_pipe_cb(), sighandler_child_death(), sighandler_chld(), sighandler_shutdown(), start_helper(), start_process(), tokenizer_cb(), 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 321 of file disk.c.

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

References fn, GNUNET_ERROR_TYPE_WARNING, GNUNET_log_strerror_file, GNUNET_YES, and mode.

Referenced by create_listen_socket(), LEGACY_SERVICE_start(), and service_task().

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

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

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

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

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 }
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
static int result
Global testing status.

References GNUNET_SYSERR, h, len, and result.

Referenced by child_death_task(), cmd_read(), database_setup(), decrementBit(), fh_reader(), file_hash_task(), get_store_message(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_DISK_fn_read(), GNUNET_FS_data_reader_file_(), GNUNET_FS_handle_on_demand_block(), helper_read(), incrementBit(), load_list_messages(), load_list_tunnels(), load_member_session_history(), load_message_store_entries(), load_message_store_links(), main(), maint_child_death(), nat_server_read(), parent_control_handler(), print_key(), put_cb(), read_external_ipv4(), 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, len, 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 {
668  struct GNUNET_DISK_FileHandle *fh;
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:1235
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, fn, 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, len, result, and ret.

Referenced by discard_hosts_helper(), ego_callback(), gen_topo_from_file(), GNUNET_FRIENDS_parse(), GNUNET_TESTBED_hosts_load_from_file(), GNUNET_TESTING_get_topo_from_file(), load_file(), load_search_strings(), policy_filename_cb(), read_host_file(), run(), and setup_ac().

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(), do_shutdown(), get_cb(), GNUNET_ATS_solver_logging_write_to_disk(), GNUNET_BIO_flush(), GNUNET_FRIENDS_write(), GNUNET_OS_process_kill(), GNUNET_TESTING_peer_configure(), handle_estimate(), helper_write(), incrementBit(), iterate_save_entries(), iterate_save_links(), iterate_save_member_session_history_hentries(), iterate_save_messages(), main(), make_empty_file(), process_result_with_request(), publicize_rm(), publish_fs_connect_complete_cb(), regex_found_handler(), save_list_messages(), save_list_tunnels(), sighandler_child_death(), sighandler_chld(), sighandler_shutdown(), start_dump(), stat_iterator(), stats_iterator(), store_and_free_entries(), store_peer_presistently_iterator(), to_file_raw(), tofile_(), try_match_block(), 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 701 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 }
static char buf[2048]
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.

Referenced by calculate_pow(), clean_task(), discard_hosts_helper(), dump_my_hello(), GNUNET_FRIENDS_parse(), handle_create_message(), main(), shutdown_task(), sync_pow(), update_hello(), and write_proof().

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

1126 {
1127  char *buf;
1128  uint64_t pos;
1129  uint64_t size;
1130  size_t len;
1131  ssize_t sret;
1132  struct GNUNET_DISK_FileHandle *in;
1133  struct GNUNET_DISK_FileHandle *out;
1134 
1136  {
1138  return GNUNET_SYSERR;
1139  }
1140  pos = 0;
1141  in =
1143  if (! in)
1144  {
1146  return GNUNET_SYSERR;
1147  }
1148  out =
1149  GNUNET_DISK_file_open (dst,
1156  if (! out)
1157  {
1160  return GNUNET_SYSERR;
1161  }
1163  while (pos < size)
1164  {
1165  len = COPY_BLK_SIZE;
1166  if (len > size - pos)
1167  len = size - pos;
1168  sret = GNUNET_DISK_file_read (in, buf, len);
1169  if ((sret < 0) || (len != (size_t) sret))
1170  goto FAIL;
1171  sret = GNUNET_DISK_file_write (out, buf, len);
1172  if ((sret < 0) || (len != (size_t) sret))
1173  goto FAIL;
1174  pos += len;
1175  }
1176  GNUNET_free (buf);
1178  GNUNET_DISK_file_close (out);
1179  return GNUNET_OK;
1180  FAIL:
1181  GNUNET_free (buf);
1183  GNUNET_DISK_file_close (out);
1184  return GNUNET_SYSERR;
1185 }
#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: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:222

◆ 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  {
852  LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "opendir", dname);
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  {
870  GNUNET_free (name);
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);
890  GNUNET_free (name);
891  GNUNET_free (dname);
892  if (GNUNET_NO == ret)
893  return count;
894  return GNUNET_SYSERR;
895  }
896  }
897  count++;
898  }
899  closedir (dinfo);
900  GNUNET_free (name);
901  GNUNET_free (dname);
902  return count;
903 }
#define LOG(kind,...)
Definition: disk.c:31
static const char * dir_name
Top-level directory we monitor to auto-publish.
#define DIR_SEPARATOR
Definition: platform.h:164
#define DIR_SEPARATOR_STR
Definition: platform.h:165
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
const char * name

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 cron_clean_data_hosts(), cron_scan_directory_data_hosts(), deserialization_master(), deserialize_download(), deserialize_search(), determine_id(), discover_testbed_nodes(), do_directory_scan(), GNUNET_DISK_directory_remove(), GNUNET_PLUGIN_load_all(), iter_testbed_path(), load_handle_configuration(), load_member(), load_member_store(), load_operation_store(), preprocess_file(), profiler_eval(), 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_patterbthe 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 1007 of file disk.c.

1010 {
1011  char *mypat = GNUNET_strdup (glob_pattern);
1012  char *sep;
1013  int ret;
1014 
1015  if ( (NULL != strrchr (glob_pattern, '+')) ||
1016  (NULL != strrchr (glob_pattern, '[')) ||
1017  (NULL != strrchr (glob_pattern, '+')) ||
1018  (NULL != strrchr (glob_pattern, '~')) )
1019  {
1021  "unsupported glob pattern: '%s'\n",
1022  glob_pattern);
1023  GNUNET_free (mypat);
1024  return -1;
1025  }
1026 
1027  sep = strrchr (mypat, DIR_SEPARATOR);
1028  if (NULL == sep)
1029  {
1030  GNUNET_free (mypat);
1031  return -1;
1032  }
1033 
1034  *sep = '\0';
1035 
1036  if (NULL != strchr (mypat, '*'))
1037  {
1038  GNUNET_free (mypat);
1039  GNUNET_break (0);
1041  "glob pattern may only contain '*' in the final path component\n");
1042  return -1;
1043  }
1044 
1045  {
1046  struct GlobClosure gc = {
1047  .glob = sep + 1,
1048  .cb = callback,
1049  .cls = callback_cls,
1050  .nres = 0,
1051  };
1053  "scanning directory '%s' for glob matches on '%s'\n",
1054  mypat,
1055  gc.glob);
1057  glob_cb,
1058  &gc
1059  );
1060  GNUNET_free (mypat);
1061  return (ret < 0) ? ret : gc.nres;
1062  }
1063 }
static enum GNUNET_GenericReturnValue glob_cb(void *cls, const char *filename)
Function called with a filename.
Definition: disk.c:976
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:963
const char * glob
Definition: disk.c:956

◆ 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 381 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 int res
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create(const char *dir)
Implementation of "mkdir -p".
Definition: disk.c:496

Referenced by callback_set_handle_name(), create_hostkeys(), database_setup(), get_server_addresses(), GNUNET_ATS_solver_logging_write_to_disk(), GNUNET_DISK_file_close(), GNUNET_FRIENDS_write_start(), GNUNET_FS_download_sync_(), LEGACY_SERVICE_get_server_addresses(), main(), make_serialization_file_name(), make_serialization_file_name_in_dir(), run(), save(), save_hostlist_file(), setup_log_file(), store_valid_peers(), trigger_recursive_download(), unix_transport_server_start(), and update_hello().

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

405 {
406  struct stat filestat;
407  int ret;
408 
409  ret = stat (fil, &filestat);
410  if (ret != 0)
411  {
412  if (errno != ENOENT)
414  return GNUNET_SYSERR;
415  }
416  if (! S_ISDIR (filestat.st_mode))
417  {
419  "A file already exits with the same name %s\n",
420  fil);
421  return GNUNET_NO;
422  }
423  if (GNUNET_YES == is_readable)
424  ret = access (fil, R_OK | X_OK);
425  else
426  ret = access (fil, X_OK);
427  if (ret < 0)
428  {
430  return GNUNET_NO;
431  }
432  return GNUNET_YES;
433 }
@ GNUNET_ERROR_TYPE_INFO

Referenced by callback_scan_for_members(), callback_scan_for_sessions(), callback_set_handle_name(), create_service(), deserialization_master(), deserialize_download(), deserialize_search(), get_store_operation_type(), GNUNET_CONFIGURATION_load(), 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_handle_configuration(), load_member(), load_member_store(), load_operation_store(), load_room(), run(), save_handle_configuration(), save_member(), save_member_store(), and save_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 1007 of file disk.c.

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

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 access_handler_callback(), calculate_pow(), clean_task(), delete_files(), discard_hosts_helper(), GNUNET_FS_remove_sync_dir_(), GNUNET_TESTING_system_destroy(), main(), publish_timeout(), remove_room_member_session(), report_uri(), run(), 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 1678 of file disk.c.

1680 {
1683  &purge_cfg_dir,
1684  (void *) option));
1685 }
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:1654
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 381 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 fn, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, LOG_STRERROR_FILE, mktemp_name(), and t.

Referenced by create_service(), cron_scan_directory_data_hosts(), ensure_folder_exist(), get_store_operation_type(), iterate_save_members(), iterate_save_session(), run(), save_handle_configuration(), save_member(), save_member_store(), save_room(), write_benchmark_data(), and write_pid_file().

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

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

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

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

References fn.

Referenced by write_pid_file().

Here is the caller graph for this function:

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

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

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

Referenced by database_setup(), full_recursive_download(), hostkeys_load(), load_etc_hosts(), load_keys(), 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 1378 of file disk.c.

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

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

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

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

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

Here is the caller graph for this function: