GNUnet  0.10.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...
 

Functions

int GNUNET_DISK_handle_invalid (const struct GNUNET_DISK_FileHandle *h)
 Checks whether a handle is invalid. More...
 
int 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...
 
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...
 
int 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...
 
int 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...
 
int 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 (int blocking_read, int blocking_write, int inherit_read, int inherit_write)
 Creates an interprocess channel. More...
 
struct GNUNET_DISK_PipeHandleGNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
 Creates a pipe object from a couple of file descriptors. More...
 
int GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p)
 Closes an interprocess channel. More...
 
int 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...
 
int 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...
 
ssize_t GNUNET_DISK_fn_write (const char *fn, const void *buffer, size_t n, enum GNUNET_DISK_AccessPermissions mode)
 Write a buffer to a file. More...
 
int 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_directory_create_for_file (const char *filename)
 Create the directory structure for storing a file. More...
 
int GNUNET_DISK_directory_test (const char *fil, int is_readable)
 Test if fil is a directory and listable. More...
 
int 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...
 
int GNUNET_DISK_directory_create (const char *dir)
 Implementation of "mkdir -p". More...
 
int GNUNET_DISK_file_lock (struct GNUNET_DISK_FileHandle *fh, off_t lock_start, off_t lock_end, int excl)
 Lock a part of a file. More...
 
int GNUNET_DISK_file_unlock (struct GNUNET_DISK_FileHandle *fh, off_t unlock_start, off_t unlock_end)
 Unlock a part of a file. More...
 
void GNUNET_DISK_filename_canonicalize (char *fn)
 Removes special characters as ':' from a filename. More...
 
int 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...
 
int GNUNET_DISK_file_unmap (struct GNUNET_DISK_MapHandle *h)
 Unmap a file. More...
 
int 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.

41  {
46 
51 
56 };
Handle represents a file.
Handle represents a pipe.
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 89 of file gnunet_disk_lib.h.

89  {
94 
99 
104 
109 
114 
119 
124 };
Open the file for reading.
Create file if it doesn't exist.
Append to the file.
Truncate file if it exists.
Open the file for writing.
Open the file for both reading and writing.
Fail if file already exists.

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

129  {
134 
139 
144 };
Read-write memory map.
Read-only memory map.
Write-able 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 150 of file gnunet_disk_lib.h.

150  {
155 
160 
165 
170 
175 
180 
185 
190 
195 
200 };
Everybody can execute.
Nobody is allowed to do anything to the file.
Everybody can write.
Everybody can read.

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

207  {
212 
217 
222 };
Seek a relative position (from the current offset).
Seek an absolute position from the end of the file.
Seek an absolute position (from the start 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 228 of file gnunet_disk_lib.h.

228  {
233 
238 };
The writing-end of a pipe.
The reading-end of a pipe.

Function Documentation

◆ GNUNET_DISK_handle_invalid()

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

References GNUNET_DISK_FileHandle::fd, GNUNET_NO, and GNUNET_YES.

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

191 {
192  return ((!h) || (h->fd == -1)) ? GNUNET_YES : GNUNET_NO;
193 }
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_YES
Definition: gnunet_common.h:77
int fd
File handle on Unix-like systems.
Here is the caller graph for this function:

◆ GNUNET_DISK_file_test()

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

References GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_NO, GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, GNUNET_YES, LOG_STRERROR_FILE, and ret.

Referenced by create_download_context(), create_unique_cfgs(), database_setup(), ego_callback(), gen_topo_from_file(), get_path_from_PATH(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_CRYPTO_ecdsa_key_create_from_file(), GNUNET_CRYPTO_eddsa_key_create_from_file(), GNUNET_DISK_file_open(), GNUNET_FRIENDS_parse(), GNUNET_FRIENDS_write_start(), GNUNET_FS_download_start_task_(), GNUNET_HOSTLIST_client_start(), GNUNET_PROGRAM_run2(), GNUNET_SERVICE_run_(), GNUNET_TESTBED_hosts_load_from_file(), GNUNET_TRANSPORT_TESTING_start_peer(), hostkeys_load(), hosts_directory_scan_callback(), LEGACY_SERVICE_run(), load_hostlist_file(), load_search_strings(), policy_filename_cb(), print_key(), read_host_file(), read_index_list(), read_update_information_graph(), restore_valid_peers(), and run().

542 {
543  struct stat filestat;
544  int ret;
545  char *rdir;
546 
547  rdir = GNUNET_STRINGS_filename_expand(fil);
548  if (rdir == NULL)
549  return GNUNET_SYSERR;
550 
551  ret = stat(rdir, &filestat);
552  if (ret != 0)
553  {
554  if (errno != ENOENT)
555  {
557  GNUNET_free(rdir);
558  return GNUNET_SYSERR;
559  }
560  GNUNET_free(rdir);
561  return GNUNET_NO;
562  }
563  if (!S_ISREG(filestat.st_mode))
564  {
565  GNUNET_free(rdir);
566  return GNUNET_NO;
567  }
568  if (access(rdir, F_OK) < 0)
569  {
571  GNUNET_free(rdir);
572  return GNUNET_SYSERR;
573  }
574  GNUNET_free(rdir);
575  return GNUNET_YES;
576 }
#define GNUNET_NO
Definition: gnunet_common.h:78
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:602
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: disk.c:36
#define GNUNET_YES
Definition: gnunet_common.h:77
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_DISK_file_backup()

void GNUNET_DISK_file_backup ( const char *  fil)

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

Parameters
filname of the file to back up

Definition at line 433 of file disk.c.

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

Referenced by GNUNET_FRIENDS_write_start().

434 {
435  size_t slen;
436  char *target;
437  unsigned int num;
438 
439  slen = strlen(fil) + 20;
440  target = GNUNET_malloc(slen);
441  num = 0;
442  do
443  {
444  GNUNET_snprintf(target, slen, "%s.%u~", fil, num++);
445  }
446  while (0 == access(target, F_OK));
447  if (0 != rename(fil, target))
449  GNUNET_free(target);
450 }
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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
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 223 of file disk.c.

References GNUNET_DISK_FileHandle::fd, GNUNET_SYSERR, and t.

Referenced by decrementBit(), fh_reader(), GNUNET_FS_data_reader_file_(), GNUNET_FS_handle_on_demand_block(), incrementBit(), make_empty_file(), process_result_with_request(), try_top_down_reconstruction(), and unindex_reader().

226 {
227  if (h == NULL)
228  {
229  errno = EINVAL;
230  return GNUNET_SYSERR;
231  }
232 
233  static int t[] = { SEEK_SET, SEEK_CUR, SEEK_END };
234 
235  return lseek(h->fd, offset, t[whence]);
236 }
static struct GNUNET_SCHEDULER_Task * t
Main task.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int fd
File handle on Unix-like systems.
Here is the caller graph for this function:

◆ GNUNET_DISK_file_size()

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

References getSizeRec(), GNUNET_assert, GetFileSizeData::include_sym_links, ret, GetFileSizeData::single_file_mode, and GetFileSizeData::total.

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

258 {
259  struct GetFileSizeData gfsd;
260  int ret;
261 
262  GNUNET_assert(size != NULL);
263  gfsd.total = 0;
264  gfsd.include_sym_links = include_symbolic_links;
265  gfsd.single_file_mode = single_file_mode;
266  ret = getSizeRec(&gfsd, filename);
267  *size = gfsd.total;
268  return ret;
269 }
int single_file_mode
GNUNET_YES if mode is file-only (return total == -1 for directories).
Definition: disk.c:95
Closure for the recursion to determine the file size of a directory.
Definition: disk.c:81
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ret
Final status code.
Definition: gnunet-arm.c:89
static char * filename
static int getSizeRec(void *cls, const char *fn)
Iterate over all files in the given directory and accumulate their size.
Definition: disk.c:144
static unsigned int size
Size of the "table".
Definition: peer.c:66
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_DISK_file_get_identifiers()

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

References GNUNET_OK, and GNUNET_SYSERR.

Referenced by handle_client_index_start(), and hash_for_index_cb().

291 {
292 #if HAVE_STAT
293  {
294  struct stat sbuf;
295 
296  if (0 != stat(filename, &sbuf))
297  {
298  return GNUNET_SYSERR;
299  }
300  *ino = (uint64_t)sbuf.st_ino;
301  }
302 #else
303  *ino = 0;
304 #endif
305 #if HAVE_STATVFS
306  {
307  struct statvfs fbuf;
308 
309  if (0 != statvfs(filename, &fbuf))
310  {
311  return GNUNET_SYSERR;
312  }
313  *dev = (uint64_t)fbuf.f_fsid;
314  }
315 #elif HAVE_STATFS
316  {
317  struct statfs fbuf;
318 
319  if (0 != statfs(filename, &fbuf))
320  {
321  return GNUNET_SYSERR;
322  }
323  *dev =
324  ((uint64_t)fbuf.f_fsid.val[0]) << 32 || ((uint64_t)fbuf.f_fsid.val[1]);
325  }
326 #else
327  *dev = 0;
328 #endif
329  return GNUNET_OK;
330 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static char * filename
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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 465 of file disk.c.

References GNUNET_DISK_PipeHandle::fd, fn, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, LOG_STRERROR_FILE, and mktemp_name().

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

466 {
467  int fd;
468  char *fn;
469  mode_t omask;
470 
471  omask = umask(S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
472  fn = mktemp_name(t);
473  if (-1 == (fd = mkstemp(fn)))
474  {
476  GNUNET_free(fn);
477  umask(omask);
478  return NULL;
479  }
480  umask(omask);
481  if (0 != close(fd))
483  return fn;
484 }
static struct GNUNET_SCHEDULER_Task * t
Main task.
static char * fn
Filename of the unique file.
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: disk.c:36
static char * mktemp_name(const char *t)
Create the name for a temporary file or directory from a template.
Definition: disk.c:340
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_DISK_mkdtemp()

char* GNUNET_DISK_mkdtemp ( const char *  t)

Create an (empty) temporary directory on disk.

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

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

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

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

Referenced by access_handler_callback(), and GNUNET_TESTING_system_create_with_portrange().

407 {
408  char *fn;
409  mode_t omask;
410 
411  omask = umask(S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
412  fn = mktemp_name(t);
413  if (fn != mkdtemp(fn))
414  {
416  GNUNET_free(fn);
417  umask(omask);
418  return NULL;
419  }
420  umask(omask);
421  return fn;
422 }
static struct GNUNET_SCHEDULER_Task * t
Main task.
static char * fn
Filename of the unique file.
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: disk.c:36
static char * mktemp_name(const char *t)
Create the name for a temporary file or directory from a template.
Definition: disk.c:340
#define GNUNET_free(ptr)
Wrapper around free.
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 1262 of file disk.c.

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

Referenced by create_hostkeys(), database_setup(), database_shutdown(), full_recursive_download(), get_file_handle(), GNUNET_ATS_solver_logging_write_to_disk(), GNUNET_ATS_TEST_logging_write_to_file(), GNUNET_BIO_read_open(), GNUNET_BIO_write_open(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_CRYPTO_ecdsa_key_create_from_file(), GNUNET_CRYPTO_eddsa_key_create_from_file(), GNUNET_CRYPTO_hash_file(), GNUNET_DISK_file_copy(), GNUNET_DISK_fn_read(), GNUNET_DISK_fn_write(), 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(), GNUNET_TIME_absolute_get_monotonic(), hostkeys_load(), iface_proc(), load_etc_hosts(), load_keys(), lookup_dns_servers(), main(), print_key(), process_result_with_request(), publish_fs_connect_complete_cb(), REGEX_TEST_read_from_file(), restore_valid_peers(), run(), server_log(), start_dump(), start_insert(), store_valid_peers(), to_file_raw(), tofile_(), try_match_block(), write_benchmark_data(), write_bw_gnuplot_script(), write_rtt_gnuplot_script(), and write_throughput_gnuplot_script().

1265 {
1266  char *expfn;
1267  struct GNUNET_DISK_FileHandle *ret;
1268 
1269  int oflags;
1270  int mode;
1271  int fd;
1272 
1274  if (NULL == expfn)
1275  return NULL;
1276 
1277  mode = 0;
1279  oflags = O_RDWR; /* note: O_RDWR is NOT always O_RDONLY | O_WRONLY */
1280  else if (flags & GNUNET_DISK_OPEN_READ)
1281  oflags = O_RDONLY;
1282  else if (flags & GNUNET_DISK_OPEN_WRITE)
1283  oflags = O_WRONLY;
1284  else
1285  {
1286  GNUNET_break(0);
1287  GNUNET_free(expfn);
1288  return NULL;
1289  }
1290  if (flags & GNUNET_DISK_OPEN_FAILIFEXISTS)
1291  oflags |= (O_CREAT | O_EXCL);
1292  if (flags & GNUNET_DISK_OPEN_TRUNCATE)
1293  oflags |= O_TRUNC;
1294  if (flags & GNUNET_DISK_OPEN_APPEND)
1295  oflags |= O_APPEND;
1297  {
1298  if (flags & GNUNET_DISK_OPEN_CREATE)
1299  {
1301  oflags |= O_CREAT;
1302  mode = translate_unix_perms(perm);
1303  }
1304  }
1305 
1306  fd = open(expfn,
1307  oflags
1308 #if O_CLOEXEC
1309  | O_CLOEXEC
1310 #endif
1311  | O_LARGEFILE,
1312  mode);
1313  if (fd == -1)
1314  {
1315  if (0 == (flags & GNUNET_DISK_OPEN_FAILIFEXISTS))
1317  else
1319  GNUNET_free(expfn);
1320  return NULL;
1321  }
1322 
1323  ret = GNUNET_new(struct GNUNET_DISK_FileHandle);
1324 
1325  ret->fd = fd;
1326 
1327  GNUNET_free(expfn);
1328  return ret;
1329 }
int 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:541
Open the file for reading.
Create file if it doesn&#39;t exist.
int GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:681
Append to the file.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static int ret
Final status code.
Definition: gnunet-arm.c:89
static int translate_unix_perms(enum GNUNET_DISK_AccessPermissions perm)
Translate GNUnet-internal permission bitmap to UNIX file access permission bitmap.
Definition: disk.c:107
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define O_LARGEFILE
Definition: platform.h:219
static char * fn
Filename of the unique file.
Truncate file if it exists.
Open the file for writing.
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:602
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: disk.c:36
Open the file for both reading and writing.
int fd
File handle on Unix-like systems.
Fail if file already exists.
Handle used to access files (and pipes).
static enum @11 mode
Should we do a PUT (mode = 0) or GET (mode = 1);.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_DISK_file_handle_size()

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

References GNUNET_DISK_FileHandle::fd, GNUNET_OK, and GNUNET_SYSERR.

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

204 {
205  struct stat sbuf;
206 
207  if (0 != fstat(fh->fd, &sbuf))
208  return GNUNET_SYSERR;
209  *size = sbuf.st_size;
210  return GNUNET_OK;
211 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:66
int fd
File handle on Unix-like systems.
Here is the caller graph for this function:

◆ GNUNET_DISK_pipe()

struct GNUNET_DISK_PipeHandle* GNUNET_DISK_pipe ( int  blocking_read,
int  blocking_write,
int  inherit_read,
int  inherit_write 
)

Creates an interprocess channel.

Parameters
blocking_readcreates an asynchronous pipe for reading if set to GNUNET_NO
blocking_writecreates an asynchronous pipe for writing if set to GNUNET_NO
inherit_read1 to make read handle inheritable, 0 otherwise (NT only)
inherit_write1 to make write handle inheritable, 0 otherwise (NT only)
Returns
handle to the new pipe, NULL on error
Parameters
blocking_readcreates an asynchronous pipe for reading if set to GNUNET_NO
blocking_writecreates an asynchronous pipe for writing if set to GNUNET_NO
inherit_readinherit the parent processes stdin (only for windows)
inherit_writeinherit the parent processes stdout (only for windows)
Returns
handle to the new pipe, NULL on error

Definition at line 1518 of file disk.c.

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

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

1522 {
1523  int fd[2];
1524  int ret;
1525  int eno;
1526 
1527  (void)inherit_read;
1528  (void)inherit_write;
1529  ret = pipe(fd);
1530  if (ret == -1)
1531  {
1532  eno = errno;
1534  errno = eno;
1535  return NULL;
1536  }
1537  return GNUNET_DISK_pipe_from_fd(blocking_read, blocking_write, fd);
1538 }
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define LOG_STRERROR(kind, syscall)
Definition: disk.c:33
struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe_from_fd(int blocking_read, int blocking_write, int fd[2])
Creates a pipe object from a couple of file descriptors.
Definition: disk.c:1552
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 ( int  blocking_read,
int  blocking_write,
int  fd[2] 
)

Creates a pipe object from a couple of file descriptors.

Useful for wrapping existing pipe FDs.

Parameters
blocking_readcreates an asynchronous pipe for reading if set to GNUNET_NO
blocking_writecreates an asynchronous pipe for writing if set to GNUNET_NO
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

Useful for wrapping existing pipe FDs.

Parameters
blocking_readcreates an asynchronous pipe for reading if set to GNUNET_NO
blocking_writecreates an asynchronous pipe for writing if set to GNUNET_NO
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 1552 of file disk.c.

References GNUNET_DISK_FileHandle::fd, GNUNET_DISK_PipeHandle::fd, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_free_non_null, GNUNET_new, LOG_STRERROR, p, and ret.

Referenced by GNUNET_DISK_pipe().

1553 {
1554  struct GNUNET_DISK_PipeHandle *p;
1555 
1556  p = GNUNET_new(struct GNUNET_DISK_PipeHandle);
1557 
1558  int ret;
1559  int flags;
1560  int eno = 0; /* make gcc happy */
1561 
1562  ret = 0;
1563  if (fd[0] >= 0)
1564  {
1565  p->fd[0] = GNUNET_new(struct GNUNET_DISK_FileHandle);
1566  p->fd[0]->fd = fd[0];
1567  if (!blocking_read)
1568  {
1569  flags = fcntl(fd[0], F_GETFL);
1570  flags |= O_NONBLOCK;
1571  if (0 > fcntl(fd[0], F_SETFL, flags))
1572  {
1573  ret = -1;
1574  eno = errno;
1575  }
1576  }
1577  flags = fcntl(fd[0], F_GETFD);
1578  flags |= FD_CLOEXEC;
1579  if (0 > fcntl(fd[0], F_SETFD, flags))
1580  {
1581  ret = -1;
1582  eno = errno;
1583  }
1584  }
1585 
1586  if (fd[1] >= 0)
1587  {
1588  p->fd[1] = GNUNET_new(struct GNUNET_DISK_FileHandle);
1589  p->fd[1]->fd = fd[1];
1590  if (!blocking_write)
1591  {
1592  flags = fcntl(fd[1], F_GETFL);
1593  flags |= O_NONBLOCK;
1594  if (0 > fcntl(fd[1], F_SETFL, flags))
1595  {
1596  ret = -1;
1597  eno = errno;
1598  }
1599  }
1600  flags = fcntl(fd[1], F_GETFD);
1601  flags |= FD_CLOEXEC;
1602  if (0 > fcntl(fd[1], F_SETFD, flags))
1603  {
1604  ret = -1;
1605  eno = errno;
1606  }
1607  }
1608  if (ret == -1)
1609  {
1610  errno = eno;
1612  if (p->fd[0]->fd >= 0)
1613  GNUNET_break(0 == close(p->fd[0]->fd));
1614  if (p->fd[1]->fd >= 0)
1615  GNUNET_break(0 == close(p->fd[1]->fd));
1616  GNUNET_free_non_null(p->fd[0]);
1617  GNUNET_free_non_null(p->fd[1]);
1618  GNUNET_free(p);
1619  errno = eno;
1620  return NULL;
1621  }
1622 
1623  return p;
1624 }
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define LOG_STRERROR(kind, syscall)
Definition: disk.c:33
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_DISK_FileHandle * fd[2]
File descriptors for the pipe.
Definition: disk.c:73
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
int fd
File handle on Unix-like systems.
Handle used to access files (and pipes).
Handle used to manage a pipe.
Definition: disk.c:68
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function:

◆ GNUNET_DISK_pipe_close()

int GNUNET_DISK_pipe_close ( struct GNUNET_DISK_PipeHandle p)

Closes an interprocess channel.

Parameters
ppipe
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise
Parameters
ppipe to close
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1706 of file disk.c.

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

Referenced by GN_stop_gnunet_nat_server_(), 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(), and start_process().

1707 {
1708  int ret = GNUNET_OK;
1709 
1710  int read_end_close;
1711  int write_end_close;
1712  int read_end_close_errno;
1713  int write_end_close_errno;
1714 
1716  read_end_close_errno = errno;
1718  write_end_close_errno = errno;
1719  GNUNET_free(p);
1720 
1721  if (GNUNET_OK != read_end_close)
1722  {
1723  errno = read_end_close_errno;
1724  ret = read_end_close;
1725  }
1726  else if (GNUNET_OK != write_end_close)
1727  {
1728  errno = write_end_close_errno;
1729  ret = write_end_close;
1730  }
1731 
1732  return ret;
1733 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
The writing-end of a pipe.
The reading-end of a pipe.
int GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd end)
Closes an interprocess channel.
Definition: disk.c:1635
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_DISK_pipe_close_end()

int 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

Closes one half of an interprocess channel.

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

Definition at line 1635 of file disk.c.

References GNUNET_DISK_PipeHandle::fd, GNUNET_DISK_file_close(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, GNUNET_OK, and ret.

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

1637 {
1638  int ret = GNUNET_OK;
1639 
1641  {
1642  if (p->fd[0])
1643  {
1644  ret = GNUNET_DISK_file_close(p->fd[0]);
1645  p->fd[0] = NULL;
1646  }
1647  }
1648  else if (end == GNUNET_DISK_PIPE_END_WRITE)
1649  {
1650  if (p->fd[1])
1651  {
1652  ret = GNUNET_DISK_file_close(p->fd[1]);
1653  p->fd[1] = NULL;
1654  }
1655  }
1656 
1657  return ret;
1658 }
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
struct GNUNET_DISK_FileHandle * fd[2]
File descriptors for the pipe.
Definition: disk.c:73
The writing-end of a pipe.
The reading-end of a pipe.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_DISK_pipe_detach_end()

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

Detaches one of the ends from the pipe.

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

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

Definition at line 1673 of file disk.c.

References GNUNET_DISK_PipeHandle::fd, GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, and ret.

Referenced by start_process().

1675 {
1676  struct GNUNET_DISK_FileHandle *ret = NULL;
1677 
1679  {
1680  if (p->fd[0])
1681  {
1682  ret = p->fd[0];
1683  p->fd[0] = NULL;
1684  }
1685  }
1686  else if (end == GNUNET_DISK_PIPE_END_WRITE)
1687  {
1688  if (p->fd[1])
1689  {
1690  ret = p->fd[1];
1691  p->fd[1] = NULL;
1692  }
1693  }
1694 
1695  return ret;
1696 }
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
static int ret
Final status code.
Definition: gnunet-arm.c:89
struct GNUNET_DISK_FileHandle * fd[2]
File descriptors for the pipe.
Definition: disk.c:73
The writing-end of a pipe.
The reading-end of a pipe.
Handle used to access files (and pipes).
Here is the caller graph for this function:

◆ GNUNET_DISK_file_close()

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

References GNUNET_DISK_FileHandle::fd, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_OK, GNUNET_SYSERR, LOG_STRERROR, and ret.

Referenced by check_completed(), cleanup(), close_files_iter(), create_hostkeys(), database_setup(), database_shutdown(), do_shutdown(), file_hash_finish(), full_recursive_download(), get_cb(), GNUNET_ATS_solver_logging_write_to_disk(), GNUNET_ATS_TEST_logging_write_to_file(), GNUNET_BIO_flush(), GNUNET_BIO_read_close(), GNUNET_BIO_write_close(), GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_CRYPTO_ecdsa_key_create_from_file(), GNUNET_CRYPTO_eddsa_key_create_from_file(), GNUNET_CRYPTO_hash_file_cancel(), GNUNET_DISK_file_copy(), GNUNET_DISK_fn_read(), GNUNET_DISK_fn_write(), GNUNET_DISK_pipe_close_end(), 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(), GNUNET_TIME_absolute_get_monotonic(), hostkeys_load(), load_etc_hosts(), lookup_dns_servers(), main(), 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(), server_log(), shutdown_pch(), shutdown_task(), start_process(), stop_broadcast(), store_valid_peers(), to_file_raw(), tofile_(), try_match_block(), unindex_finish(), unload_keys(), write_benchmark_data(), write_bw_gnuplot_script(), write_rtt_gnuplot_script(), and write_throughput_gnuplot_script().

1340 {
1341  int ret;
1342 
1343  if (h == NULL)
1344  {
1345  errno = EINVAL;
1346  return GNUNET_SYSERR;
1347  }
1348 
1349  ret = GNUNET_OK;
1350 
1351  if (close(h->fd) != 0)
1352  {
1354  ret = GNUNET_SYSERR;
1355  }
1356 
1357  GNUNET_free(h);
1358  return ret;
1359 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define LOG_STRERROR(kind, syscall)
Definition: disk.c:33
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int fd
File handle on Unix-like systems.
#define GNUNET_free(ptr)
Wrapper around free.

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

References GNUNET_DISK_PipeHandle::fd, GNUNET_break, GNUNET_DISK_PIPE_END_READ, and GNUNET_DISK_PIPE_END_WRITE.

Referenced by child_death_task(), GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_OS_command_run(), GNUNET_SCHEDULER_driver_init(), gnunet_uri(), maint_child_death(), restart_nat_server(), run(), shutdown_pipe_cb(), sighandler_child_death(), sighandler_shutdown(), start_helper(), start_process(), tokenizer_cb(), and work().

1746 {
1747  switch (n)
1748  {
1751  return p->fd[n];
1752 
1753  default:
1754  GNUNET_break(0);
1755  return NULL;
1756  }
1757 }
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_DISK_FileHandle * fd[2]
File descriptors for the pipe.
Definition: disk.c:73
The writing-end of a pipe.
The reading-end of a pipe.
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 argumets 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

If both argumets are GNUNET_NO, the file is made world-read-write-executable (777).

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

References GNUNET_ERROR_TYPE_WARNING, GNUNET_log_strerror_file, GNUNET_YES, and mode.

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

379 {
380  mode_t mode;
381 
382  if (GNUNET_YES == require_uid_match)
383  mode = S_IRUSR | S_IWUSR | S_IXUSR;
384  else if (GNUNET_YES == require_gid_match)
385  mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP;
386  else
387  mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH |
388  S_IWOTH | S_IXOTH;
389  if (0 != chmod(fn, mode))
391 }
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static char * fn
Filename of the unique file.
#define GNUNET_YES
Definition: gnunet_common.h:77
static enum @11 mode
Should we do a PUT (mode = 0) or GET (mode = 1);.
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
Parameters
fnonative integer file descriptor
Returns
file handle corresponding to the descriptor, NULL on error

Definition at line 1369 of file disk.c.

References GNUNET_DISK_FileHandle::fd, fh, and GNUNET_new.

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

1370 {
1371  struct GNUNET_DISK_FileHandle *fh;
1372 
1373  if ((((off_t)-1) == lseek(fno, 0, SEEK_CUR)) && (EBADF == errno))
1374  return NULL; /* invalid FD */
1375 
1376  fh = GNUNET_new(struct GNUNET_DISK_FileHandle);
1377 
1378  fh->fd = fno;
1379 
1380  return fh;
1381 }
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static int fh
Handle to the unique file.
int fd
File handle on Unix-like systems.
Handle used to access files (and pipes).
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

Get a handle from a native FD.

Parameters
fdnative streaming file descriptor
Returns
file handle corresponding to the descriptor

Definition at line 1391 of file disk.c.

References GNUNET_DISK_get_handle_from_int_fd().

Referenced by run(), and testing_main().

1392 {
1393  int fno;
1394 
1395  fno = fileno(fd);
1396  if (-1 == fno)
1397  return NULL;
1398 
1400 }
struct GNUNET_DISK_FileHandle * GNUNET_DISK_get_handle_from_int_fd(int fno)
Get a handle from a native integer FD.
Definition: disk.c:1369
int fd
File handle on Unix-like systems.
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 729 of file disk.c.

References GNUNET_DISK_FileHandle::fd, and GNUNET_SYSERR.

Referenced by child_death_task(), cmd_read(), database_setup(), decrementBit(), fh_reader(), file_hash_task(), GNUNET_BIO_read(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_CRYPTO_ecdsa_key_create_from_file(), GNUNET_CRYPTO_eddsa_key_create_from_file(), GNUNET_DISK_file_copy(), GNUNET_DISK_fn_read(), GNUNET_FS_data_reader_file_(), GNUNET_FS_handle_on_demand_block(), helper_read(), incrementBit(), main(), maint_child_death(), nat_server_read(), parent_control_handler(), print_key(), put_cb(), read_external_ipv4(), read_task(), REGEX_TEST_read_from_file(), restore_valid_peers(), run(), server_log(), shutdown_pipe_cb(), start_insert(), try_top_down_reconstruction(), and unindex_reader().

732 {
733  if (NULL == h)
734  {
735  errno = EINVAL;
736  return GNUNET_SYSERR;
737  }
738 
739  return read(h->fd, result, len);
740 }
static int result
Global testing status.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int fd
File handle on Unix-like systems.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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 754 of file disk.c.

References GNUNET_DISK_FileHandle::fd, GNUNET_SYSERR, and ret.

757 {
758  if (NULL == h)
759  {
760  errno = EINVAL;
761  return GNUNET_SYSERR;
762  }
763 
764  int flags;
765  ssize_t ret;
766 
767  /* set to non-blocking, read, then set back */
768  flags = fcntl(h->fd, F_GETFL);
769  if (0 == (flags & O_NONBLOCK))
770  (void)fcntl(h->fd, F_SETFL, flags | O_NONBLOCK);
771  ret = read(h->fd, result, len);
772  if (0 == (flags & O_NONBLOCK))
773  {
774  int eno = errno;
775  (void)fcntl(h->fd, F_SETFL, flags);
776  errno = eno;
777  }
778  return ret;
779 }
static int ret
Final status code.
Definition: gnunet-arm.c:89
static int result
Global testing status.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int fd
File handle on Unix-like systems.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...

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

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

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

792 {
793  struct GNUNET_DISK_FileHandle *fh;
794  ssize_t ret;
795  int eno;
796 
798  if (NULL == fh)
799  return GNUNET_SYSERR;
800  ret = GNUNET_DISK_file_read(fh, result, len);
801  eno = errno;
803  errno = eno;
804  return ret;
805 }
Open the file for reading.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
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:729
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Nobody is allowed to do anything to the file.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
static char * fn
Filename of the unique file.
static int result
Global testing status.
static int fh
Handle to the unique file.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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:1262
Handle used to access files (and pipes).
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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 817 of file disk.c.

References GNUNET_DISK_FileHandle::fd, and GNUNET_SYSERR.

Referenced by create_hostkeys(), database_shutdown(), decrementBit(), do_shutdown(), get_cb(), GNUNET_ATS_solver_logging_write_to_disk(), GNUNET_ATS_TEST_logging_write_to_file(), GNUNET_BIO_flush(), GNUNET_CRYPTO_ecdsa_key_create_from_file(), GNUNET_CRYPTO_eddsa_key_create_from_file(), GNUNET_DISK_file_copy(), GNUNET_DISK_fn_write(), GNUNET_FRIENDS_write(), GNUNET_OS_process_kill(), GNUNET_TESTING_peer_configure(), GNUNET_TIME_absolute_get_monotonic(), handle_estimate(), helper_write(), incrementBit(), main(), make_empty_file(), process_result_with_request(), publicize_rm(), publish_fs_connect_complete_cb(), regex_found_handler(), sighandler_child_death(), sighandler_shutdown(), start_dump(), stat_iterator(), stats_iterator(), store_and_free_entries(), store_peer_presistently_iterator(), to_file_raw(), tofile_(), try_match_block(), write_bw_gnuplot_script(), write_rtt_gnuplot_script(), write_task(), and write_throughput_gnuplot_script().

820 {
821  if (NULL == h)
822  {
823  errno = EINVAL;
824  return GNUNET_SYSERR;
825  }
826 
827 
828  return write(h->fd, buffer, n);
829 }
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int fd
File handle on Unix-like systems.
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 841 of file disk.c.

References GNUNET_DISK_FileHandle::fd, GNUNET_SYSERR, and ret.

Referenced by write_benchmark_data().

844 {
845  if (NULL == h)
846  {
847  errno = EINVAL;
848  return GNUNET_SYSERR;
849  }
850 
851 
852  int flags;
853  ssize_t ret;
854 
855  /* set to blocking, write, then set back */
856  flags = fcntl(h->fd, F_GETFL);
857  if (0 != (flags & O_NONBLOCK))
858  (void)fcntl(h->fd, F_SETFL, flags - O_NONBLOCK);
859  ret = write(h->fd, buffer, n);
860  if (0 == (flags & O_NONBLOCK))
861  (void)fcntl(h->fd, F_SETFL, flags);
862  return ret;
863 }
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int fd
File handle on Unix-like systems.
Here is the caller graph for this function:

◆ GNUNET_DISK_fn_write()

ssize_t GNUNET_DISK_fn_write ( const char *  fn,
const void *  buffer,
size_t  n,
enum GNUNET_DISK_AccessPermissions  mode 
)

Write a buffer to a file.

If the file is longer than the given buffer size, it will be truncated.

Parameters
fnfile name
bufferthe data to write
nnumber of bytes to write
modefile permissions
Returns
number of bytes written on success, GNUNET_SYSERR on error

If the file is longer than the number of bytes that will be written, it will be truncated.

Parameters
fnfile name
bufferthe data to write
nnumber of bytes to write
modefile permissions
Returns
number of bytes written on success, GNUNET_SYSERR on error

Definition at line 877 of file disk.c.

References fh, GNUNET_assert, GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_OPEN_WRITE, GNUNET_OK, GNUNET_SYSERR, and ret.

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

881 {
882  struct GNUNET_DISK_FileHandle *fh;
883  ssize_t ret;
884 
885  fh =
889  mode);
890  if (!fh)
891  return GNUNET_SYSERR;
892  ret = GNUNET_DISK_file_write(fh, buffer, n);
894  return ret;
895 }
Create file if it doesn&#39;t exist.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
static char * fn
Filename of the unique file.
Truncate file if it exists.
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:817
static int fh
Handle to the unique file.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
Open the file for writing.
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:1262
Handle used to access files (and pipes).
static enum @11 mode
Should we do a PUT (mode = 0) or GET (mode = 1);.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_DISK_file_copy()

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

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

1070 {
1071  char *buf;
1072  uint64_t pos;
1073  uint64_t size;
1074  size_t len;
1075  ssize_t sret;
1076  struct GNUNET_DISK_FileHandle *in;
1077  struct GNUNET_DISK_FileHandle *out;
1078 
1080  {
1082  return GNUNET_SYSERR;
1083  }
1084  pos = 0;
1085  in =
1087  if (!in)
1088  {
1090  return GNUNET_SYSERR;
1091  }
1092  out =
1100  if (!out)
1101  {
1104  return GNUNET_SYSERR;
1105  }
1107  while (pos < size)
1108  {
1109  len = COPY_BLK_SIZE;
1110  if (len > size - pos)
1111  len = size - pos;
1112  sret = GNUNET_DISK_file_read(in, buf, len);
1113  if ((sret < 0) || (len != (size_t)sret))
1114  goto FAIL;
1115  sret = GNUNET_DISK_file_write(out, buf, len);
1116  if ((sret < 0) || (len != (size_t)sret))
1117  goto FAIL;
1118  pos += len;
1119  }
1120  GNUNET_free(buf);
1123  return GNUNET_OK;
1124 FAIL:
1125  GNUNET_free(buf);
1128  return GNUNET_SYSERR;
1129 }
Open the file for reading.
Create file if it doesn&#39;t exist.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
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:729
Nobody is allowed to do anything to the file.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
#define COPY_BLK_SIZE
Block size for IO for copying files.
Definition: disk.c:42
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:817
static char buf[2048]
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:66
Open the file for writing.
int 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:254
#define GNUNET_YES
Definition: gnunet_common.h:77
Fail if file already exists.
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:1262
Handle used to access files (and pipes).
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:

◆ GNUNET_DISK_directory_scan()

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

Scan a directory for files.

Parameters
dir_namethe name of the directory
callbackthe method to call for each file
callback_clsclosure for callback
Returns
the number of files found, -1 on error
Parameters
dir_namethe name of the directory
callbackthe method to call for each file, can be NULL, in that case, we only count
callback_clsclosure for callback
Returns
the number of files found, GNUNET_SYSERR on error or ieration aborted by callback returning GNUNET_SYSERR

Definition at line 909 of file disk.c.

References _, 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(), getSizeRec(), GNUNET_CONFIGURATION_load_from(), GNUNET_DISK_directory_remove(), GNUNET_PLUGIN_load_all(), iter_testbed_path(), preprocess_file(), profiler_eval(), run(), and scan().

912 {
913  DIR *dinfo;
914  struct dirent *finfo;
915  struct stat istat;
916  int count = 0;
917  int ret;
918  char *name;
919  char *dname;
920  unsigned int name_len;
921  unsigned int n_size;
922 
923  GNUNET_assert(NULL != dir_name);
925  if (NULL == dname)
926  return GNUNET_SYSERR;
927  while ((strlen(dname) > 0) && (dname[strlen(dname) - 1] == DIR_SEPARATOR))
928  dname[strlen(dname) - 1] = '\0';
929  if (0 != stat(dname, &istat))
930  {
932  GNUNET_free(dname);
933  return GNUNET_SYSERR;
934  }
935  if (!S_ISDIR(istat.st_mode))
936  {
938  _("Expected `%s' to be a directory!\n"),
939  dir_name);
940  GNUNET_free(dname);
941  return GNUNET_SYSERR;
942  }
943  errno = 0;
944  dinfo = opendir(dname);
945  if ((EACCES == errno) || (NULL == dinfo))
946  {
947  LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "opendir", dname);
948  if (NULL != dinfo)
949  closedir(dinfo);
950  GNUNET_free(dname);
951  return GNUNET_SYSERR;
952  }
953  name_len = 256;
954  n_size = strlen(dname) + name_len + strlen(DIR_SEPARATOR_STR) + 1;
955  name = GNUNET_malloc(n_size);
956  while (NULL != (finfo = readdir(dinfo)))
957  {
958  if ((0 == strcmp(finfo->d_name, ".")) ||
959  (0 == strcmp(finfo->d_name, "..")))
960  continue;
961  if (NULL != callback)
962  {
963  if (name_len < strlen(finfo->d_name))
964  {
965  GNUNET_free(name);
966  name_len = strlen(finfo->d_name);
967  n_size = strlen(dname) + name_len + strlen(DIR_SEPARATOR_STR) + 1;
968  name = GNUNET_malloc(n_size);
969  }
970  /* dname can end in "/" only if dname == "/";
971  * if dname does not end in "/", we need to add
972  * a "/" (otherwise, we must not!) */
973  GNUNET_snprintf(name,
974  n_size,
975  "%s%s%s",
976  dname,
977  (0 == strcmp(dname, DIR_SEPARATOR_STR))
978  ? ""
980  finfo->d_name);
981  ret = callback(callback_cls, name);
982  if (GNUNET_OK != ret)
983  {
984  closedir(dinfo);
985  GNUNET_free(name);
986  GNUNET_free(dname);
987  if (GNUNET_NO == ret)
988  return count;
989  return GNUNET_SYSERR;
990  }
991  }
992  count++;
993  }
994  closedir(dinfo);
995  GNUNET_free(name);
996  GNUNET_free(dname);
997  return count;
998 }
static const char * dir_name
Top-level directory we monitor to auto-publish.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
#define DIR_SEPARATOR_STR
Definition: platform.h:168
#define LOG(kind,...)
Definition: disk.c:31
#define DIR_SEPARATOR
Definition: platform.h:167
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:602
const char * name
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: disk.c:36
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_DISK_directory_create_for_file()

int 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
Parameters
filenamename of a file in the directory
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure, GNUNET_NO if the directory exists but is not writeable for us

Definition at line 681 of file disk.c.

References DIR_SEPARATOR, GNUNET_DISK_directory_create(), GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, len, and ret.

Referenced by create_hostkeys(), database_setup(), get_server_addresses(), GNUNET_ATS_solver_logging_write_to_disk(), GNUNET_CONFIGURATION_write(), GNUNET_CRYPTO_ecdsa_key_create_from_file(), GNUNET_CRYPTO_eddsa_key_create_from_file(), GNUNET_DISK_file_open(), GNUNET_FRIENDS_parse(), GNUNET_FRIENDS_write_start(), GNUNET_FS_download_sync_(), handle_create_message(), 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().

682 {
683  char *rdir;
684  size_t len;
685  int ret;
686  int eno;
687 
689  if (NULL == rdir)
690  {
691  errno = EINVAL;
692  return GNUNET_SYSERR;
693  }
694  if (0 == access(rdir, W_OK))
695  {
696  GNUNET_free(rdir);
697  return GNUNET_OK;
698  }
699 
700  len = strlen(rdir);
701  while ((len > 0) && (rdir[len] != DIR_SEPARATOR))
702  len--;
703  rdir[len] = '\0';
704  /* The empty path is invalid and in this case refers to / */
705  if (0 == len)
706  {
707  GNUNET_free(rdir);
708  rdir = GNUNET_strdup("/");
709  }
710  ret = GNUNET_DISK_directory_create(rdir);
711  if ((GNUNET_OK == ret) && (0 != access(rdir, W_OK)))
712  ret = GNUNET_NO;
713  eno = errno;
714  GNUNET_free(rdir);
715  errno = eno;
716  return ret;
717 }
int GNUNET_DISK_directory_create(const char *dir)
Implementation of "mkdir -p".
Definition: disk.c:586
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static char * filename
#define DIR_SEPARATOR
Definition: platform.h:167
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:602
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_DISK_directory_test()

int 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

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 stat'ed

Definition at line 500 of file disk.c.

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

Referenced by deserialization_master(), deserialize_download(), deserialize_search(), GNUNET_DISK_directory_create(), GNUNET_DISK_directory_remove(), GNUNET_FS_remove_sync_dir_(), GNUNET_OS_installation_get_path(), and run().

501 {
502  struct stat filestat;
503  int ret;
504 
505  ret = stat(fil, &filestat);
506  if (ret != 0)
507  {
508  if (errno != ENOENT)
510  return GNUNET_SYSERR;
511  }
512  if (!S_ISDIR(filestat.st_mode))
513  {
515  "A file already exits with the same name %s\n",
516  fil);
517  return GNUNET_NO;
518  }
519  if (GNUNET_YES == is_readable)
520  ret = access(fil, R_OK | X_OK);
521  else
522  ret = access(fil, X_OK);
523  if (ret < 0)
524  {
526  return GNUNET_NO;
527  }
528  return GNUNET_YES;
529 }
#define GNUNET_NO
Definition: gnunet_common.h:78
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define LOG(kind,...)
Definition: disk.c:31
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: disk.c:36
#define GNUNET_YES
Definition: gnunet_common.h:77
Here is the caller graph for this function:

◆ GNUNET_DISK_directory_remove()

int 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

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

References 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 access_handler_callback(), delete_files(), GNUNET_FS_remove_sync_dir_(), GNUNET_TESTING_system_destroy(), publish_timeout(), purge_cfg_dir(), remove_helper(), report_uri(), and run().

1027 {
1028  struct stat istat;
1029 
1030  if (NULL == filename)
1031  {
1032  GNUNET_break(0);
1033  return GNUNET_SYSERR;
1034  }
1035  if (0 != lstat(filename, &istat))
1036  return GNUNET_NO; /* file may not exist... */
1037  (void)chmod(filename, S_IWUSR | S_IRUSR | S_IXUSR);
1038  if (0 == unlink(filename))
1039  return GNUNET_OK;
1040  if ((errno != EISDIR) &&
1041  /* EISDIR is not sufficient in all cases, e.g.
1042  * sticky /tmp directory may result in EPERM on BSD.
1043  * So we also explicitly check "isDirectory" */
1045  {
1047  return GNUNET_SYSERR;
1048  }
1049  if (GNUNET_SYSERR ==
1051  return GNUNET_SYSERR;
1052  if (0 != rmdir(filename))
1053  {
1055  return GNUNET_SYSERR;
1056  }
1057  return GNUNET_OK;
1058 }
int GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:500
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:909
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static int remove_helper(void *unused, const char *fn)
Function that removes the given directory by calling GNUNET_DISK_directory_remove().
Definition: disk.c:1010
static char * filename
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: disk.c:36
#define GNUNET_YES
Definition: gnunet_common.h:77
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 1822 of file disk.c.

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

1823 {
1826  &purge_cfg_dir,
1827  (void *)option));
1828 }
static char * cfg_filename
Name of the configuration file.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static char * option
Name of the option.
Definition: gnunet-config.c:38
static int purge_cfg_dir(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Helper function for GNUNET_DISK_purge_cfg_dir.
Definition: disk.c:1792
int 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...
Here is the call graph for this function:

◆ GNUNET_DISK_directory_create()

int GNUNET_DISK_directory_create ( const char *  dir)

Implementation of "mkdir -p".

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

Definition at line 586 of file disk.c.

References 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, len, LOG_STRERROR_FILE, and ret.

Referenced by cron_scan_directory_data_hosts(), ensure_folder_exist(), GNUNET_DISK_directory_create_for_file(), run(), write_benchmark_data(), and write_pid_file().

587 {
588  char *rdir;
589  unsigned int len;
590  unsigned int pos;
591  unsigned int pos2;
592  int ret = GNUNET_OK;
593 
595  if (rdir == NULL)
596  {
597  GNUNET_break(0);
598  return GNUNET_SYSERR;
599  }
600 
601  len = strlen(rdir);
602 
603  pos = 1; /* skip heading '/' */
604 
605  /* Check which low level directories already exist */
606  pos2 = len;
607  rdir[len] = DIR_SEPARATOR;
608  while (pos <= pos2)
609  {
610  if (DIR_SEPARATOR == rdir[pos2])
611  {
612  rdir[pos2] = '\0';
614  if (GNUNET_NO == ret)
615  {
617  "Creating directory `%s' failed",
618  rdir);
619  GNUNET_free(rdir);
620  return GNUNET_SYSERR;
621  }
622  rdir[pos2] = DIR_SEPARATOR;
623  if (GNUNET_YES == ret)
624  {
625  pos2++;
626  break;
627  }
628  }
629  pos2--;
630  }
631  rdir[len] = '\0';
632  if (pos < pos2)
633  pos = pos2;
634  /* Start creating directories */
635  while (pos <= len)
636  {
637  if ((rdir[pos] == DIR_SEPARATOR) || (pos == len))
638  {
639  rdir[pos] = '\0';
641  if (GNUNET_NO == ret)
642  {
644  "Creating directory `%s' failed",
645  rdir);
646  GNUNET_free(rdir);
647  return GNUNET_SYSERR;
648  }
649  if (GNUNET_SYSERR == ret)
650  {
651  ret = mkdir(rdir,
652  S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH |
653  S_IXOTH); /* 755 */
654 
655  if ((ret != 0) && (errno != EEXIST))
656  {
658  GNUNET_free(rdir);
659  return GNUNET_SYSERR;
660  }
661  }
662  rdir[pos] = DIR_SEPARATOR;
663  }
664  pos++;
665  }
666  GNUNET_free(rdir);
667  return GNUNET_OK;
668 }
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:84
int GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:500
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define DIR_SEPARATOR
Definition: platform.h:167
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:602
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: disk.c:36
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_DISK_file_lock()

int GNUNET_DISK_file_lock ( struct GNUNET_DISK_FileHandle fh,
off_t  lock_start,
off_t  lock_end,
int  excl 
)

Lock a part of a file.

Parameters
fhfile handle
lock_startabsolute position from where to lock
lock_endabsolute position until where to lock
exclGNUNET_YES for an exclusive lock
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1195 of file disk.c.

References GNUNET_DISK_FileHandle::fd, GNUNET_OK, and GNUNET_SYSERR.

Referenced by GNUNET_CRYPTO_ecdsa_key_create_from_file(), and GNUNET_CRYPTO_eddsa_key_create_from_file().

1199 {
1200  if (fh == NULL)
1201  {
1202  errno = EINVAL;
1203  return GNUNET_SYSERR;
1204  }
1205 
1206  struct flock fl;
1207 
1208  memset(&fl, 0, sizeof(struct flock));
1209  fl.l_type = excl ? F_WRLCK : F_RDLCK;
1210  fl.l_whence = SEEK_SET;
1211  fl.l_start = lock_start;
1212  fl.l_len = lock_end;
1213 
1214  return fcntl(fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
1215 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int fd
File handle on Unix-like systems.
Here is the caller graph for this function:

◆ GNUNET_DISK_file_unlock()

int GNUNET_DISK_file_unlock ( struct GNUNET_DISK_FileHandle fh,
off_t  unlock_start,
off_t  unlock_end 
)

Unlock a part of a file.

Parameters
fhfile handle
unlock_startabsolute position from where to unlock
unlock_endabsolute position until where to unlock
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1227 of file disk.c.

References GNUNET_DISK_FileHandle::fd, GNUNET_OK, and GNUNET_SYSERR.

Referenced by GNUNET_CRYPTO_ecdsa_key_create_from_file(), and GNUNET_CRYPTO_eddsa_key_create_from_file().

1230 {
1231  if (fh == NULL)
1232  {
1233  errno = EINVAL;
1234  return GNUNET_SYSERR;
1235  }
1236 
1237  struct flock fl;
1238 
1239  memset(&fl, 0, sizeof(struct flock));
1240  fl.l_type = F_UNLCK;
1241  fl.l_whence = SEEK_SET;
1242  fl.l_start = unlock_start;
1243  fl.l_len = unlock_end;
1244 
1245  return fcntl(fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
1246 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int fd
File handle on Unix-like systems.
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 1137 of file disk.c.

Referenced by progress_cb().

1138 {
1139  char *idx;
1140  char c;
1141 
1142  for (idx = fn; *idx; idx++)
1143  {
1144  c = *idx;
1145 
1146  if (c == '/' || c == '\\' || c == ':' || c == '*' || c == '?' || c == '"' ||
1147  c == '<' || c == '>' || c == '|')
1148  {
1149  *idx = '_';
1150  }
1151  }
1152 }
static char * fn
Filename of the unique file.
Here is the caller graph for this function:

◆ GNUNET_DISK_file_change_owner()

int 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
Parameters
filenamename of file to change the owner of
username of the new owner
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1163 of file disk.c.

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

Referenced by write_pid_file().

1164 {
1165  struct passwd *pws;
1166 
1167  pws = getpwnam(user);
1168  if (NULL == pws)
1169  {
1171  _("Cannot obtain information about user `%s': %s\n"),
1172  user,
1173  strerror(errno));
1174  return GNUNET_SYSERR;
1175  }
1176  if (0 != chown(filename, pws->pw_uid, pws->pw_gid))
1177  {
1179  return GNUNET_SYSERR;
1180  }
1181  return GNUNET_OK;
1182 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static char * filename
#define LOG(kind,...)
Definition: disk.c:31
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: disk.c:36
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
Parameters
hopen file handle
mhandle to the new mapping
accessaccess specification, GNUNET_DISK_MAP_TYPE_xxx
lensize of the mapping
Returns
pointer to the mapped memory region, NULL on failure

Definition at line 1433 of file disk.c.

References GNUNET_DISK_FileHandle::fd, GNUNET_assert, GNUNET_DISK_MAP_TYPE_READ, GNUNET_DISK_MAP_TYPE_WRITE, GNUNET_free, GNUNET_new, len, and MAP_FAILED.

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

1437 {
1438  if (NULL == h)
1439  {
1440  errno = EINVAL;
1441  return NULL;
1442  }
1443 
1444  int prot;
1445 
1446  prot = 0;
1447  if (access & GNUNET_DISK_MAP_TYPE_READ)
1448  prot = PROT_READ;
1449  if (access & GNUNET_DISK_MAP_TYPE_WRITE)
1450  prot |= PROT_WRITE;
1451  *m = GNUNET_new(struct GNUNET_DISK_MapHandle);
1452  (*m)->addr = mmap(NULL, len, prot, MAP_SHARED, h->fd, 0);
1453  GNUNET_assert(NULL != (*m)->addr);
1454  if (MAP_FAILED == (*m)->addr)
1455  {
1456  GNUNET_free(*m);
1457  return NULL;
1458  }
1459  (*m)->len = len;
1460  return (*m)->addr;
1461 }
#define MAP_FAILED
Definition: disk.c:1420
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Read-only memory map.
Write-able memory map.
int fd
File handle on Unix-like systems.
Handle for a memory-mapping operation.
Definition: disk.c:1406
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the caller graph for this function:

◆ GNUNET_DISK_file_unmap()

int GNUNET_DISK_file_unmap ( struct GNUNET_DISK_MapHandle h)

Unmap a file.

Parameters
hmapping handle
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise
Parameters
hmapping handle
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1469 of file disk.c.

References GNUNET_DISK_MapHandle::addr, GNUNET_free, GNUNET_OK, GNUNET_SYSERR, GNUNET_DISK_MapHandle::len, and ret.

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

1470 {
1471  int ret;
1472 
1473  if (h == NULL)
1474  {
1475  errno = EINVAL;
1476  return GNUNET_SYSERR;
1477  }
1478 
1479  ret = munmap(h->addr, h->len) != -1 ? GNUNET_OK : GNUNET_SYSERR;
1480 
1481  GNUNET_free(h);
1482  return ret;
1483 }
void * addr
Address where the map is in memory.
Definition: disk.c:1410
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
size_t len
Number of bytes mapped.
Definition: disk.c:1415
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function:

◆ GNUNET_DISK_file_sync()

int 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
Parameters
hhandle to an open file
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1492 of file disk.c.

References GNUNET_DISK_FileHandle::fd, GNUNET_OK, and GNUNET_SYSERR.

Referenced by GNUNET_CRYPTO_ecdsa_key_create_from_file(), GNUNET_CRYPTO_eddsa_key_create_from_file(), and publicize_rm().

1493 {
1494  if (h == NULL)
1495  {
1496  errno = EINVAL;
1497  return GNUNET_SYSERR;
1498  }
1499 
1500 #if defined(FREEBSD) || defined(OPENBSD) || defined(DARWIN)
1501  return fsync(h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
1502 #else
1503  return fdatasync(h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
1504 #endif
1505 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int fd
File handle on Unix-like systems.
Here is the caller graph for this function: