gnunet_disk_lib.h

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2001-2012 GNUnet e.V.
 
     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.
 
     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
#if ! defined (__GNUNET_UTIL_LIB_H_INSIDE__)
#error "Only <gnunet_util_lib.h> can be included directly."
#endif
 
#ifndef GNUNET_DISK_LIB_H
#define GNUNET_DISK_LIB_H
 
struct GNUNET_DISK_PipeHandle;
 
enum GNUNET_FILE_Type
{
  GNUNET_DISK_HANLDE_TYPE_EVENT,
 
  GNUNET_DISK_HANLDE_TYPE_FILE,
 
  GNUNET_DISK_HANLDE_TYPE_PIPE
};
 
struct GNUNET_DISK_FileHandle
{
  int fd;
};
 
 
/* we need size_t, and since it can be both unsigned int
   or unsigned long long, this IS platform dependent;
   but "stdlib.h" should be portable 'enough' to be
   unconditionally available... */
 
#include <stdlib.h>
#include "gnunet_configuration_lib.h"
#include "gnunet_scheduler_lib.h"
 
#ifdef __cplusplus
extern "C"
{
#if 0                           /* keep Emacsens' auto-indent happy */
}
#endif
#endif
 
 
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
};
 
enum GNUNET_DISK_MapType
{
  GNUNET_DISK_MAP_TYPE_READ = 1,
 
  GNUNET_DISK_MAP_TYPE_WRITE = 2,
 
  GNUNET_DISK_MAP_TYPE_READWRITE = 3
};
 
 
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
};
 
 
enum GNUNET_DISK_Seek
{
  GNUNET_DISK_SEEK_SET = 0,
 
  GNUNET_DISK_SEEK_CUR = 1,
 
  GNUNET_DISK_SEEK_END = 2
};
 
 
enum GNUNET_DISK_PipeEnd
{
  GNUNET_DISK_PIPE_END_READ = 0,
 
  GNUNET_DISK_PIPE_END_WRITE = 1
};
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_handle_invalid (const struct GNUNET_DISK_FileHandle *h);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_file_test (const char *fil);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_file_test_read (const char *fil);
 
 
char*
GNUNET_DISK_file_backup (const char *fil);
 
 
off_t
GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h,
                       off_t offset,
                       enum GNUNET_DISK_Seek whence);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_file_size (const char *filename,
                       uint64_t *size,
                       int include_symbolic_links,
                       int single_file_mode);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_file_get_identifiers (const char *filename,
                                  uint64_t *dev,
                                  uint64_t *ino);
 
 
char *
GNUNET_DISK_mktemp (const char *t);
 
 
char *
GNUNET_DISK_mkdtemp (const char *t);
 
 
struct GNUNET_DISK_FileHandle *
GNUNET_DISK_file_open (const char *fn,
                       enum GNUNET_DISK_OpenFlags flags,
                       enum GNUNET_DISK_AccessPermissions perm);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_file_handle_size (struct GNUNET_DISK_FileHandle *fh,
                              off_t *size);
 
 
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 = GNUNET_DISK_PF_BLOCKING_READ
                               | GNUNET_DISK_PF_BLOCKING_WRITE
 
};
 
 
struct GNUNET_DISK_PipeHandle *
GNUNET_DISK_pipe (enum GNUNET_DISK_PipeFlags pf);
 
 
struct GNUNET_DISK_PipeHandle *
GNUNET_DISK_pipe_from_fd (enum GNUNET_DISK_PipeFlags pf,
                          int fd[2]);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_pipe_close_end (struct GNUNET_DISK_PipeHandle *p,
                            enum GNUNET_DISK_PipeEnd end);
 
 
struct GNUNET_DISK_FileHandle *
GNUNET_DISK_pipe_detach_end (struct GNUNET_DISK_PipeHandle *p,
                             enum GNUNET_DISK_PipeEnd end);
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_file_close (struct GNUNET_DISK_FileHandle *h);
 
 
const struct GNUNET_DISK_FileHandle *
GNUNET_DISK_pipe_handle (const struct GNUNET_DISK_PipeHandle *p,
                         enum GNUNET_DISK_PipeEnd n);
 
 
void
GNUNET_DISK_fix_permissions (const char *fn,
                             int require_uid_match,
                             int require_gid_match);
 
 
struct GNUNET_DISK_FileHandle *
GNUNET_DISK_get_handle_from_int_fd (int fno);
 
 
struct GNUNET_DISK_FileHandle *
GNUNET_DISK_get_handle_from_native (FILE *fd);
 
 
ssize_t
GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h,
                       void *result,
                       size_t len);
 
 
ssize_t
GNUNET_DISK_fn_read (const char *fn,
                     void *result,
                     size_t len);
 
 
ssize_t
GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle *h,
                        const void *buffer,
                        size_t n);
 
 
ssize_t
GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle *h,
                                 const void *buffer,
                                 size_t n);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_fn_write (const char *fn,
                      const void *buf,
                      size_t buf_size,
                      enum GNUNET_DISK_AccessPermissions mode);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_file_copy (const char *src,
                       const char *dst);
 
 
int
GNUNET_DISK_directory_scan (const char *dir_name,
                            GNUNET_FileNameCallback callback,
                            void *callback_cls);
 
int
GNUNET_DISK_glob (const char *glob_pattern,
                  GNUNET_FileNameCallback callback,
                  void *callback_cls);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_directory_create_for_file (const char *filename);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_directory_test (const char *fil,
                            int is_readable);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_directory_remove (const char *filename);
 
 
void
GNUNET_DISK_purge_cfg_dir (const struct GNUNET_OS_ProjectData *pd,
                           const char *cfg_filename,
                           const char *option);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_directory_create (const char *dir);
 
 
void
GNUNET_DISK_filename_canonicalize (char *fn);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_file_change_owner (const char *filename,
                               const char *user);
 
 
struct GNUNET_DISK_MapHandle;
 
 
void *
GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h,
                      struct GNUNET_DISK_MapHandle **m,
                      enum GNUNET_DISK_MapType access,
                      size_t len);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_file_unmap (struct GNUNET_DISK_MapHandle *h);
 
 
enum GNUNET_GenericReturnValue
GNUNET_DISK_file_sync (const struct GNUNET_DISK_FileHandle *h);
 
 
#if 0                           /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
/* ifndef GNUNET_DISK_LIB_H */
#endif
  /* end of group */
 /* end of group addition */
 
/* end of gnunet_disk_lib.h */