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.
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).
enum GNUNET_GenericReturnValue	GNUNET_DISK_file_test_read (const char *fil)
	Check that fil corresponds to a filename and the file has read permissions.
char *	GNUNET_DISK_file_backup (const char *fil)
	Move a file out of the way (create a backup) by renaming it to "orig.NUM~" where NUM is the smallest number that is not used yet.
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.
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).
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.
char *	GNUNET_DISK_mktemp (const char *t)
	Create an (empty) temporary file on disk.
char *	GNUNET_DISK_mkdtemp (const char *t)
	Create an (empty) temporary directory on disk.
struct GNUNET_DISK_FileHandle *	GNUNET_DISK_file_open (const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
	Open a file.
enum GNUNET_GenericReturnValue	GNUNET_DISK_file_handle_size (struct GNUNET_DISK_FileHandle *fh, off_t *size)
	Get the size of an open file.
struct GNUNET_DISK_PipeHandle *	GNUNET_DISK_pipe (enum GNUNET_DISK_PipeFlags pf)
	Creates an interprocess channel.
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.
enum GNUNET_GenericReturnValue	GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p)
	Closes an interprocess channel.
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.
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.
enum GNUNET_GenericReturnValue	GNUNET_DISK_file_close (struct GNUNET_DISK_FileHandle *h)
	Close an open file.
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.
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.
struct GNUNET_DISK_FileHandle *	GNUNET_DISK_get_handle_from_int_fd (int fno)
	Get a handle from a native integer FD.
struct GNUNET_DISK_FileHandle *	GNUNET_DISK_get_handle_from_native (FILE *fd)
	Get a handle from a native FD.
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.
ssize_t	GNUNET_DISK_fn_read (const char *fn, void *result, size_t len)
	Read the contents of a binary file into a buffer.
ssize_t	GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
	Write a buffer to a file.
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.
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.
enum GNUNET_GenericReturnValue	GNUNET_DISK_file_copy (const char *src, const char *dst)
	Copy a file.
int	GNUNET_DISK_directory_scan (const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
	Scan a directory for files.
int	GNUNET_DISK_glob (const char *glob_pattern, GNUNET_FileNameCallback callback, void *callback_cls)
	Find all files matching a glob pattern.
enum GNUNET_GenericReturnValue	GNUNET_DISK_directory_create_for_file (const char *filename)
	Create the directory structure for storing a file.
enum GNUNET_GenericReturnValue	GNUNET_DISK_directory_test (const char *fil, int is_readable)
	Test if fil is a directory and listable.
enum GNUNET_GenericReturnValue	GNUNET_DISK_directory_remove (const char *filename)
	Remove all files in a directory (rm -rf).
void	GNUNET_DISK_purge_cfg_dir (const struct GNUNET_OS_ProjectData *pd, const char *cfg_filename, const char *option)
	Remove the directory given under option in section [PATHS] in configuration under cfg_filename.
enum GNUNET_GenericReturnValue	GNUNET_DISK_directory_create (const char *dir)
	Implementation of "mkdir -p".
void	GNUNET_DISK_filename_canonicalize (char *fn)
	Removes special characters as ':' from a filename.
enum GNUNET_GenericReturnValue	GNUNET_DISK_file_change_owner (const char *filename, const char *user)
	Change owner of a file.
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.
enum GNUNET_GenericReturnValue	GNUNET_DISK_file_unmap (struct GNUNET_DISK_MapHandle *h)
	Unmap a file.
enum GNUNET_GenericReturnValue	GNUNET_DISK_file_sync (const struct GNUNET_DISK_FileHandle *h)
	Write file changes to disk.

Detailed Description

Disk IO APIs.

Enumeration Type Documentation

GNUNET_FILE_Type

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

{
  GNUNET_DISK_HANLDE_TYPE_EVENT,
 
  GNUNET_DISK_HANLDE_TYPE_FILE,
 
  GNUNET_DISK_HANLDE_TYPE_PIPE
};

GNUNET_DISK_OpenFlags

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

{
  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
};

GNUNET_DISK_MapType

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

{
  GNUNET_DISK_MAP_TYPE_READ = 1,
 
  GNUNET_DISK_MAP_TYPE_WRITE = 2,
 
  GNUNET_DISK_MAP_TYPE_READWRITE = 3
};

GNUNET_DISK_AccessPermissions

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

{
  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
};

GNUNET_DISK_Seek

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

{
  GNUNET_DISK_SEEK_SET = 0,
 
  GNUNET_DISK_SEEK_CUR = 1,
 
  GNUNET_DISK_SEEK_END = 2
};

GNUNET_DISK_PipeEnd

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

{
  GNUNET_DISK_PIPE_END_READ = 0,
 
  GNUNET_DISK_PIPE_END_WRITE = 1
};

GNUNET_DISK_PipeFlags

enum GNUNET_DISK_PipeFlags

Flags for GNUNET_DISK_pipe().

Enumerator
GNUNET_DISK_PF_NONE	No special options, use non-blocking read/write operations.
GNUNET_DISK_PF_BLOCKING_READ	Configure read end to block when reading if set.
GNUNET_DISK_PF_BLOCKING_WRITE	Configure write end to block when writing if set.
GNUNET_DISK_PF_BLOCKING_RW	Configure both pipe ends for blocking operations if set.

Definition at line 419 of file gnunet_disk_lib.h.

{
 
  GNUNET_DISK_PF_NONE,
 
  GNUNET_DISK_PF_BLOCKING_READ = 1,
 
  GNUNET_DISK_PF_BLOCKING_WRITE = 2,
 
  GNUNET_DISK_PF_BLOCKING_RW = GNUNET_DISK_PF_BLOCKING_READ
                               | GNUNET_DISK_PF_BLOCKING_WRITE
 
};

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

h	handle to check

Returns

GNUNET_YES if invalid, GNUNET_NO if valid

Definition at line 199 of file disk.c.

{
  return ((! h) || (h->fd == -1)) ? 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

fil	filename 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 557 of file disk.c.

{
  return file_test_internal (fil,
                             F_OK);
}

References file_test_internal().

Referenced by callback_scan_for_operations(), create_download_context(), create_unique_cfgs(), database_connect(), database_setup(), database_setup(), database_setup(), database_setup(), database_setup(), ego_callback(), get_path_from_PATH(), get_topo_string_from_file(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_DISK_file_open(), GNUNET_FS_download_start_task_(), GNUNET_HOSTLIST_client_start(), GNUNET_PROGRAM_conf_and_options(), GNUNET_PROGRAM_run2(), GNUNET_SERVICE_run_(), GNUNET_TRANSPORT_TESTING_start_peer(), hosts_directory_scan_callback(), load_hostlist_file(), load_list_messages(), load_list_tunnels(), load_member(), load_member_session(), load_member_session_history(), load_member_session_next(), load_message_store(), load_peer_store(), load_search_strings(), main(), PABC_load_public_parameters(), print_key(), read_file(), read_index_list(), read_update_information_graph(), restore_valid_peers(), run(), run(), run(), run(), run(), run(), run(), start_peer_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

fil	filename 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 565 of file disk.c.

{
  return file_test_internal (fil,
                             R_OK);
}

References file_test_internal().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DISK_file_backup()

char * GNUNET_DISK_file_backup

(

const char *

fil

)

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

Parameters

fil	name of the file to back up

Returns

the backup file name (must be freed by caller)

Definition at line 373 of file disk.c.

{
  size_t slen;
  char *target;
  unsigned int num;
 
  slen = strlen (fil) + 20;
  target = GNUNET_malloc (slen);
  num = 0;
 
#if HAVE_RENAMEAT2
  {
    int fd;
 
    do
    {
      GNUNET_snprintf (target,
                       slen,
                       "%s.%u~",
                       fil,
                       num++);
      fd = open (target,
                 O_CREAT | O_EXCL,
                 translate_unix_perms (GNUNET_DISK_PERM_USER_WRITE));
    } while (-1 == fd);
    if (0 != renameat2 (AT_FDCWD,
                        fil,
                        AT_FDCWD,
                        target,
                        RENAME_EXCHANGE))
    {
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                "renameat2",
                                fil);
      GNUNET_break (0 ==
                    close (fd));
      return NULL;
    }
    GNUNET_break (0 ==
                  close (fd));
  }
#else
  do
  {
    GNUNET_snprintf (target,
                     slen,
                     "%s.%u~",
                     fil,
                     num++);
  }
  while (0 == access (target,
                      F_OK));
  if (0 != rename (fil,
                   target))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                              "rename",
                              fil);
    return NULL;
  }
#endif
  return target;
}

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

Here is the call graph for this function:

GNUNET_DISK_file_seek()

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

Move the read/write pointer in a file.

Parameters

h	handle of an open file
offset	position to move to
whence	specification to which position the offset parameter relates to

Returns

the new position on success, GNUNET_SYSERR otherwise

Definition at line 219 of file disk.c.

{
  static int t[] = { SEEK_SET, SEEK_CUR, SEEK_END };
 
  if (h == NULL)
  {
    errno = EINVAL;
    return GNUNET_SYSERR;
  }
  return lseek (h->fd, offset, t[whence]);
}

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

filename	name of the file or directory
size	set to the size of the file (or, in the case of directories, the sum of all sizes of files in the directory)
include_symbolic_links	should symbolic links be included?
single_file_mode	GNUNET_YES to only get size of one file and return GNUNET_SYSERR for directories.

Returns

GNUNET_SYSERR on error, GNUNET_OK on success

Definition at line 235 of file disk.c.

{
  struct GetFileSizeData gfsd;
  enum GNUNET_GenericReturnValue ret;
 
  GNUNET_assert (size != NULL);
  gfsd.total = 0;
  gfsd.include_sym_links = include_symbolic_links;
  gfsd.single_file_mode = single_file_mode;
  ret = get_size_rec (&gfsd, filename);
  *size = gfsd.total;
  return ret;
}

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(), database_setup(), get_topo_string_from_file(), GNUNET_CONFIGURATION_parse(), GNUNET_CRYPTO_hash_file(), GNUNET_DISK_file_copy(), GNUNET_FS_file_information_create_from_file(), GNUNET_FS_unindex_start(), load(), load_file(), load_message_store_entries(), load_message_store_epochs(), load_message_store_links(), load_search_strings(), preprocess_file(), print_key(), run(), 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

filename	name of the file
dev	set to the device ID
ino	set to the inode ID

Returns

GNUNET_OK on success

Definition at line 254 of file disk.c.

{
#if HAVE_STAT
  {
    struct stat sbuf;
 
    if (0 != stat (filename, &sbuf))
    {
      return GNUNET_SYSERR;
    }
    *ino = (uint64_t) sbuf.st_ino;
  }
#else
  *ino = 0;
#endif
#if HAVE_STATVFS
  {
    struct statvfs fbuf;
 
    if (0 != statvfs (filename, &fbuf))
    {
      return GNUNET_SYSERR;
    }
    *dev = (uint64_t) fbuf.f_fsid;
  }
#elif HAVE_STATFS
  {
    struct statfs fbuf;
 
    if (0 != statfs (filename, &fbuf))
    {
      return GNUNET_SYSERR;
    }
    *dev =
      ((uint64_t) fbuf.f_fsid.val[0]) << 32 || ((uint64_t) fbuf.f_fsid.val[1]);
  }
#else
  *dev = 0;
#endif
  return 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

t	component 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 439 of file disk.c.

{
  int fd;
  char *fn;
  mode_t omask;
 
  omask = umask (S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
  fn = mktemp_name (t);
  if (-1 == (fd = mkstemp (fn)))
  {
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR,
                       "mkstemp",
                       fn);
    GNUNET_free (fn);
    umask (omask);
    return NULL;
  }
  umask (omask);
  if (0 != close (fd))
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
                       "close",
                       fn);
  return fn;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DISK_mkdtemp()

char * GNUNET_DISK_mkdtemp

(

const char *

t

)

Create an (empty) temporary directory on disk.

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

Parameters

t	component to use for the name; does NOT contain "XXXXXX" or "/tmp/".

Returns

NULL on error, otherwise name of freshly created directory

Definition at line 353 of file disk.c.

{
  char *fn;
  mode_t omask;
 
  omask = umask (S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
  fn = mktemp_name (t);
  if (fn != mkdtemp (fn))
  {
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "mkdtemp", fn);
    GNUNET_free (fn);
    umask (omask);
    return NULL;
  }
  umask (omask);
  return fn;
}

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

Referenced by create_response(), and GNUNET_TESTBED_system_create_with_portrange().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DISK_file_open()

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

Open a file.

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

Parameters

fn	file name to be opened
flags	opening flags, a combination of GNUNET_DISK_OPEN_xxx bit flags
perm	permissions 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 1308 of file disk.c.

{
  char *expfn;
  struct GNUNET_DISK_FileHandle *ret;
 
  int oflags;
  int mode;
  int fd;
 
  expfn = GNUNET_STRINGS_filename_expand (fn);
  if (NULL == expfn)
    return NULL;
 
  mode = 0;
  if (GNUNET_DISK_OPEN_READWRITE == (flags & GNUNET_DISK_OPEN_READWRITE))
    oflags = O_RDWR; /* note: O_RDWR is NOT always O_RDONLY | O_WRONLY */
  else if (flags & GNUNET_DISK_OPEN_READ)
    oflags = O_RDONLY;
  else if (flags & GNUNET_DISK_OPEN_WRITE)
    oflags = O_WRONLY;
  else
  {
    GNUNET_break (0);
    GNUNET_free (expfn);
    return NULL;
  }
  if (flags & GNUNET_DISK_OPEN_FAILIFEXISTS)
    oflags |= (O_CREAT | O_EXCL);
  if (flags & GNUNET_DISK_OPEN_TRUNCATE)
    oflags |= O_TRUNC;
  if (flags & GNUNET_DISK_OPEN_APPEND)
    oflags |= O_APPEND;
  if (GNUNET_NO == GNUNET_DISK_file_test (fn))
  {
    if (flags & GNUNET_DISK_OPEN_CREATE)
    {
      (void) GNUNET_DISK_directory_create_for_file (expfn);
      oflags |= O_CREAT;
      mode = translate_unix_perms (perm);
    }
  }
 
  // Setting O_CLOEXEC after pipe() may introduce
  // race conditions: https://bugs.gnunet.org/view.php?id=9311
  // This is no problem if the platform supports pipe2
  fd = open (expfn,
             oflags
#if O_CLOEXEC
             | O_CLOEXEC
#endif
             | O_LARGEFILE,
             mode);
  if (fd == -1)
  {
    if (0 == (flags & GNUNET_DISK_OPEN_FAILIFEXISTS))
      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
                         "open",
                         expfn);
    else
      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_DEBUG,
                         "open",
                         expfn);
    GNUNET_free (expfn);
    return NULL;
  }
 
  ret = GNUNET_new (struct GNUNET_DISK_FileHandle);
 
  ret->fd = fd;
 
  GNUNET_free (expfn);
  return ret;
}

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

Referenced by database_setup(), database_setup(), database_shutdown(), database_shutdown(), full_recursive_download(), get_file_handle(), GNUNET_BIO_read_open_file(), GNUNET_BIO_write_open_file(), GNUNET_CONFIGURATION_write(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_CRYPTO_hash_file(), GNUNET_DISK_file_copy(), GNUNET_DISK_fn_read(), GNUNET_FS_data_reader_file_(), GNUNET_FS_download_start_task_(), GNUNET_FS_handle_on_demand_block(), GNUNET_FS_unindex_do_remove_(), GNUNET_TIME_absolute_get_monotonic(), load_etc_hosts(), load_ikm(), load_list_messages(), load_list_tunnels(), load_member_session_history(), load_message_store(), load_message_store_entries(), load_message_store_epochs(), 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(), run(), run(), 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:

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

fh	open file handle
size	where to write size of the file

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 206 of file disk.c.

{
  struct stat sbuf;
 
  if (0 != fstat (fh->fd, &sbuf))
    return GNUNET_SYSERR;
  *size = sbuf.st_size;
  return GNUNET_OK;
}

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

Referenced by GNUNET_CONTAINER_bloomfilter_load(), GNUNET_TIME_absolute_get_monotonic(), load_etc_hosts(), load_ikm(), 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

pf	how to configure the pipe

Returns

handle to the new pipe, NULL on error

Definition at line 1523 of file disk.c.

{
  int fd[2];
 
#if HAVE_PIPE2 && O_CLOEXEC
  if (-1 == pipe2 (fd, O_CLOEXEC))
#else
  if (-1 == pipe (fd))
#endif
  {
    int eno = errno;
 
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "pipe");
    errno = eno;
    return NULL;
  }
  return GNUNET_DISK_pipe_from_fd (pf, fd);
}

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

pf	how to configure the pipe
fd	an 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 1544 of file disk.c.

{
  struct GNUNET_DISK_PipeHandle *p;
  int ret = 0;
  int flags;
  int eno = 0; /* make gcc happy */
 
  p = GNUNET_new (struct GNUNET_DISK_PipeHandle);
  if (fd[0] >= 0)
  {
    p->fd[0] = GNUNET_new (struct GNUNET_DISK_FileHandle);
    p->fd[0]->fd = fd[0];
    if (0 == (GNUNET_DISK_PF_BLOCKING_READ & pf))
    {
      flags = fcntl (fd[0], F_GETFL);
      flags |= O_NONBLOCK;
      if (0 > fcntl (fd[0], F_SETFL, flags))
      {
        ret = -1;
        eno = errno;
      }
    }
    flags = fcntl (fd[0], F_GETFD);
    flags |= FD_CLOEXEC;
    if (0 > fcntl (fd[0], F_SETFD, flags))
    {
      ret = -1;
      eno = errno;
    }
  }
 
  if (fd[1] >= 0)
  {
    p->fd[1] = GNUNET_new (struct GNUNET_DISK_FileHandle);
    p->fd[1]->fd = fd[1];
    if (0 == (GNUNET_DISK_PF_BLOCKING_WRITE & pf))
    {
      flags = fcntl (fd[1], F_GETFL);
      flags |= O_NONBLOCK;
      if (0 > fcntl (fd[1], F_SETFL, flags))
      {
        ret = -1;
        eno = errno;
      }
    }
    flags = fcntl (fd[1], F_GETFD);
    flags |= FD_CLOEXEC;
    if (0 > fcntl (fd[1], F_SETFD, flags))
    {
      ret = -1;
      eno = errno;
    }
  }
  if (ret == -1)
  {
    errno = eno;
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fcntl");
    if (p->fd[0]->fd >= 0)
      GNUNET_break (0 == close (p->fd[0]->fd));
    if (p->fd[1]->fd >= 0)
      GNUNET_break (0 == close (p->fd[1]->fd));
    GNUNET_free (p->fd[0]);
    GNUNET_free (p->fd[1]);
    GNUNET_free (p);
    errno = eno;
    return NULL;
  }
  return p;
}

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

p

pipe

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1670 of file disk.c.

{
  enum GNUNET_GenericReturnValue ret = GNUNET_OK;
  enum GNUNET_GenericReturnValue read_end_close;
  enum GNUNET_GenericReturnValue write_end_close;
  int read_end_close_errno;
  int write_end_close_errno;
 
  read_end_close = GNUNET_DISK_pipe_close_end (p,
                                               GNUNET_DISK_PIPE_END_READ);
  read_end_close_errno = errno;
  write_end_close = GNUNET_DISK_pipe_close_end (p,
                                                GNUNET_DISK_PIPE_END_WRITE);
  write_end_close_errno = errno;
  GNUNET_free (p);
 
  if (GNUNET_OK != read_end_close)
  {
    errno = read_end_close_errno;
    ret = read_end_close;
  }
  else if (GNUNET_OK != write_end_close)
  {
    errno = write_end_close_errno;
    ret = write_end_close;
  }
 
  return ret;
}

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

p	pipe to close end of
end	which end of the pipe to close

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1617 of file disk.c.

{
  enum GNUNET_GenericReturnValue ret = GNUNET_OK;
 
  if (end == GNUNET_DISK_PIPE_END_READ)
  {
    if (p->fd[0])
    {
      ret = GNUNET_DISK_file_close (p->fd[0]);
      p->fd[0] = NULL;
    }
  }
  else if (end == GNUNET_DISK_PIPE_END_WRITE)
  {
    if (p->fd[1])
    {
      ret = GNUNET_DISK_file_close (p->fd[1]);
      p->fd[1] = NULL;
    }
  }
  return ret;
}

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

p	pipe to detach an end from
end	which 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 1643 of file disk.c.

{
  struct GNUNET_DISK_FileHandle *ret = NULL;
 
  if (end == GNUNET_DISK_PIPE_END_READ)
  {
    if (p->fd[0])
    {
      ret = p->fd[0];
      p->fd[0] = NULL;
    }
  }
  else if (end == GNUNET_DISK_PIPE_END_WRITE)
  {
    if (p->fd[1])
    {
      ret = p->fd[1];
      p->fd[1] = NULL;
    }
  }
 
  return ret;
}

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

h	file handle

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1386 of file disk.c.

{
  enum GNUNET_GenericReturnValue ret;
 
  if (NULL == h)
  {
    errno = EINVAL;
    return GNUNET_SYSERR;
  }
 
  ret = GNUNET_OK;
  if (0 != close (h->fd))
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
                  "close");
    ret = GNUNET_SYSERR;
  }
  GNUNET_free (h);
  return ret;
}

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

Referenced by check_completed(), clear_message_store(), close_files_iter(), database_setup(), database_setup(), database_shutdown(), database_shutdown(), do_shutdown(), do_shutdown(), file_hash_finish(), full_recursive_download(), get_cb(), GNUNET_ARM_operation_cancel(), GNUNET_ARM_request_service_start(), GNUNET_BIO_flush(), GNUNET_BIO_read_close(), GNUNET_BIO_write_close(), GNUNET_CONFIGURATION_write(), GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_CRYPTO_hash_file_cancel(), GNUNET_DISK_file_copy(), GNUNET_DISK_fn_read(), GNUNET_DISK_pipe_close_end(), GNUNET_FS_data_reader_file_(), GNUNET_FS_download_signal_suspend_(), GNUNET_FS_download_start_task_(), GNUNET_FS_handle_on_demand_block(), GNUNET_FS_unindex_signal_suspend_(), GNUNET_FS_unindex_stop(), GNUNET_OS_process_destroy(), GNUNET_TIME_absolute_get_monotonic(), load_etc_hosts(), load_ikm(), load_list_messages(), load_list_tunnels(), load_member_session_history(), load_message_store(), load_message_store_entries(), load_message_store_epochs(), 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(), 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

p	pipe
n	end to access

Returns

handle for the respective end

Definition at line 1702 of file disk.c.

{
  switch (n)
  {
  case GNUNET_DISK_PIPE_END_READ:
  case GNUNET_DISK_PIPE_END_WRITE:
    return p->fd[n];
 
  default:
    GNUNET_break (0);
    return NULL;
  }
}

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(), maint_child_death(), maint_child_death(), restart_nat_server(), run(), run(), run(), shutdown_pipe_cb(), sighandler_child_death(), sighandler_child_death(), sighandler_child_death(), 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

fn	name of the file to update
require_uid_match	GNUNET_YES means 700
require_gid_match	GNUNET_YES means 770 unless require_uid_match is set

Definition at line 334 of file disk.c.

{
  mode_t mode;
 
  if (GNUNET_YES == require_uid_match)
    mode = S_IRUSR | S_IWUSR | S_IXUSR;
  else if (GNUNET_YES == require_gid_match)
    mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP;
  else
    mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH
           | S_IWOTH | S_IXOTH;
  if (0 != chmod (fn, mode))
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "chmod", fn);
}

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

fno	native integer file descriptor

Returns

file handle corresponding to the descriptor

Definition at line 1409 of file disk.c.

{
  struct GNUNET_DISK_FileHandle *fh;
 
  if ((((off_t) -1) == lseek (fno, 0, SEEK_CUR)) && (EBADF == errno))
    return NULL; /* invalid FD */
 
  fh = GNUNET_new (struct GNUNET_DISK_FileHandle);
 
  fh->fd = fno;
 
  return fh;
}

References GNUNET_DISK_FileHandle::fd, and GNUNET_new.

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

Here is the caller graph for this function:

GNUNET_DISK_get_handle_from_native()

struct GNUNET_DISK_FileHandle * GNUNET_DISK_get_handle_from_native

(

FILE *

fd

)

Get a handle from a native FD.

Parameters

fd	native file descriptor

Returns

file handle corresponding to the descriptor

Definition at line 1425 of file disk.c.

{
  int fno;
 
  fno = fileno (fd);
  if (-1 == fno)
    return NULL;
  return GNUNET_DISK_get_handle_from_int_fd (fno);
}

References GNUNET_DISK_FileHandle::fd, and GNUNET_DISK_get_handle_from_int_fd().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DISK_file_read()

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

Read the contents of a binary file into a buffer.

Parameters

h	handle to an open file
result	the buffer to write the result to
len	the maximum number of bytes to read

Returns

the number of bytes read on success, GNUNET_SYSERR on failure

Definition at line 704 of file disk.c.

{
  if (NULL == h)
  {
    errno = EINVAL;
    return GNUNET_SYSERR;
  }
  return read (h->fd,
               result,
               len);
}

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_ikm(), load_list_messages(), load_list_tunnels(), load_member_session_history(), load_message_store_attribute(), load_peer_store(), maint_child_death(), maint_child_death(), 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(), run(), shutdown_pipe_cb(), start_insert(), try_top_down_reconstruction(), and unindex_reader().

Here is the caller graph for this function:

GNUNET_DISK_fn_read()

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

Read the contents of a binary file into a buffer.

Parameters

fn	file name
result	the buffer to write the result to
len	the maximum number of bytes to read

Returns

number of bytes read, GNUNET_SYSERR on failure

Definition at line 720 of file disk.c.

{
  struct GNUNET_DISK_FileHandle *fh;
  ssize_t ret;
  int eno;
 
  fh = GNUNET_DISK_file_open (fn,
                              GNUNET_DISK_OPEN_READ,
                              GNUNET_DISK_PERM_NONE);
  if (NULL == fh)
    return GNUNET_SYSERR;
  ret = GNUNET_DISK_file_read (fh,
                               result,
                               len);
  eno = errno;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_DISK_file_close (fh));
  errno = eno;
  return ret;
}

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

Referenced by ego_callback(), get_topo_string_from_file(), GNUNET_CONFIGURATION_parse(), hosts_directory_scan_callback(), load_file(), load_search_strings(), run(), run(), run(), 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

h	handle to open file
buffer	the data to write
n	number of bytes to write

Returns

number of bytes written on success, GNUNET_SYSERR on error

Definition at line 745 of file disk.c.

{
  if (NULL == h)
  {
    errno = EINVAL;
    return GNUNET_SYSERR;
  }
  return write (h->fd,
                buffer,
                n);
}

References GNUNET_SYSERR, and h.

Referenced by database_shutdown(), decrementBit(), delete_store_message(), do_shutdown(), get_cb(), GNUNET_BIO_flush(), GNUNET_CONFIGURATION_write(), GNUNET_DISK_file_copy(), GNUNET_OS_process_kill(), GNUNET_TIME_absolute_get_monotonic(), helper_write(), incrementBit(), iterate_save_member_session_history_hentries(), iterate_save_messages(), iterate_save_peers(), load_ikm(), process_result_with_request(), publicize_rm(), regex_found_handler(), save_list_messages(), save_list_tunnels(), sighandler_child_death(), sighandler_child_death(), sighandler_child_death(), sighandler_child_death(), sighandler_shutdown(), sign_worker(), start_dump(), stats_iterator(), store_and_free_entries(), 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

h	handle to open file
buffer	the data to write
n	number of bytes to write

Returns

number of bytes written on success, GNUNET_SYSERR on error

Definition at line 761 of file disk.c.

{
  int flags;
  ssize_t ret;
 
  if (NULL == h)
  {
    errno = EINVAL;
    return GNUNET_SYSERR;
  }
  /* set to blocking, write, then set back */
  flags = fcntl (h->fd,
                 F_GETFL);
  if (0 != (flags & O_NONBLOCK))
    (void) fcntl (h->fd,
                  F_SETFL,
                  flags - O_NONBLOCK);
  ret = write (h->fd,
               buffer,
               n);
  if (0 == (flags & O_NONBLOCK))
    (void) fcntl (h->fd,
                  F_SETFL,
                  flags);
  return ret;
}

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

fn	file name
buf	the data to write
buf_size	number of bytes to write from buf
mode	file permissions

Returns

GNUNET_OK on success, GNUNET_NO if a file existed under filename GNUNET_SYSERR on failure

Definition at line 792 of file disk.c.

{
  char *tmpl;
  int fd;
 
  if (GNUNET_OK !=
      GNUNET_DISK_directory_create_for_file (fn))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                              "mkstemp",
                              fn);
    return GNUNET_SYSERR;
  }
  {
    char *dname;
 
    dname = GNUNET_strdup (fn);
    GNUNET_asprintf (&tmpl,
                     "%s/XXXXXX",
                     dirname (dname));
    GNUNET_free (dname);
  }
  fd = mkstemp (tmpl);
  if (-1 == fd)
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                              "mkstemp",
                              tmpl);
    GNUNET_free (tmpl);
    return GNUNET_SYSERR;
  }
 
  if (0 != fchmod (fd,
                   translate_unix_perms (mode)))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                              "chmod",
                              tmpl);
    GNUNET_assert (0 == close (fd));
    if (0 != unlink (tmpl))
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                "unlink",
                                tmpl);
    GNUNET_free (tmpl);
    return GNUNET_SYSERR;
  }
  if (buf_size !=
      write (fd,
             buf,
             buf_size))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                              "write",
                              tmpl);
    GNUNET_assert (0 == close (fd));
    if (0 != unlink (tmpl))
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                "unlink",
                                tmpl);
    GNUNET_free (tmpl);
    return GNUNET_SYSERR;
  }
  GNUNET_assert (0 == close (fd));
 
  if (0 != link (tmpl,
                 fn))
  {
    if (0 != unlink (tmpl))
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                "unlink",
                                tmpl);
    GNUNET_free (tmpl);
    return GNUNET_NO;
  }
  if (0 != unlink (tmpl))
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                              "unlink",
                              tmpl);
  GNUNET_free (tmpl);
  return GNUNET_OK;
 
 
}

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

src	file to copy
dst	destination file name

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1185 of file disk.c.

{
  char *buf;
  uint64_t pos;
  uint64_t size;
  size_t len;
  ssize_t sret;
  struct GNUNET_DISK_FileHandle *in;
  struct GNUNET_DISK_FileHandle *out;
 
  if (GNUNET_OK !=
      GNUNET_DISK_file_size (src,
                             &size,
                             GNUNET_YES,
                             GNUNET_YES))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                              "stat",
                              src);
    return GNUNET_SYSERR;
  }
  pos = 0;
  in =
    GNUNET_DISK_file_open (src,
                           GNUNET_DISK_OPEN_READ,
                           GNUNET_DISK_PERM_NONE);
  if (! in)
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", src);
    return GNUNET_SYSERR;
  }
  out =
    GNUNET_DISK_file_open (dst,
                           GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE
                           | GNUNET_DISK_OPEN_FAILIFEXISTS,
                           GNUNET_DISK_PERM_USER_READ
                           | GNUNET_DISK_PERM_USER_WRITE
                           | GNUNET_DISK_PERM_GROUP_READ
                           | GNUNET_DISK_PERM_GROUP_WRITE);
  if (! out)
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", dst);
    GNUNET_DISK_file_close (in);
    return GNUNET_SYSERR;
  }
  buf = GNUNET_malloc (COPY_BLK_SIZE);
  while (pos < size)
  {
    len = COPY_BLK_SIZE;
    if (len > size - pos)
      len = size - pos;
    sret = GNUNET_DISK_file_read (in, buf, len);
    if ((sret < 0) || (len != (size_t) sret))
      goto FAIL;
    sret = GNUNET_DISK_file_write (out, buf, len);
    if ((sret < 0) || (len != (size_t) sret))
      goto FAIL;
    pos += len;
  }
  GNUNET_free (buf);
  GNUNET_break (GNUNET_OK ==
                GNUNET_DISK_file_close (in));
  GNUNET_break (GNUNET_OK ==
                GNUNET_DISK_file_close (out));
  return GNUNET_OK;
FAIL:
  GNUNET_free (buf);
  GNUNET_break (GNUNET_OK ==
                GNUNET_DISK_file_close (in));
  GNUNET_break (GNUNET_OK ==
                GNUNET_DISK_file_close (out));
  return GNUNET_SYSERR;
}

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

Here is the call graph for this function:

GNUNET_DISK_directory_scan()

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

Scan a directory for files.

Parameters

dir_name	the name of the directory
callback	the method to call for each file
callback_cls	closure for callback

Returns

the number of files found, -1 on error

Definition at line 881 of file disk.c.

{
  DIR *dinfo;
  struct dirent *finfo;
  int count = 0;
  enum GNUNET_GenericReturnValue ret;
  char *name;
  char *dname;
  unsigned int name_len;
  unsigned int n_size;
 
  GNUNET_assert (NULL != dir_name);
  dname = GNUNET_STRINGS_filename_expand (dir_name);
  if (NULL == dname)
    return GNUNET_SYSERR;
  while ( (strlen (dname) > 0) &&
          (dname[strlen (dname) - 1] == DIR_SEPARATOR) )
    dname[strlen (dname) - 1] = '\0';
  dinfo = opendir (dname);
  if (NULL == dinfo)
  {
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
                       "opendir",
                       dname);
    GNUNET_free (dname);
    return GNUNET_SYSERR;
  }
  name_len = 256;
  n_size = strlen (dname) + name_len + strlen (DIR_SEPARATOR_STR) + 1;
  name = GNUNET_malloc (n_size);
  while (NULL != (finfo = readdir (dinfo)))
  {
    if ((0 == strcmp (finfo->d_name, ".")) ||
        (0 == strcmp (finfo->d_name, "..")))
      continue;
    if (NULL != callback)
    {
      if (name_len < strlen (finfo->d_name))
      {
        GNUNET_free (name);
        name_len = strlen (finfo->d_name);
        n_size = strlen (dname) + name_len + strlen (DIR_SEPARATOR_STR) + 1;
        name = GNUNET_malloc (n_size);
      }
      /* dname can end in "/" only if dname == "/";
       * if dname does not end in "/", we need to add
       * a "/" (otherwise, we must not!) */
      GNUNET_snprintf (name,
                       n_size,
                       "%s%s%s",
                       dname,
                       (0 == strcmp (dname,
                                     DIR_SEPARATOR_STR))
                       ? ""
                       : DIR_SEPARATOR_STR,
                       finfo->d_name);
      ret = callback (callback_cls,
                      name);
      if (GNUNET_OK != ret)
      {
        closedir (dinfo);
        GNUNET_free (name);
        GNUNET_free (dname);
        if (GNUNET_NO == ret)
          return count;
        return GNUNET_SYSERR;
      }
    }
    count++;
  }
  closedir (dinfo);
  GNUNET_free (name);
  GNUNET_free (dname);
  return count;
}

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

Referenced by deserialization_master(), deserialize_download(), deserialize_search(), determine_id(), discover_testbed_nodes(), get_size_rec(), GNUNET_CONFIGURATION_load_from(), GNUNET_DISK_directory_remove(), GNUNET_DISK_glob(), GNUNET_PLUGIN_load_all(), iter_testbed_path(), load_member(), load_member_store(), load_operation_store(), preprocess_file(), run(), run(), run(), 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_pattern	the glob pattern to search for
callback	the method to call for each file
callback_cls	closure for callback

Returns

the number of files found, -1 on error

Definition at line 1063 of file disk.c.

{
  char *mypat = GNUNET_strdup (glob_pattern);
  char *sep;
  int ret;
 
  if ( (NULL != strrchr (glob_pattern, '+')) ||
       (NULL != strrchr (glob_pattern, '[')) ||
       (NULL != strrchr (glob_pattern, '~')) )
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "unsupported glob pattern: '%s'\n",
         glob_pattern);
    GNUNET_free (mypat);
    return -1;
  }
 
  sep = strrchr (mypat, DIR_SEPARATOR);
  if (NULL == sep)
  {
    GNUNET_free (mypat);
    return -1;
  }
 
  *sep = '\0';
 
  if (NULL != strchr (mypat, '*'))
  {
    GNUNET_free (mypat);
    GNUNET_break (0);
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "glob pattern may only contain '*' in the final path component\n");
    return -1;
  }
 
  {
    struct GlobClosure gc = {
      .glob = sep + 1,
      .cb = callback,
      .cls = callback_cls,
      .nres = 0,
    };
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "scanning directory '%s' for glob matches on '%s'\n",
         mypat,
         gc.glob);
    ret = GNUNET_DISK_directory_scan (mypat,
                                      glob_cb,
                                      &gc
                                      );
    GNUNET_free (mypat);
    return (ret < 0) ? ret : gc.nres;
  }
}

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 do_discover_peers(), and 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

filename

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

{
  char *rdir;
  size_t len;
  int eno;
  enum GNUNET_GenericReturnValue res;
 
  rdir = GNUNET_STRINGS_filename_expand (filename);
  if (NULL == rdir)
  {
    errno = EINVAL;
    return GNUNET_SYSERR;
  }
  if (0 == access (rdir, W_OK))
  {
    GNUNET_free (rdir);
    return GNUNET_OK;
  }
  len = strlen (rdir);
  while ((len > 0) && (rdir[len] != DIR_SEPARATOR))
    len--;
  rdir[len] = '\0';
  /* The empty path is invalid and in this case refers to / */
  if (0 == len)
  {
    GNUNET_free (rdir);
    rdir = GNUNET_strdup ("/");
  }
  res = GNUNET_DISK_directory_create (rdir);
  if ( (GNUNET_OK == res) &&
       (0 != access (rdir, W_OK)) )
    res = GNUNET_NO;
  eno = errno;
  GNUNET_free (rdir);
  errno = eno;
  return res;
}

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

Referenced by database_connect(), database_setup(), database_setup(), database_setup(), database_setup(), database_setup(), get_server_addresses(), get_server_addresses(), GNUNET_CONFIGURATION_write(), GNUNET_DISK_file_open(), GNUNET_DISK_fn_write(), GNUNET_FS_download_sync_(), load_ikm(), make_serialization_file_name(), make_serialization_file_name_in_dir(), run(), 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

fil	filename to test
is_readable	GNUNET_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 466 of file disk.c.

{
  struct stat filestat;
  int ret;
 
  ret = stat (fil, &filestat);
  if (ret != 0)
  {
    if (errno != ENOENT)
      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
                         "stat",
                         fil);
    return GNUNET_SYSERR;
  }
  if (! S_ISDIR (filestat.st_mode))
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         "A file already exits with the same name %s\n",
         fil);
    return GNUNET_NO;
  }
  if (GNUNET_YES == is_readable)
    ret = access (fil,
                  R_OK | X_OK);
  else
    ret = access (fil,
                  X_OK);
  if (ret < 0)
  {
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
                       "access",
                       fil);
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

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(), move_message_store(), PABC_load_public_parameters(), remove_srv_room(), run(), 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

filename

the file to remove

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1140 of file disk.c.

{
  struct stat istat;
 
  if (NULL == filename)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (0 != lstat (filename, &istat))
    return GNUNET_NO; /* file may not exist... */
  (void) chmod (filename,
                S_IWUSR | S_IRUSR | S_IXUSR);
  if (0 == unlink (filename))
    return GNUNET_OK;
  if ( (errno != EISDIR) &&
       /* EISDIR is not sufficient in all cases, e.g.
        * sticky /tmp directory may result in EPERM on BSD.
        * So we also explicitly check "isDirectory" */
       (GNUNET_YES !=
        GNUNET_DISK_directory_test (filename,
                                    GNUNET_YES)) )
  {
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
                       "rmdir",
                       filename);
    return GNUNET_SYSERR;
  }
  if (GNUNET_SYSERR ==
      GNUNET_DISK_directory_scan (filename,
                                  &remove_helper,
                                  NULL))
    return GNUNET_SYSERR;
  if (0 != rmdir (filename))
  {
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
                       "rmdir",
                       filename);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DISK_purge_cfg_dir()

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

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

Parameters

pd	project data to use to determine paths
cfg_filename	configuration file to parse
option	option with the dir name to purge

Definition at line 1769 of file disk.c.

{
  GNUNET_break (GNUNET_OK ==
                GNUNET_CONFIGURATION_parse_and_run (pd,
                                                    cfg_filename,
                                                    &purge_cfg_dir,
                                                    (void *) option));
}

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

dir	the directory to create

Returns

GNUNET_SYSERR on failure, GNUNET_OK otherwise

Definition at line 573 of file disk.c.

{
  char *rdir;
  unsigned int len;
  unsigned int pos;
  unsigned int pos2;
  int ret = GNUNET_OK;
 
  rdir = GNUNET_STRINGS_filename_expand (dir);
  if (rdir == NULL)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
 
  len = strlen (rdir);
 
  pos = 1; /* skip heading '/' */
 
  /* Check which low level directories already exist */
  pos2 = len;
  rdir[len] = DIR_SEPARATOR;
  while (pos <= pos2)
  {
    if (DIR_SEPARATOR == rdir[pos2])
    {
      rdir[pos2] = '\0';
      ret = GNUNET_DISK_directory_test (rdir,
                                        GNUNET_NO);
      if (GNUNET_NO == ret)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Creating directory `%s' failed\n",
                    rdir);
        GNUNET_free (rdir);
        return GNUNET_SYSERR;
      }
      rdir[pos2] = DIR_SEPARATOR;
      if (GNUNET_YES == ret)
      {
        pos2++;
        break;
      }
    }
    pos2--;
  }
  rdir[len] = '\0';
  if (pos < pos2)
    pos = pos2;
  /* Start creating directories */
  while (pos <= len)
  {
    if ( (rdir[pos] == DIR_SEPARATOR) ||
         (pos == len) )
    {
      rdir[pos] = '\0';
      ret = GNUNET_DISK_directory_test (rdir,
                                        GNUNET_NO);
      if (GNUNET_NO == ret)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Creating directory `%s' failed\n",
                    rdir);
        GNUNET_free (rdir);
        return GNUNET_SYSERR;
      }
      if (GNUNET_SYSERR == ret)
      {
        ret = mkdir (rdir,
                     S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH
                     | S_IXOTH);    /* 755 */
 
        if ((ret != 0) && (errno != EEXIST))
        {
          LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR,
                             "mkdir",
                             rdir);
          GNUNET_free (rdir);
          return GNUNET_SYSERR;
        }
      }
      rdir[pos] = DIR_SEPARATOR;
    }
    pos++;
  }
  GNUNET_free (rdir);
  return GNUNET_OK;
}

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

fn	the filename to canonicalize

Definition at line 1262 of file disk.c.

{
  char *idx;
  char c;
 
  for (idx = fn; *idx; idx++)
  {
    c = *idx;
 
    if ((c == '/') || (c == '\\') || (c == ':') || (c == '*') || (c == '?') ||
        (c ==
         '"')
        ||
        (c == '<') || (c == '>') || (c == '|') )
    {
      *idx = '_';
    }
  }
}

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

filename	file to change
user	new owner of the file

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1284 of file disk.c.

{
  struct passwd *pws;
 
  pws = getpwnam (user);
  if (NULL == pws)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Cannot obtain information about user `%s': %s\n"),
         user,
         strerror (errno));
    return GNUNET_SYSERR;
  }
  if (0 != chown (filename, pws->pw_uid, pws->pw_gid))
  {
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "chown", filename);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

h	open file handle
m	handle to the new mapping (will be set)
access	access specification, GNUNET_DISK_MAP_TYPE_xxx
len	size of the mapping

Returns

pointer to the mapped memory region, NULL on failure

Definition at line 1459 of file disk.c.

{
  int prot;
 
  if (NULL == h)
  {
    errno = EINVAL;
    return NULL;
  }
  prot = 0;
  if (access & GNUNET_DISK_MAP_TYPE_READ)
    prot = PROT_READ;
  if (access & GNUNET_DISK_MAP_TYPE_WRITE)
    prot |= PROT_WRITE;
  *m = GNUNET_new (struct GNUNET_DISK_MapHandle);
  (*m)->addr = mmap (NULL, len, prot, MAP_SHARED, h->fd, 0);
  GNUNET_assert (NULL != (*m)->addr);
  if (MAP_FAILED == (*m)->addr)
  {
    GNUNET_free (*m);
    return NULL;
  }
  (*m)->len = len;
  return (*m)->addr;
}

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

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

Here is the caller graph for this function:

GNUNET_DISK_file_unmap()

enum GNUNET_GenericReturnValue GNUNET_DISK_file_unmap

(

struct GNUNET_DISK_MapHandle *

h

)

Unmap a file.

Parameters

h	mapping handle

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1490 of file disk.c.

{
  enum GNUNET_GenericReturnValue ret;
 
  if (NULL == h)
  {
    errno = EINVAL;
    return GNUNET_SYSERR;
  }
  ret = munmap (h->addr, h->len) != -1 ? GNUNET_OK : GNUNET_SYSERR;
  GNUNET_free (h);
  return ret;
}

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

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

Here is the caller graph for this function:

GNUNET_DISK_file_sync()

enum GNUNET_GenericReturnValue GNUNET_DISK_file_sync

(

const struct GNUNET_DISK_FileHandle *

h

)

Write file changes to disk.

Parameters

h	handle to an open file

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1506 of file disk.c.

{
  if (h == NULL)
  {
    errno = EINVAL;
    return GNUNET_SYSERR;
  }
 
#if ! defined(__linux__) || ! defined(GNU)
  return fsync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
#else
  return fdatasync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
#endif
}

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: