lib/base/nconfig.h

   1 #ifndef NC_NCONFIG_H
   2 #define NC_NCONFIG_H    1
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6
   7 /*
   8  * Superblock definitions
   9  */
  10 #define NC_SB_MAGIC             ("\0\11\22")                    // Superblock identifier
  11
  12 /*
  13  * Key type definitions
  14  */
  15 #define NC_DIR                  0x01    // The key is a directory
  16 #define NC_STRING               0x02    // The key contains a string
  17 #define NC_INT                  0x03    // The key contains a signed integer
  18 #define NC_UINT                 0x04    // The key contains an unsigned integer
  19 #define NC_RAW                  0x05    // The key contains raw data
  20 #define NC_DOUBLE               0x06    // The key contains a double
  21 #define NC_LINK                 0x07    // The key points somewhere else
  22
  23 /*
  24  * File access definitions
  25  */
  26 #define NC_O_RO                 0x01    // Open file in read-only mode
  27 #define NC_O_RW                 0x02    // Open file in read-write mode
  28
  29 /*
  30  * Lock types
  31  */
  32 #define NC_L_NONE               0x00    // No lock
  33 #define NC_L_RO                 0x01    // Read-only lock
  34 #define NC_L_RW                 0x02    // Read-write lock
  35
  36 /*
  37  * Error codes
  38  */
  39 #define NC_ERR_OK                       0               // Everything is OK
  40 #define NC_ERR_TYPE              -1             // Type mismatch
  41 #define NC_ERR_NDIR              -2             // Key is not a directory
  42 #define NC_ERR_PERM              -3             // Operation is not allowed
  43 #define NC_ERR_NMEM              -4             // Not enough memory to complete operation
  44 #define NC_ERR_NEXIST    -5             // Key does not exist
  45 #define NC_ERR_NFILE     -6             // No file is assigned/open
  46 #define NC_ERR_CORRUPT -7               // File is corrupted
  47 #define NC_ERR_NVAL              -8             // Invalid value
  48 #define NC_ERR_RDONLY    -9             // File is open in read-only mode
  49 #define NC_ERR_NOSUPPORT -10    // Support is not compiled-in
  50
  51 /*
  52  * Truth value definitions
  53  */
  54 #ifndef TRUE
  55 #define TRUE                    1
  56 #endif
  57 #ifndef FALSE
  58 #define FALSE                   0
  59 #endif
  60
  61 /*
  62  * Header of the config file.
  63  */
  64 struct nc_sb_s {
  65         char magic[4];          // superblock magic
  66         unsigned size;          // Current file size
  67         unsigned ent_inc;       // directory increment
  68         unsigned chunk_inc;     // Memory chunks increment
  69         unsigned size_inc;      // file size increment
  70         unsigned chunk_ttl;     // size of chunkmap
  71         unsigned chunk;         // pointer to chunkmap
  72         unsigned root;          // pointer to root direntry
  73         unsigned modtime;       // file version
  74 };
  75
  76 /*
  77  * Free chunk descriptor
  78  */
  79 struct nc_chunk_s {
  80         unsigned offset;
  81         unsigned size;
  82 };
  83
  84 /*
  85  *  In-file directory entry
  86  */
  87 struct nc_de_s {
  88         unsigned name;
  89         unsigned type;
  90         unsigned parent;
  91         unsigned offset;
  92         unsigned pages;
  93         unsigned crc;
  94 };
  95
  96 /*
  97  * Ls reporting
  98  */
  99 struct nc_ls_s {
 100         const char *name;
 101         unsigned type;
 102 };
 103
 104 class NConfig
 105 {
 106 public:
 107                 /*
 108                  * Class constructor
 109                  * pass TRUE as parameter to enable
 110                  * write protection when leaving library
 111                  */
 112                 NConfig(int protect = FALSE);
 113                 virtual ~NConfig();
 114
 115                 /*
 116                  * Set file name (prior to open)
 117                  * Errors:
 118                  * NC_ERR_PERM  file is already open
 119                  * NC_ERR_NVAL  no file name is given
 120                  */
 121                 int setName(const char *name);
 122
 123                 /*
 124                  * Open the configuration file, re-open it
 125                  * Errors:
 126                  * NC_ERR_NFILE         no file name is assigned
 127                  * NC_ERR_TYPE          file open mode is invalid
 128                  * NC_ERR_PERM          file cannot be opened/created
 129                  * NC_ERR_NMEM          unable to mmap the file
 130                  * NC_ERR_CORRUPT       superblock magic mismatch
 131                  */
 132                 int open(const int how = NC_O_RW);
 133
 134                 /*
 135                  * Close the configuration file
 136                  * No errors defined
 137                  */
 138                 void close();
 139
 140                 void flush(); // flush file if not mmap'ed
 141
 142                 /*
 143                  * Create a new file
 144                  * resize is filesize increment is system pages
 145                  * dirent is directory increment
 146                  * mchunks is memory block increment
 147                  * Errors:
 148                  * NC_ERR_PERM          file already exists
 149                  * NC_ERR_NFILE         cannot create new file
 150                  * NC_ERR_NVAL          file is already open
 151                  */
 152                 int createNew(unsigned resize = 4, unsigned dirent = 32, unsigned mchunks = 32);
 153
 154                 /*
 155                  * Get an unsigned integer
 156                  * Errors:
 157                  * NC_ERR_NFILE         no file is open
 158                  * NC_ERR_NEXIST        the key does not exist
 159                  * NC_ERR_TYPE          the key exists, but is of different type
 160                  */
 161                 int getKey(const char *name, unsigned &value);
 162                 int getKey(const char *name, unsigned long long &value);
 163
 164                 /*
 165                  * Get a signed integer
 166                  * Errors:
 167                  * NC_ERR_NFILE         no file is open
 168                  * NC_ERR_NEXIST        the key does not exist
 169                  * NC_ERR_TYPE          the key exists, but is of different type
 170                  */
 171                 int getKey(const char *name, int &value);
 172                 int getKey(const char *name, signed long long &value);
 173
 174                 /*
 175                  * Get a string
 176                  * Errors:
 177                  * NC_ERR_NFILE         no file is open
 178                  * NC_ERR_NEXIST        the key does not exist
 179                  * NC_ERR_TYPE          the key exists, but is of different type
 180                  */
 181                 int getKey(const char *name, char *&value);
 182
 183                 /*
 184                  * Get a long double
 185                  * Errors:
 186                  * NC_ERR_NFILE         no file is open
 187                  * NC_ERR_NEXIST        the key does not exist
 188                  * NC_ERR_TYPE          the key exists, but is of different type
 189                  */
 190                 int getKey(const char *name, double &value);
 191                 int getKey(const char *name, long double &value);
 192
 193                 /*
 194                  * Get raw data
 195                  * Errors:
 196                  * NC_ERR_NFILE         no file is open
 197                  * NC_ERR_NEXIST        the key does not exist
 198                  * NC_ERR_TYPE          the key exists, but is of different type
 199                  */
 200                 int getKey(const char *name, char *&value, unsigned &len);
 201
 202                 /*
 203                  * Insert an unsigned integer
 204                  * NC_ERR_NFILE         no file is open
 205                  * NC_ERR_RDONLY        file is open in read-only mode
 206                  * NC_ERR_PERM          intermediate key is not a directory
 207                  * NC_ERR_TYPE          key already exists, but is not an usigned integer
 208                  * NC_ERR_NEXIST        key does not exist (should NEVER happen)
 209                  */
 210                 int setKey(const char *name, const unsigned value);
 211                 int setKey(const char *name, const unsigned long long value);
 212
 213                 /*
 214                  * Insert an integer
 215                  * NC_ERR_NFILE         no file is open
 216                  * NC_ERR_RDONLY        file is open in read-only mode
 217                  * NC_ERR_PERM          intermediate key is not a directory
 218                  * NC_ERR_TYPE          key already exists, but is not a signed integer
 219                  * NC_ERR_NEXIST        key does not exist (should NEVER happen)
 220                  */
 221                 int setKey(const char *name, const int value);
 222                 int setKey(const char *name, const signed long long value);
 223
 224                 /*
 225                  * Insert a string
 226                  * NC_ERR_NFILE         no file is open
 227                  * NC_ERR_RDONLY        file is open in read-only mode
 228                  * NC_ERR_PERM          intermediate key is not a directory
 229                  * NC_ERR_TYPE          key already exists, but is not a string
 230                  * NC_ERR_NEXIST        key does not exist (should NEVER happen)
 231                  */
 232                 int setKey(const char *name, const char *value);
 233
 234                 /*
 235                  * Insert raw data
 236                  * NC_ERR_NFILE         no file is open
 237                  * NC_ERR_RDONLY        file is open in read-only mode
 238                  * NC_ERR_PERM          intermediate key is not a directory
 239                  * NC_ERR_TYPE          key already exists, but is not raw data
 240                  * NC_ERR_NEXIST        key does not exist (should NEVER happen)
 241                  */
 242                 int setKey(const char *name, const char *value, const unsigned len);
 243
 244                 /*
 245                  * Insert a double
 246                  * NC_ERR_NFILE         no file is open
 247                  * NC_ERR_RDONLY        file is open in read-only mode
 248                  * NC_ERR_PERM          intermediate key is not a directory
 249                  * NC_ERR_TYPE          key already exists, but is not raw data
 250                  * NC_ERR_NEXIST        key does not exist (should NEVER happen)
 251                  */
 252                 int setKey(const char *name, const double value);
 253                 int setKey(const char *name, const long double value);
 254
 255                 /*
 256                  * Rename a key
 257                  * Errors:
 258                  * NC_ERR_NFILE         no file is open
 259                  * NC_ERR_RDONLY        file is open read-only
 260                  * NC_ERR_NEXIST        the key does not exist
 261                  * NC_ERR_PERM          key with specified name already exists
 262                  */
 263                 int renameKey(const char *oldname, const char *newname);
 264
 265                 /*
 266                  * Delete a key
 267                  * No errors defined
 268                  */
 269                 void delKey(const char *name);
 270
 271                 /*
 272                  * Create a directory
 273                  * entries parameter specifies number of direntries to preallocate
 274                  * Errors:
 275                  * NC_ERR_NFILE         no file is open
 276                  * NC_ERR_RDONLY        file is open in read-only mode
 277                  * NC_ERR_PERM          intermediate key is not a directory
 278                  * NC_ERR_TYPE          key already exists, but is not a directory
 279                  * NC_ERR_NEXIST        key does not exist (should NEVER happen)
 280                  */
 281                 int createDir(const char *name, unsigned entries = 0);
 282
 283                 /*
 284                  * Change working directory
 285                  * Errors:
 286                  * NC_ERR_NFILE         no file is open
 287                  * NC_ERR_NDIR          target key is not a directory
 288                  * NC_ERR_NEXIST        target key direcotry does not exist
 289                  */
 290                 int chDir(const char *name);
 291
 292                 /*
 293                  * Print working directory
 294                  * Errors:
 295                  * Returns NULL on error
 296                  */
 297                 const char *pwDir();
 298
 299                 /*
 300                  * List all keys in current/specified directory
 301                  * Result is a NULL-terminated array of nc_ls_s
 302                  * structures.
 303                  * Errors:
 304                  * Returns NULL on error
 305                  * Note:
 306                  * You need to free the returned pointer,
 307                  * as well as all the names in it.
 308                  */
 309                 struct nc_ls_s *ls(const char *dir = NULL);
 310
 311                 /*
 312                  * Lock file
 313                  * This will block until lock becomes available
 314                  * type is either:
 315                  *              NC_L_RO for read-only lock
 316                  *              NC_L_RW for read-write lock
 317                  * No errors defined
 318                  *
 319                  * NOTE: lock may get promoted
 320                  */
 321                 void lockFile(int type, int force = FALSE);
 322
 323                 /*
 324                  * Unlock file
 325                  * No errors defined
 326                  */
 327                 void unLockFile();
 328
 329                 /*
 330                  * Print out (to stderr) information about current file
 331                  * No errors defined
 332                  */
 333                 void status();
 334
 335                 /*
 336                  * Return version string
 337                  */
 338                 static char *version();
 339
 340                 /*
 341                  * Dump current file to XML
 342                  * Errors:
 343                  * NC_ERR_NFILE         no file is open
 344                  * NC_ERR_PERM          could not write XML output
 345                  */
 346                 int toXML(const char *filename);
 347
 348                 /*
 349                  * Load XML to current file
 350                  * a file has to be open
 351                  * force can be
 352                  *      TRUE - existing keys will be deleted
 353                  *      FALSE - import will ignore a key if existing key type conflicts
 354                  * Errors:
 355                  * NC_ERR_NFILE         no file is open
 356                  * NC_ERR_PERM          file is open read-only
 357                  */
 358                 int fromXML(const char *filename, int force = TRUE);
 359
 360 protected:
 361                 int fd, omode, lock, careful;
 362                 char *fname, *data, *cname;
 363                 unsigned lsize, update;
 364                 unsigned revision, olck;
 365                 struct nc_sb_s *sb;
 366                 struct nc_de_s *rdir, *cdir;
 367                 struct nc_chunk_s *chunks;
 368
 369                 int _setKey(const char *, const unsigned, const char *, const unsigned);
 370                 void _delKey(const char *, struct nc_de_s *, int);
 371                 void expand(unsigned);
 372
 373                 void fast_free(unsigned);
 374
 375                 unsigned getChunk(unsigned);
 376                 void freeChunk(unsigned);
 377                 static inline unsigned alignSize(unsigned);
 378
 379                 struct nc_de_s *getDirEnt(const char *, struct nc_de_s * = NULL);
 380                 struct nc_de_s *insert(unsigned, struct nc_de_s *);
 381                 char *canonize(const char *);
 382                 char *getName(const struct nc_de_s *);
 383
 384                 void _remap(const size_t, const size_t);
 385
 386                 inline unsigned crc(const char *, unsigned);
 387                 void store(nc_de_s *, FILE *);
 388                 void restore(void *, int);
 389 };
 390
 391 #endif /* NC_NCONFIG_H */
 392