libcvmfs.h

Go to the documentation of this file.

#ifndef CVMFS_LIBCVMFS_H_
#define CVMFS_LIBCVMFS_H_

#define LIBCVMFS_VERSION 2
#define LIBCVMFS_VERSION_MAJOR LIBCVMFS_VERSION
#define LIBCVMFS_VERSION_MINOR 13
// Revision Changelog
// 13: revision introduced
// 14: fix expand_path for absolute paths, add mountpoint to cvmfs_context
// 15: remove counting of open file descriptors
// 16: remove unnecessary free
// 17: apply new classes around the cache manager
// 18: add cvmfs_pread and support for chunked files
// 19: CernVM-FS 2.2.0
// 20: fix reading of chunked files
// 21: CernVM-FS 2.2.3
// 22: CernVM-FS 2.3.0
// 23: update initialization code
// 24: add LIBCVMFS_ERR_REVISION_BLACKLISTED
// 25: CernVM-FS 2.4.0
// 26: CernVM-FS 2.5.0
// 27: Add cvmfs_options_init_v2
// 28: CernVM-FS 2.6.0
// 29: CernVM-FS 2.8
//     * Add cvmfs_options_parse_default
//     * Add cvmfs_listdir_stat
//     * Add catalog counters to struct cvmfs_nc_attr
// 30: CernVM-FS 2.8
//     * Implement cvmfs_remount()
//     * Add cvmfs_get_revision()
// 31: CernVM-FS 2.11
//     * Move from static libcvmfs.a to shared libcvmfs_client.so
#define LIBCVMFS_REVISION 31

#include <stdint.h>
#include <sys/stat.h>
#include <unistd.h>

// Legacy error codes
#define LIBCVMFS_FAIL_OK         0
#define LIBCVMFS_FAIL_NOFILES   -1
#define LIBCVMFS_FAIL_MKCACHE   -2
#define LIBCVMFS_FAIL_OPENCACHE -3
#define LIBCVMFS_FAIL_LOCKFILE  -4
#define LIBCVMFS_FAIL_INITCACHE -5
#define LIBCVMFS_FAIL_INITQUOTA -6
#define LIBCVMFS_FAIL_BADOPT    -7


#ifdef __cplusplus
extern "C" {
// Map C++ classes to their C interface names
typedef class LibContext cvmfs_context;
typedef class SimpleOptionsParser cvmfs_option_map;
#else
typedef struct LibContext cvmfs_context;
typedef struct OptionsManager cvmfs_option_map;
#endif

typedef enum {
  LIBCVMFS_ERR_OK = 0,
  LIBCVMFS_ERR_UNKNOWN,
  LIBCVMFS_ERR_OPTIONS,
  LIBCVMFS_ERR_PERMISSION,
  LIBCVMFS_ERR_MOUNT,                  // unused in the library
  LIBCVMFS_ERR_LOADER_TALK,            // unused in the library
  LIBCVMFS_ERR_FUSE_LOOP,              // unused in the library
  LIBCVMFS_ERR_LOAD_LIBRARY,           // unused in the library
  LIBCVMFS_ERR_INCOMPATIBLE_VERSIONS,  // unused
  LIBCVMFS_ERR_CACHE_DIR,
  LIBCVMFS_ERR_PEERS,                  // unused
  LIBCVMFS_ERR_NFS_MAPS,
  LIBCVMFS_ERR_QUOTA,
  LIBCVMFS_ERR_MONITOR,                // unused in the library
  LIBCVMFS_ERR_TALK,                   // unused in the library
  LIBCVMFS_ERR_SIGNATURE,
  LIBCVMFS_ERR_CATALOG,
  LIBCVMFS_ERR_MAINTENANCE_MODE,       // unused in the library
  LIBCVMFS_ERR_SAVE_STATE,             // unused in the library
  LIBCVMFS_ERR_RESTORE_STATE,          // unused in the library
  LIBCVMFS_ERR_OTHER_MOUNT,            // unused in the library
  LIBCVMFS_ERR_DOUBLE_MOUNT,           // unused in the library
  LIBCVMFS_ERR_HISTORY,
  LIBCVMFS_ERR_WPAD,
  LIBCVMFS_ERR_LOCK_WORKSPACE,
  LIBCVMFS_ERR_REVISION_BLACKLISTED,
} cvmfs_errors;

struct cvmfs_nc_attr {
  char *mountpoint;
  char *hash;
  uint64_t size;

  // Catalog counters
  uint64_t ctr_regular;
  uint64_t ctr_symlink;
  uint64_t ctr_special;
  uint64_t ctr_dir;
  uint64_t ctr_nested;
  uint64_t ctr_chunked;
  uint64_t ctr_chunks;
  uint64_t ctr_file_size;
  uint64_t ctr_chunked_size;
  uint64_t ctr_xattr;
  uint64_t ctr_external;
  uint64_t ctr_external_file_size;
};

struct cvmfs_nc_attr* cvmfs_nc_attr_init();

void cvmfs_nc_attr_free(struct cvmfs_nc_attr *nc_attr);

struct cvmfs_attr {
  /* Struct definition information */
  unsigned version;
  uint64_t size;

  /* Contents of stat, mapped from DirectoryEntry */
  dev_t     st_dev;
  ino_t     st_ino;
  mode_t    st_mode;
  nlink_t   st_nlink;
  uid_t     st_uid;
  gid_t     st_gid;
  dev_t     st_rdev;
  off_t     st_size;
  time_t    mtime;

  /* CVMFS related content */
  int cvm_nchunks;
  int cvm_is_hash_artificial;
  /* This information is allocated and should be freed */
  // For chunked files without bulk hash: hash of chunk hashes
  char * cvm_checksum;
  char * cvm_symlink;
  char * cvm_parent;
  char * cvm_name;
  void * cvm_xattrs;
};


struct cvmfs_stat_t {
  // name of the object, owned by the struct (needs to be freed)
  char * name;
  struct stat info;
};

struct cvmfs_attr* cvmfs_attr_init();

void cvmfs_attr_free(struct cvmfs_attr *attr);

void cvmfs_set_log_fn( void (*log_fn)(const char *msg) );

char *cvmfs_statistics_format(cvmfs_context *ctx);

cvmfs_option_map *cvmfs_options_init();
cvmfs_option_map *cvmfs_options_init_v2(int taint_environ);


void cvmfs_enable_threaded(cvmfs_context *ctx);

cvmfs_option_map *cvmfs_options_init_legacy(const char *legacy_options);
cvmfs_option_map *cvmfs_options_clone(cvmfs_option_map *opts);
cvmfs_option_map *cvmfs_options_clone_legacy(cvmfs_option_map *opts,
                                             const char *legacy_options);
void cvmfs_options_fini(cvmfs_option_map *opts);
void cvmfs_options_set(cvmfs_option_map *opts,
                       const char *key, const char *value);
int cvmfs_options_parse(cvmfs_option_map *opts, const char *path);
void cvmfs_options_parse_default(cvmfs_option_map *opts, const char *fqrn);
void cvmfs_options_unset(cvmfs_option_map *opts, const char *key);
char *cvmfs_options_get(cvmfs_option_map *opts, const char *key);
char *cvmfs_options_dump(cvmfs_option_map *opts);
void cvmfs_options_free(char *value);


int cvmfs_init(char const *options);


cvmfs_errors cvmfs_init_v2(cvmfs_option_map *opts);


void cvmfs_fini();

cvmfs_context* cvmfs_attach_repo(char const *options);

cvmfs_errors cvmfs_attach_repo_v2(const char *fqrn, cvmfs_option_map *opts,
                                  cvmfs_context **ctx);

void cvmfs_adopt_options(cvmfs_context *ctx, cvmfs_option_map *opts);


void cvmfs_detach_repo(cvmfs_context *ctx);


int cvmfs_remount(cvmfs_context *ctx);


int cvmfs_open(cvmfs_context *ctx, const char *path);


ssize_t cvmfs_pread(cvmfs_context *ctx,
                    int fd, void *buf, size_t size, off_t off);

int cvmfs_close(cvmfs_context *ctx, int fd);

int cvmfs_readlink(cvmfs_context *ctx,
  const char *path,
  char *buf,
  size_t size);

int cvmfs_stat(cvmfs_context *ctx, const char *path, struct stat *st);

int cvmfs_lstat(cvmfs_context *ctx, const char *path, struct stat *st);

int cvmfs_stat_attr(
  cvmfs_context *ctx,
  const char *path,
  struct cvmfs_attr *attr);

int cvmfs_listdir(
  cvmfs_context *ctx,
  const char *path,
  char ***buf,
  size_t *buflen);

int cvmfs_listdir_contents(
  cvmfs_context *ctx,
  const char *path,
  char ***buf,
  size_t *listlen,
  size_t *buflen);

int cvmfs_listdir_stat(
  cvmfs_context *ctx,
  const char *path,
  struct cvmfs_stat_t **buf,
  size_t *listlen,
  size_t *buflen);

int cvmfs_stat_nc(
  cvmfs_context *ctx,
  const char *path,
  struct cvmfs_nc_attr *ncst);

int cvmfs_list_nc(
  cvmfs_context *ctx,
  const char *path,
  char ***buf,
  size_t *buflen);


void cvmfs_list_free(char **buf);

uint64_t cvmfs_get_revision(cvmfs_context *ctx);

#ifdef __cplusplus
}
#endif

#endif  // CVMFS_LIBCVMFS_H_