GDBM(3)

📦 version 1.23, in debian bookworm, ubuntu jammy

🌈 GDBM(3) — GDBM User Reference 🌈

okay so bestie, welcome to GDBM(3), aka the GDBM User Reference. This is the Unix manual page that's about to make key/data storage make sense. It's giving library-of-routines realness, and we're gonna read it together. No cap. 💅

✨ NAME ✨

GDBM — The GNU database manager. Includes dbm and ndbm compatibility. 👑 Periodt.

🌈 SYNOPSIS 🌈

Here's the whole cast of characters, fr fr. All the prototypes, externs, and the crash-tolerance duo. Copy-paste exact, don't touch the spelling, iykyk.

#include <gdbm.h>

extern gdbm_error gdbm_errno;
extern char *gdbm_version;
extern int gdbm_version[3];
GDBM_FILE gdbm_open (const char *name, int block_size,
                     int flags, int mode,
                     void (*fatal_func)(const char *));
int gdbm_close (GDBM_FILE dbf);
int gdbm_store (GDBM_FILE dbf, datum key, datum content, int flag);
datum gdbm_fetch (GDBM_FILE dbf, datum key);
int gdbm_delete (GDBM_FILE dbf, datum key);
datum gdbm_firstkey (GDBM_FILE dbf);
datum gdbm_nextkey (GDBM_FILE dbf, datum key);
int gdbm_recover (GDBM_FILE dbf, gdbm_recovery *rcvr, intflags);
int gdbm_reorganize (GDBM_FILE dbf);
int gdbm_sync (GDBM_FILE dbf);
int gdbm_exists (GDBM_FILE dbf, datum key);
const char *gdbm_strerror (gdbm_error errno);
int gdbm_setopt (GDBM_FILE dbf, int option, int value, int size);
int gdbm_fdesc (GDBM_FILE dbf);
int gdbm_count (GDBM_FILE dbf, gdbm_count_t *pcount);
int gdbm_bucket_count (GDBM_FILE dbf, size_t *pcount);
int gdbm_avail_verify (GDBM_FILE dbf);

💅 Crash Tolerance (see below):

And these two are the crash-tolerance girlies. We'll get to them later, bestie.

int gdbm_failure_atomic (GDBM_FILE dbf, const char *even, const char
*odd);
int gdbm_latest_snapshot (const char *even, const char *odd, const char
**result);

💌 NOTICE 💌

So this manpage? It's a short lil description of the GDBM library. If you want the detailed discussion, examples, and usage recommendations, you gotta go to the GDBM Manual in Texinfo format. To access it, run:

info gdbm

The docs are also online at:

https://www.gnu.org/software/gdbm/manual

And if there's ever a discrepancy between this manpage and the GDBM Manual? Should any discrepancies occur between this manpage and the GDBM Manual, the later shall be considered the authoritative source. No cap. 👑

💖 DESCRIPTION 💖

GNU dbm is a library of routines that manages data files full of key/data pairs. What can it do? Store, retrieve, delete by key, and do a non-sorted traversal of all keys. A process is allowed to use multiple data files at the same time. Iconic behavior. ✨

🎀 Opening a database 🎀

When a process opens a gdbm file, it's designated as a "reader" or a "writer". Only one writer may open a gdbm file, and many readers may open the file. Readers and writers can not open the gdbm file at the same time. That's the vibe check. The procedure for opening a gdbm file is:

GDBM_FILE gdbm_open (const char *name, int block_size,
                     int flags, int mode,
                     void (*fatal_func)(const char *));

Name is the name of the file (the complete name, gdbm does not append any characters to this name). It's literally the whole name, bestie. No extra letters added.

Block_size is the size of a single transfer from disk to memory. If the value is less than 512, the file system block size is used instead. The size is adjusted so that the block can hold exact number of directory entries, so that the effective block size can be slightly greater than requested. This adjustment is disabled if the GDBM_BSEXACT flag is used. So yeah, it might be a tiny bit bigger than you asked. Slay.

The flags parameter is a bitmask, composed of the access mode and one or more modifier flags. The access mode bit designates the process as a reader or writer and must be one of the following:

GDBM_READER — reader
GDBM_WRITER — writer
GDBM_WRCREAT — writer — if database does not exist create new one
GDBM_NEWDB — writer — create new database regardless if one exists

Additional flags (modifiers) can be combined with these values by bitwise OR. Not all of them are meaningful with all access modes. So mix and match responsibly. 💅

Flags that are valid for any value of access mode are:

GDBM_CLOEXEC — Set the close-on-exec flag on the database file descriptor.
GDBM_NOLOCK — Prevents the library from performing any locking on the database file.
GDBM_NOMMAP — Instructs gdbm_open to disable the use of mmap(2).
GDBM_PREREAD — When mapping GDBM file to memory, read its contents immediately, instead of when needed (prefault reading). This can be advantageous if you open a read-only database and are going to do a lot of look-ups on it. In this case entire database will be read at once and searches will operate on an in-memory copy. In contrast, GDBM_PREREAD should not be used if you open a database (even in read-only mode) only to retrieve a couple of keys.

Finally, never use GDBM_PREREAD when opening a database for updates, especially for inserts: this will degrade performance.

This flag has no effect if GDBM_NOMMAP is given, or if the operating system does not support prefault reading. It is known to work on Linux and FreeBSD kernels.

GDBM_XVERIFY — Enable additional consistency checks. With this flag, eventual corruptions of the database are discovered when opening it, instead of when a corrupted structure is read during normal operation. However, on large databases, it can slow down the opening process.

The following additional flags are valid when the database is opened for writing (GDBM_WRITER, GDBM_WRCREAT, or GDBM_NEWDB):

GDBM_SYNC — Causes all database operations to be synchronized to the disk.

NOTE: this option entails severe performance degradation and does not necessarily ensure that the resulting database state is consistent, therefore we discourage its use. For a discussion of how to ensure database consistency with minimal performance overhead, see CRASH TOLERANCE below.

GDBM_FAST — A reverse of GDBM_SYNC: synchronize writes only when needed. This is the default. This flag is provided only for compatibility with previous versions of GDBM.

The following flags can be used together with GDBM_NEWDB. They also take effect when used with GDBM_WRCREAT, if the requested database file doesn't exist:

GDBM_BSEXACT — If this flag is set and the requested block_size value cannot be used, gdbm_open will refuse to create the database. In this case it will set the gdbm_errno variable to GDBM_BLOCK_SIZE_ERROR and return NULL.

Without this flag, gdbm_open will silently adjust the block_size to a usable value, as described above.

GDBM_NUMSYNC — Create new database in extended database format, a format best suited for effective crash recovery. For a detailed discussion, see the CRASH RECOVERY chapter below.

Mode is the file mode (see chmod(2) and open(2)). It is used if the file is created.

Fatal_func is a function to be called when gdbm if it encounters a fatal error. This parameter is deprecated and must always be NULL. So like, don't pass anything else, bestie.

The return value is the pointer needed by all other routines to access that gdbm file. If the return is the NULL pointer, gdbm_open was not successful. In this case, the reason of the failure can be found in the gdbm_errno variable. If the following call returns true (non-zero value):

gdbm_check_syserr(gdbm_open)

the system errno variable must be examined in order to obtain more detail about the failure. Lowkey important.

GDBM_FILE gdbm_fd_open (int FD, const char *name, int block_size,
                        int flags, int mode,
                        void (*fatal_func)(const char *));

This is an alternative entry point to gdbm_open. FD is a valid file descriptor obtained as a result of a call to open(2) or creat(2). The function opens (or creates) a DBM database this descriptor refers to. The descriptor is not dup'ed, and will be closed when the returned GDBM_FILE is closed. Use dup (2) if that is not desirable.

In case of error, the function behaves like gdbm_open and does not close FD. This can be altered by the following value passed in flags:

GDBM_CLOERROR — Close FD before exiting on error.

The rest of arguments are the same as for gdbm_open.

🦋 Calling convention 🦋

All GDBM functions take as their first parameter the database handle (GDBM_FILE), returned from gdbm_open or gdbm_fd_open. That's the main character of every call. 👑

Any value stored in the GDBM database is described by datum, an aggregate type defined as:

typedef struct
{
  char *dptr;
  int   dsize;
} datum;

The dptr field points to the actual data. Its type is char * for historical reasons. Actually it should have been typed void *. Programmers are free to store data of arbitrary complexity, both scalar and aggregate, in this field. So go off, store whatever.

The dsize field contains the number of bytes stored in dptr.

The datum type is used to describe both keys and content (values) in the database. Values of this type can be passed as arguments or returned from GDBM function calls.

GDBM functions that return datum indicate failure by setting its dptr field to NULL.

Functions returning integer value, indicate success by returning 0 and failure by returning a non-zero value (the only exception to this rule is gdbm_exists, for which the return value is reversed). Yes, gdbm_exists is the rebel. 💅

If the returned value indicates failure, the gdbm_errno variable contains an integer value indicating what went wrong. A similar value is associated with the dbf handle and can be accessed using the gdbm_last_errno function. Immediately after return from a function, both values are exactly equal. Subsequent GDBM calls with another dbf as argument may alter the value of the global gdbm_errno, but the value returned by gdbm_last_errno will always indicate the most recent code of an error that occurred for that particular database. Programmers are encouraged to use such per-database error codes. Per-database? Obsessed.

Sometimes the actual reason of the failure can be clarified by examining the system errno value. To make sure its value is meaningful for a given GDBM error code, use the gdbm_check_syserr function. The function takes error code as argument and returns 1 if the errno is meaningful for that error, or 0 if it is irrelevant.

Similarly to gdbm_errno, the latest errno value associated with a particular database can be obtained using the gdbm_last_syserr function.

The gdbm_clear_error clears the error indicator (both GDBM and system error codes) associated with a database handle.

Some critical errors leave the database in a structurally inconsistent state. If that happens, all subsequent GDBM calls accessing that database will fail with the GDBM error code of GDBM_NEED_RECOVERY (a special function gdbm_needs_recovery is also provided, which returns true if the database handle given as its argument is structurally inconsistent). To return such databases to consistent state, use the gdbm_recover function (see below). So yeah, if you see GDBM_NEED_RECOVERY, it's giving broken, and you need to recover.

The GDBM_NEED_RECOVERY error cannot be cleared using gdbm_clear_error. Periodt.

✨ Error functions ✨

okay bestie this is where GDBM tells you what went wrong, and honestly? it's giving very transparent, very communicative, we love that for us 💅

gdbm_error gdbm_last_errno (GDBM_FILE dbf) — hands you the error code of the most recent fail that happened while operating on dbf.
int gdbm_last_syserr (GDBM_FILE dbf) — gives you the value of the system errno variable tied to the most recent failure that went down on dbf.
int gdbm_check_syserr (gdbm_error err) — returns 1 if you should actually go check the system errno value to get more info about the error described by GDBM code err.
void gdbm_clear_error (GDBM_FILE dbf) — wipes the error state for the database dbf. This one gets called implicitly the moment you enter any GDBM function that operates on a GDBM_FILE, so it's kinda doing its thing behind the scenes 🫶
int gdbm_needs_recovery (GDBM_FILE dbf) — returns 1 if the database file dbf is in an inconsistent state and needs recovery. not the vibe we want, but at least she tells us 😭
const char *gdbm_strerror (gdbm_error err) — returns a textual description of the error code err.
const char *gdbm_db_strerror (GDBM_FILE dbf) — returns a textual description of the recent error in database dbf. This description includes the system errno value, if relevant.

lowkey important: not every gdbm_error code has a relevant system error code attached. Use gdbm_check_syserr to figure out if a given code has one. fr fr, don't skip that step.

also, plot twist: the GDBM_NEED_RECOVERY error cannot be cleared. periodt, she stays.

✨ Closing the database ✨

bestie, listen — it is important that every database file you open also gets closed. like, actually important. You need this to update the reader/writer count on the file. Here's how you do it:

int gdbm_close (GDBM_FILE dbf);

✨ Database lookups ✨

int gdbm_exists (GDBM_FILE dbf, datum key) — if the key is found in the database, the return value is true (1). If nothing appropriate is found, false (0) comes back and gdbm_errno is set to GDBM_NO_ERROR. On error, it returns 0 and sets gdbm_errno.
datum gdbm_fetch (GDBM_FILE dbf, datum key) — dbf is the pointer returned by gdbm_open, and key is the key data.

If the dptr element of the return value is NULL, go examine the gdbm_errno variable. A value of GDBM_ITEM_NOT_FOUND means no data was found for that key. Any other value means an error happened.

Otherwise the return value is a pointer to the found data ✨. The storage space for the dptr element is allocated using malloc(3). GDBM does not automatically free this data — it is the programmer's responsibility to free this storage when it's no longer needed. so like, clean up after yourself, bestie 🧹

✨ Iterating over the database ✨

These next two routines let you iterate over all the items in the database. Heads up: this iteration is not key sequential, but it is guaranteed to visit every key in the database exactly once. (The order has to do with the hash values.)

datum gdbm_firstkey (GDBM_FILE dbf) — returns the first key in the database.
datum gdbm_nextkey (GDBM_FILE dbf, datum key) — given a key, returns the database key that follows it. End of iteration is marked by returning a datum with the dptr field set to NULL and setting the gdbm_errno value to GDBM_ITEM_NOT_FOUND.

After a successful return from both functions, dptr points to data allocated by malloc(3). It is the caller's responsibility to free the data when it's no longer needed. no cap.

A typical iteration loop looks like this, and she's iconic:

datum key, nextkey, content;
key = gdbm_firstkey (dbf);
while (key.dptr)
  {
    content = gdbm_fetch (dbf, key);
    /* Do something with key and/or content */
    nextkey = gdbm_nextkey (dbf, key);
    free (key.dptr);
    key = nextkey;
  }

These functions are intended to visit the database in read-only algorithms. Avoid any database modifications within the iteration loop. 🚨 File visiting is based on a hash table, and gdbm_delete and, in most cases, gdbm_store, rearrange the hash table to make sure that any collisions in the table don't leave some item un-findable. So a call to either of these functions changes the order in which the keys are ordered. Therefore, these functions should not be used when iterating over all the keys in the database.

For example, the following loop is wrong — it's possible that some keys won't be visited, or will be visited twice, if it's executed:

key = gdbm_firstkey (dbf);
while (key.dptr)
  {
    nextkey = gdbm_nextkey (dbf, key);
    if (some condition)
      gdbm_delete ( dbf, key );
    free (key.dptr);
    key = nextkey;
  }

not me showing you the exact anti-pattern 💀 don't do this one, bestie. she is a cautionary tale.

✨ Updating the database ✨

int gdbm_store (GDBM_FILE dbf, datum key, datum content, int flag) — dbf is the pointer returned by gdbm_open. key is the key data. content is the data to be associated with the key. flag can have one of the following values:
- GDBM_INSERT — insert only, generate an error if the key exists;
- GDBM_REPLACE — replace contents if the key exists.

The function returns 0 on success and -1 on failure. If the key already exists in the database and the flag is GDBM_INSERT, the function does not modify the database. It sets gdbm_errno to GDBM_CANNOT_REPLACE and returns 1. sneaky little 1, but okay 👑

int gdbm_delete (GDBM_FILE dbf, datum key) — looks up and deletes the given key from the database dbf.

The return value is 0 if there was a successful delete, or -1 on error. In that latter case, the gdbm_errno value GDBM_ITEM_NOT_FOUND indicates that the key is not present in the database. Other gdbm_errno values indicate failure.

✨ Recovering structural consistency ✨

If a function leaves the database in a structurally inconsistent state, it can be recovered using the gdbm_recover function. she's the glow-up arc 🌈

int gdbm_recover (GDBM_FILE dbf, gdbm_recovery * rcvr, int flags) — check the database file DBF and fix eventual inconsistencies. The rcvr argument can be used both to control the recovery and to return additional statistics about the process, as indicated by flags. For a detailed discussion of these arguments and their usage, see the GDBM Manual, chapter Recovering structural consistency.

You can pass NULL as rcvr and 0 as flags, if no such control is needed. easy peasy.

By default, this function first checks the database for inconsistencies and attempts recovery only if some were found. The special flags bit GDBM_RCVR_FORCE instructs gdbm_recovery to skip this check and to perform database recovery unconditionally.

✨ Export and import ✨

GDBM database files can be exported (dumped) to so called flat files or imported (loaded) from them. A flat file contains exactly the same data as the original database, but it cannot be used for searches or updates. Its purpose is to keep the data from the database for restoring it when the need arrives. As such, flat files are used for backup purposes, and for sending databases over the wire. very travel-friendly, we stan a portable file 💖

As of GDBM version 1.21, there are two flat file formats.

The ASCII file format encodes all data in Base64 and stores not only key/data pairs, but also the original database file metadata, such as file name, mode and ownership. Files in this format can be sent without additional encapsulation over transmission channels that normally allow only ASCII data, such as, e.g. SMTP. Due to additional metadata they allow for restoring an exact copy of the database, including file ownership and privileges, which is especially important if the database in question contained some security-related data. This is the preferred format. ✨ main character format fr

Another flat file format is the binary format. It stores only key/data pairs and does not keep information about the database file itself. It cannot be used to copy databases between different architectures. The binary format was introduced in GDBM version 1.9.1 and is retained mainly for backward compatibility.

The following functions are used to export or import GDBM database files.

int gdbm_dump (GDBM_FILE dbf, const char *filename, int format, int open_flag, int mode) — dumps the database file dbf to the file filename in the requested format. Allowed values for format are: GDBM_DUMP_FMT_ASCII, to create an ASCII dump file, and GDBM_DUMP_FMT_BINARY, to create a binary dump.

The value of open_flag tells gdbm_dump what to do if filename already exists. If it is GDBM_NEWDB, the function will create a new output file, replacing it if it already exists. If its value is GDBM_WRCREAT, the file will be created if it does not exist. If it does exist, gdbm_dump will return error.

The file mode to use when creating the output file is defined by the mode parameter. Its meaning is the same as for open(2).

int gdbm_load (GDBM_FILE *pdbf, const char *filename, int flag, int meta_mask, unsigned long *errline) — loads data from the dump file filename into the database pointed to by pdbf. If pdbf is NULL, the function will try to create a new database. On success, the new GDBM_FILE object will be stored in the memory location pointed to by pdbf. If the dump file carries no information about the original database file name, the function will set gdbm_errno to GDBM_NO_DBNAME and return -1, indicating failure. 😭 no name, no game.

Otherwise, if pdbf points to an already open GDBM_FILE, the function will load data from filename into that database.

The flag parameter controls the function behavior if a key from the dump file already exists in the database. See the gdbm_store function for its possible values.

The meta_mask parameter can be used to disable restoring certain bits of the file's meta-data from the information in the input dump file. It is a binary OR of zero or more of the following:

GDBM_META_MASK_MODE — do not restore file mode.
GDBM_META_MASK_OWNER — do not restore file owner.

✨ Other functions ✨

int gdbm_reorganize (GDBM_FILE dbf) — if you have had a lot of deletions and would like to shrink the space used by the GDBM file, this routine will reorganize the database. spring cleaning era 🧹✨
int gdbm_sync (GDBM_FILE dbf) — synchronizes the changes in dbf with its disk file.

It will not return until the disk file state is synchronized with the in-memory state of the database. she waits, she commits, she delivers 🫶

int gdbm_setopt (GDBM_FILE dbf, int option, void *value, int size);

okay bestie, this function is literally the glow-up remote for a database that's already open. It queries or changes some parameter. The option argument tells it what to set or retrieve. If you're setting, value points to the new value, and its actual data type depends on option. If you're getting, value points to a memory region where the return value will be stored. In both cases, size holds the actual size of the memory that value points to.

Possible values of option are:

GDBM_SETCACHESIZE, GDBM_CACHESIZE — Set the size of the internal bucket cache. The value should point to a size_t holding the desired cache size, or the constant GDBM_CACHE_AUTO, to select the best cache size automatically. By default, a newly open database is configured to adapt the cache size to the number of index buckets in the database file. This provides for the best performance. Use this option if you wish to limit the memory usage at the expense of performance. If you chose to do so, please bear in mind that cache becomes effective when its size is greater then 2/3 of the number of index bucket counts in the database. The best performance results are achieved when cache size equals the number of buckets.
GDBM_GETCACHESIZE — Return the size of the internal bucket cache. The value should point to a size_t variable, where the size will be stored.
GDBM_GETFLAGS — Return the flags describing current state of the database. The value should point to an int variable where to store the flags. On success, its value will be similar to the flags used when opening the database, except that it will reflect the current state (which may have been altered by another calls to gdbm_setopt).
GDBM_FASTMODE — Enable or disable the fast writes mode, similar to the GDBM_FAST option to gdbm_open. This option is retained for compatibility with previous versions of GDBM.
GDBM_SETSYNCMODE, GDBM_SYNCMODE — Turn on or off immediate disk synchronization after updates. The value should point to an integer: 1 to turn synchronization on, and 0 to turn it off. NOTE: setting this option entails severe performance degradation and does not necessarily ensure that the resulting database state is consistent, therefore we discourage its use. For a discussion of how to ensure database consistency with minimal performance overhead, see CRASH TOLERANCE below.
GDBM_GETSYNCMODE — Return the current synchronization status. The value should point to an int where the status will be stored.
GDBM_SETCENTFREE, GDBM_CENTFREE — Enable or disable central free block pool. The default is off, which is how previous versions of GDBM handled free blocks. If set, this option causes all subsequent free blocks to be placed in the global pool, allowing (in theory) more file space to be reused more quickly. The value should point to an integer: TRUE to turn central block pool on, and FALSE to turn it off. The GDBM_CENTFREE alias is provided for compatibility with earlier versions.
GDBM_SETCOALESCEBLKS, GDBM_COALESCEBLKS — Set free block merging to either on or off. The default is off, which is how previous versions of GDBM handled free blocks. If set, this option causes adjacent free blocks to be merged. This can become a CPU expensive process with time, though, especially if used in conjunction with GDBM_CENTFREE. The value should point to an integer: TRUE to turn free block merging on, and FALSE to turn it off.
GDBM_GETCOALESCEBLKS — Return the current status of free block merging. The value should point to an int where the status will be stored.
GDBM_SETMAXMAPSIZE — Sets maximum size of a memory mapped region. The value should point to a value of type size_t, unsigned long or unsigned. The actual value is rounded to the nearest page boundary (the page size is obtained from sysconf(_SC_PAGESIZE)).
GDBM_GETMAXMAPSIZE — Return the maximum size of a memory mapped region. The value should point to a value of type size_t where to return the data.
GDBM_SETMMAP — Enable or disable memory mapping mode. The value should point to an integer: TRUE to enable memory mapping or FALSE to disable it.
GDBM_GETMMAP — Check whether memory mapping is enabled. The value should point to an integer where to return the status.
GDBM_GETDBNAME — Return the name of the database disk file. The value should point to a variable of type char**. A pointer to the newly allocated copy of the file name will be placed there. The caller is responsible for freeing this memory when no longer needed.
GDBM_GETBLOCKSIZE — Return the block size in bytes. The value should point to int.

int gdbm_fdesc (GDBM_FILE dbf);

Returns the file descriptor of the database dbf. ✨

🛡️ CRASH TOLERANCE 🛡️

By default GNU dbm does not protect the integrity of its databases from corruption or destruction due to failures such as power outages, operating system kernel panics, or application process crashes. Such failures could damage or destroy the underlying database. yikes, bestie.

Starting with release 1.21 GNU dbm includes a mechanism that, if used correctly, enables post-crash recovery to a consistent state of the underlying database. This mechanism requires OS and filesystem support and must be requested when gdbm is compiled. The crash-tolerance mechanism is a "pure opt-in" feature, in the sense that it has no effects whatsoever except on those applications that explicitly request it. For details, see the chapter Crash Tolerance in the GDBM manual.

🌍 GLOBAL VARIABLES 🌍

gdbm_error gdbm_errno — This variable contains code of the most recent error that occurred. Note, that it is not C variable in the proper sense: you can use its value, assign any value to it, but taking its address will result in syntax error. It is a per-thread memory location.
const char *gdbm_version — A string containing the library version number and build date.
int const gdbm_version_number[3] — This variable contains library version numbers: major, minor, and patchlevel.

🏷️ VERSIONING 🏷️

The version information is kept in two places. The version of the library is kept in the gdbm_version_number variable, described above. Additionally, the header file gdbm.h defines the following macros:

GDBM_VERSION_MAJOR — Major version number.
GDBM_VERSION_MINOR — Minor version number.
GDBM_VERSION_PATCH — Patchlevel number. 0 means no patchlevel.

You can use this to compare whether your header file corresponds to the library the program is linked with.

The following function can be used to compare two version numbers:

int gdbm_version_cmp (int const a[3], int const b[3]);

Compare two version numbers formatted as gdbm_version_number. Return negative number if a is older than b, positive number if a is newer than b, and 0 if they are equal. 💅

🚨 ERROR CODES 🚨

okay bestie, this is the part where we learn what all the sad little error codes mean 😭 every single one, no skips, no cap.

GDBM_NO_ERROR — nothing went wrong. zero drama. the vibes are immaculate ✨
GDBM_MALLOC_ERROR — the memory allocation failed. it's giving "no room at the inn" 💀
GDBM_BLOCK_SIZE_ERROR — set by gdbm_open when the value of its block_size argument is wrong and the GDBM_BSEXACT flag is set. picky picky 💅
GDBM_FILE_OPEN_ERROR — the library could not open a disk file. can be set by gdbm_open, gdbm_fd_open, gdbm_dump and gdbm_load.

peek at the system errno variable for the real tea on what went wrong 🔍

GDBM_FILE_WRITE_ERROR — writing to a disk file failed. can be set by gdbm_open, gdbm_fd_open, gdbm_dump and gdbm_load.

again, check the system errno variable for more detailed diagnostics 📝

GDBM_FILE_SEEK_ERROR — positioning in a disk file failed. can be set by gdbm_open.

yes bestie, errno again. it's always errno 🫶

GDBM_FILE_READ_ERROR — reading from a disk file failed. can be set by gdbm_open, gdbm_dump and gdbm_load.

and you already know — inspect the system errno variable for a more detailed diagnostics 🌸

GDBM_BAD_MAGIC_NUMBER — the file you handed to gdbm_open is not a valid gdbm file: it has a wrong magic number. imposter syndrome but make it a file 🚩
GDBM_EMPTY_DATABASE — the file passed to gdbm_open is not a valid gdbm file: it has zero length. this error gets returned unless the flags argument has the GDBM_NEWDB bit set. it's empty, your honor 😭
GDBM_CANT_BE_READER — set by gdbm_open when it can't lock the file while being called in GDBM_READER mode. no lock, no entry 🔒
GDBM_CANT_BE_WRITER — set by gdbm_open when it can't lock the file while called in writer mode. same energy, different mode 💀
GDBM_READER_CANT_DELETE — set by gdbm_delete if it tried to operate on a database that's open in read-only mode. bestie. it said read-only. respect the boundary 🙅
GDBM_READER_CANT_STORE — set by gdbm_store if it tried to operate on a database open in read-only mode. same vibe, storing edition 📦
GDBM_READER_CANT_REORGANIZE — set by gdbm_reorganize if it tried to operate on a database open in read-only mode. three strikes, one rule 🎀
GDBM_ITEM_NOT_FOUND — the requested item wasn't found. set by gdbm_delete and gdbm_fetch when the requested key value is not in the database. it's not there and it's not coming 😔
GDBM_REORGANIZE_FAILED — gdbm_reorganize couldn't create a temporary database. the reorganization flopped fr fr 😵
GDBM_CANNOT_REPLACE — cannot replace an existing item. set by gdbm_store if the requested key value is found in the database and the flag parameter is not GDBM_REPLACE. it found it, it just refused to touch it 💅
GDBM_MALFORMED_DATA — the input data was malformed in some way. when gdbm_load returns it, that means the input file was not a valid gdbm dump file. when gdbm_store returns it, that means either the key or content parameter had its dptr field set to NULL.

GDBM_ILLEGAL_DATA is an alias for this error code, kept around for backward compatibility 🫶

GDBM_OPT_ALREADY_SET — the requested option can only be set once, and it was already set. as of version 1.21, this error code is no longer used. in prior versions it could have been returned by gdbm_setopt when setting the GDBM_CACHESIZE value. retired queen 👑
GDBM_OPT_BADVAL — the option argument is not valid, or the value argument points to an invalid value, in a call to gdbm_setopt.

GDBM_OPT_ILLEGAL is an alias for this error code, kept for backward compatibility. modern applications should not use it ⚠️

GDBM_BYTE_SWAPPED — gdbm_open is trying to open a database created on a machine with a different byte ordering. endianness said "we are not the same" 😤
GDBM_BAD_FILE_OFFSET — gdbm_open sets this if the file it's trying to open has a wrong magic number. yep, again 🔁
GDBM_BAD_OPEN_FLAGS — set by gdbm_dump if you supplied an invalid flags argument. bad flags, bestie 🚩
GDBM_FILE_STAT_ERROR — getting info about a disk file failed. the system errno will spill more details.

this one can be set by: gdbm_open, gdbm_reorganize 📊

GDBM_FILE_EOF — end of file was hit where more data was supposed to be. this can happen when fetching data from the database, and it usually means the database is truncated or otherwise corrupted 💀

this can be set by any GDBM function that does I/O. some of them are: gdbm_delete, gdbm_exists, gdbm_fetch, gdbm_export, gdbm_import, gdbm_reorganize, gdbm_firstkey, gdbm_nextkey, gdbm_store.

GDBM_NO_DBNAME — the output database name isn't specified. set by gdbm_load if the first argument points to NULL and the input file doesn't specify the database name. no name, no game 🎭
GDBM_ERR_FILE_OWNER — set by gdbm_load if it can't restore the database file owner. it's a mild error condition: the data were restored successfully, only changing the target file owner failed. inspect the system errno variable for more detailed diagnostics 🙈
GDBM_ERR_FILE_MODE — set by gdbm_load if it can't restore the database file mode. also a mild error condition: the data were restored successfully, only changing the target file owner failed. inspect the system errno variable for more detailed diagnostics 🌷
GDBM_NEED_RECOVERY — the database is in an inconsistent state and needs recovery. if you get this, call gdbm_recover 🚑
GDBM_BACKUP_FAILED — the GDBM engine can't create a backup copy of the file. no backup, no safety net 😬
GDBM_DIR_OVERFLOW — the bucket directory would overflow the size limit while attempting to split a hash bucket. this can happen while storing a new key. it's full, it can't take anymore 🫠
GDBM_BAD_BUCKET — an invalid index bucket was encountered in the database. database recovery is needed 🩹
GDBM_BAD_HEADER — set by gdbm_open and gdbm_fd_open if the first block read from the database file doesn't contain a valid GDBM header. the header said "not today" 📄
GDBM_BAD_AVAIL — the available space stack is invalid. can be set by gdbm_open and gdbm_fd_open if extended database verification was requested (GDBM_XVERIFY). it's also set by the gdbm_avail_verify function.

the database needs recovery 🔧

GDBM_BAD_HASH_TABLE — the hash table in a bucket is invalid. can be set by: gdbm_delete, gdbm_exists, gdbm_fetch, gdbm_firstkey, gdbm_nextkey, and gdbm_store.

the database needs recovery 🔧

GDBM_BAD_DIR_ENTRY — a bad directory entry was found in the bucket. the database recovery is needed 🔧
GDBM_FILE_CLOSE_ERROR — gdbm_close couldn't close the database file descriptor. the system errno variable contains the corresponding error code 🚪
GDBM_FILE_SYNC_ERROR — cached content couldn't be synchronized to disk. examine the errno variable to get more info.

database recovery is needed 🔧

GDBM_FILE_TRUNCATE_ERROR — the file can't be truncated. examine the errno variable to get more info.

set by gdbm_open and gdbm_fd_open when called with the GDBM_NEWDB flag ✂️

GDBM_BUCKET_CACHE_CORRUPTED — the bucket cache structure is corrupted. database recovery is needed 🔧
GDBM_BAD_HASH_ENTRY — set during sequential access (@pxref{Sequential}) if the next hash table entry doesn't contain the expected key. this means the bucket is malformed or corrupted, and the database needs recovery 🔧
GDBM_ERR_SNAPSHOT_CLONE — set by gdbm_failure_atomic if it couldn't clone the database file into a snapshot. inspect the system errno variable for the underlying cause of the error. if errno is EINVAL or ENOSYS, crash tolerance settings will be removed from the database 📸
GDBM_ERR_REALPATH — set by gdbm_failure_atomic if the call to the realpath function failed. realpath is used to determine the actual path names of the snapshot files. examine the system errno variable for details 🛣️
GDBM_ERR_USAGE — function usage error. that includes invalid argument values, and the like 🙃

💾 DBM COMPATIBILITY ROUTINES 💾

GDBM comes with a compatibility library called libgdbm_compat, for programs that still expect the traditional UNIX dbm or ndbm interfaces — like, e.g., Sendmail. It's optional, so some binary distributions might not have it at all. 💀

The full detailed discussion of the compatibility API is beyond this document, so below is just a short reference. For details, see the GDBM Manual, chapter Compatibility with standard dbm and ndbm. 📖

🗂️ DBM compatibility routines 🗂️

In dbm compatibility mode, only one file may be opened at a time. All users are assumed to be writers. If the database file is read only, it will fail as a writer, but will be opened as a reader. All returned pointers in datum structures point to data that the compatibility library will free. They should be treated as static pointers (as standard UNIX dbm does). 🫠

The following interfaces are provided:

#include <dbm.h>

int dbminit (const char *name);
int store (datum key, datum content);
datum fetch (datum key);
int delete (datum key);
datum firstkey (void);
datum nextkey (datum key);
int dbmclose (void);

🌸 NDBM Compatibility routines 🌸

In this mode, multiple databases can be opened. Each database is identified by a handle of type DBM *. As in the original NDBM, all returned pointers in datum structures point to data that will be freed by the compatibility library. They should be treated as static pointers. ✨

The following interfaces are provided:

#include <ndbm.h>

DBM *dbm_open (const char *name, int flags, int mode);
void dbm_close (DBM *file);
datum dbm_fetch (DBM *file, datum key);
int dbm_store (DBM *file, datum key, datum content, int flags);
int dbm_delete (DBM *file, datum key);
datum dbm_firstkey (DBM *file);
datum dbm_nextkey (DBM *file, datum key);
int dbm_error (DBM *file);
int dbm_clearerr (DBM *file);
int dbm_pagfno (DBM *file);
int dbm_dirfno (DBM *file);
int dbm_rdonly (DBM *file);

🔗 LINKING 🔗

This library is accessed by specifying -lgdbm as the last parameter to the compile line, e.g.:

gcc -o prog prog.c -lgdbm

If you wish to use the dbm or ndbm compatibility routines, you must link in the gdbm_compat library as well. For example:

gcc -o prog proc.c -lgdbm -lgdbm_compat

🐛 BUG REPORTS 🐛

Send bug reports to <bug-gdbm@gnu.org>. 🫶

👑 AUTHORS 👑

by Philip A. Nelson, Jason Downs and Sergey Poznyakoff; crash tolerance by Terence Kelly. 💅

📜 COPYRIGHT 📜

GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version.

GDBM 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 General Public License for more details.

You should have received a copy of the GNU General Public License along with GDBM. If not, see <http://gnu.org/licenses/gpl.html>

📬 CONTACTS 📬

You may contact the original author by:

   e-mail:  phil@cs.wwu.edu
  us-mail:  Philip A. Nelson
Computer Science Department
Western Washington University
Bellingham, WA 98226

You may contact the current maintainers by:

   e-mail:  downsj@downsj.com
and
   e-mail:  gray@gnu.org

For questions and feedback regarding crash tolerance, you may contact Terence Kelly at:

   e-mail:  tpkelly @ { acm.org, cs.princeton.edu, eecs.umich.edu }

That's a wrap, bestie — this was the GDBM manual, GDBM(3), dated October 18, 2021. Stay slay. 💖✨

📦 where this page comes from

debian bookworm: libgdbm-dev 1.23-3 · GPL-3.0-or-later
ubuntu jammy: libgdbm-dev 1.23-1 · GPL-3.0-or-later
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms