GDBM  - The GNU database manager.  Includes dbm and ndbm compatability.
   (Version 1.8.3.)


   #include <gdbm.h>

   extern gdbm_error

   extern char

   gdbm_open (name, block_size, read_write, mode, fatal_func)
   char * name;
   int block_size, read_write, mode;
   void (*fatal_func) ();

   gdbm_close (dbf)
   GDBM_FILE dbf;

   gdbm_store (dbf, key, content, flag)
   GDBM_FILE dbf;
   datum key, content;
   int flag;

   gdbm_fetch (dbf, key)
   GDBM_FILE dbf;
   datum key;

   gdbm_delete (dbf, key)
   GDBM_FILE dbf;
   datum key;

   gdbm_firstkey (dbf)
   GDBM_FILE dbf;

   gdbm_nextkey (dbf, key)
   GDBM_FILE dbf;
   datum key;

   gdbm_reorganize (dbf)
   GDBM_FILE dbf;

   gdbm_sync (dbf)
   GDBM_FILE dbf;

   gdbm_exists (dbf, key)
   GDBM_FILE dbf;
   datum key;

   char *
   gdbm_strerror (errno)
   gdbm_error errno;

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

   gdbm_fdesc (dbf)
   GDBM_FILE dbf;

   DBM Compatability routines:

   #include <dbm.h>

   dbminit (name)
   char *name;

   store (key, content)
   datum key, content;

   fetch (key)
   datum key;

   delete (key)
   datum key;

   firstkey ()

   nextkey (key)
   datum key;

   dbmclose ()

   NDBM Compatability routines:

   #include <ndbm.h>

   *dbm_open (name, flags, mode)
   char *name;
   int flags, mode;

   dbm_close (file)
   DBM *file;

   dbm_fetch (file, key)
   DBM *file;
   datum key;

   dbm_store (file, key, content, flags)
   DBM *file;
   datum key, content;
   int flags;

   dbm_delete (file, key)
   DBM *file;
   datum key;

   dbm_firstkey (file)
   DBM *file;

   dbm_nextkey (file)
   DBM *file;

   dbm_error (file)
   DBM *file;

   dbm_clearerr (file)
   DBM *file;

   dbm_pagfno (file)
   DBM *file;

   dbm_dirfno (file)
   DBM *file;

   dbm_rdonly (file)
   DBM *file;


   GNU dbm is a library of routines that manages data files  that  contain
   key/data pairs.  The access provided is that of storing, retrieval, and
   deletion by key and a non-sorted traversal of all keys.  A  process  is
   allowed to use multiple data files at the same time.

   A  process  that  opens  a  gdbm  file is 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. The procedure for opening a gdbm file is:

     GDBM_FILE dbf;

     dbf = gdbm_open ( name, block_size, read_write, mode, fatal_func )

   Name is the name of the file (the complete name, gdbm does  not  append
   any  characters  to  this  name).   Block_size  is the size of a single
   transfer from disk to memory. This parameter is ignored unless the file
   is  a  new file.  The minimum size is 512.  If it is less than 512, dbm
   will use the stat block size for the file system.  Read_write can  have
   one of the following values:
   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
   For the last three (writers of the database) the following may be added
   added to read_write by bitwise or: GDBM_SYNC, which causes all database
   operations  to  be  synchronized  to  the  disk, and GDBM_NOLOCK, which
   prevents the library from performing any locking on the database  file.
   The  option  GDBM_FAST  is now obsolete, since gdbm defaults to no-sync
   Mode is the file mode  (see  chmod(2)  and  open(2))  if  the  file  is
   created. (*Fatal_func) () is a function for dbm to call if it detects a
   fatal error. The only parameter of this function is a string.   If  the
   value of 0 is provided, gdbm will use a default function.

   The  return  value  dbf  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.   The  errors can be found in gdbm_errno for gdbm
   errors  and  in  errno  for  system  errors.   (For  error  codes,  see

   In  all of the following calls, the parameter dbf refers to the pointer
   returned from gdbm_open.

   It is important that every file opened is also closed.  This is  needed
   to update the reader/writer count on the file.  This is done by:

     gdbm_close (dbf);

   The  database  is used by 3 primary routines.  The first stores data in
   the database.

     ret = gdbm_store ( dbf, key, content, 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 key exists
   GDBM_REPLACE replace contents if key exists.

   If a reader calls gdbm_store, the return value will be -1.   If  called
   with  GDBM_INSERT  and key is in the database, the return value will be
   1.  Otherwise, the return value is 0.

   NOTICE: If you store data for a key that is already in the  data  base,
   gdbm   replaces  the  old  data  with  the  new  data  if  called  with
   GDBM_REPLACE.  You do not get two data items for the same key  and  you
   do not get an error from gdbm_store.

   NOTICE: The size in gdbm is not restricted like dbm or ndbm.  Your data
   can be as large as you want.

   To search for some data:

     content = gdbm_fetch ( dbf, key )

   Dbf is the pointer returned by gdbm_open.  Key is the key data.

   If the dptr element of the return value is NULL,  no  data  was  found.
   Otherwise the return value is a pointer to the found data.  The storage
   space for the dptr element is allocated using  malloc(3C).   Gdbm  does
   not   automatically   free   this   data.    It   is  the  programmer's
   responsibility to free this storage when it is no longer needed.

   To search for some data, without retrieving it:

     ret = gdbm_exists ( dbf, key )

   Dbf is the pointer returned by gdbm_open.   Key  is  the  key  data  to
   search for.

   If  the  key is found within the database, the return value ret will be
   true.  If nothing appropiate is found, ret will be false.  This routine
   is  useful  for  checking  for  the  existance  of  a  record,  without
   performing the memory allocation done by gdbm_fetch.

   To remove some data from the database:

     ret = gdbm_delete ( dbf, key )

   Dbf is the pointer returned by gdbm_open.  Key is the key data.

   The return value is -1 if the item is not present or the requester is a
   reader.  The return value is 0 if there was a successful delete.

   The  next  two  routines allow for accessing all items in the database.
   This access is not key sequential, but it is guaranteed to visit  every
   key in the database once.  (The order has to do with the hash values.)

     key = gdbm_firstkey ( dbf )

     nextkey = gdbm_nextkey ( dbf, key )

   Dbf is the pointer returned by gdbm_open. Key is the key data.

   The  return  values are both of type datum.  If the dptr element of the
   return value is NULL, there is no first key or next key.  Again  notice
   that dptr points to data allocated by malloc(3C) and gdbm will not free
   it for you.

   These functions were  intended  to  visit  the  database  in  read-only
   algorithms,   for   instance,  to  validate  the  database  or  similar

   File `visiting' is based on a `hash  table'.   gdbm_delete  re-arranges
   the  hash  table  to  make sure that any collisions in the table do not
   leave  some  item  `un-findable'.   The  original  key  order  is   NOT
   guaranteed  to  remain unchanged in ALL instances.  It is possible that
   some key will not be visited if a loop like the following is 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;

   The following routine should be used very infrequently.

     ret = gdbm_reorganize ( 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.  Gdbm
   will not shorten the length  of  a  gdbm  file  except  by  using  this
   reorganization.  (Deleted file space will be reused.)

   Unless  your database was opened with the GDBM_SYNC flag, gdbm does not
   wait for writes to be flushed  to  the  disk  before  continuing.   The
   following  routine  can  be  used  to  guarantee  that  the database is
   physically written to the disk file.

     gdbm_sync ( dbf )

   It will not return until the disk file state is  syncronized  with  the
   in-memory state of the database.

   To convert a gdbm error code into English text, use this routine:

     ret = gdbm_strerror ( errno )

   Where  errno  is  of  type  gdbm_error,  usually  the  global  variable
   gdbm_errno.  The appropiate phrase is returned.

   Gdbm now supports the ability to set certain options on an already open

     ret = gdbm_setopt ( dbf, option, value, size )

   Where  dbf  is  the return value from a previous call to gdbm_open, and
   option specifies which option to set.  The valid options are currently:

     GDBM_CACHESIZE - Set the size of the internal bucket
     cache. This option may only be set once on each GDBM_FILE
     descriptor, and is set automatically to 100 upon the first
     access to the database.

     GDBM_FASTMODE - Set fast mode to either on or off.  This
     allows fast mode to be toggled on an already open and
     active database. value (see below) should be set to either
     TRUE or FALSE.  This option is now obsolete.

     GDBM_SYNCMODE  -  Turn  on  or  off   file   system   synchronization
     This  setting  defaults  to  off;  value (see below) should be set to
     TRUE or FALSE.

     GDBM_CENTFREE - Set central free block pool to either on or off.
     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 thoery)
     more file space to be reused more quickly. value (see below) should
     be set to either TRUE or FALSE.
     NOTICE: This feature is still under study.

     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,
     especially if used in conjunction with GDBM_CENTFREE. value
     (see below) should be set to either TRUE or FALSE.
     NOTICE: This feature is still under study.

   value  is  the value to set option to, specified as an integer pointer.
   size is the size of the data pointed to by  value.   The  return  value
   will  be  -1  upon  failure,  or  0  upon success.  The global variable
   gdbm_errno will be set upon failure.

   For instance, to set a database to use a cache of 10, after opening  it
   with  gdbm_open,  but  prior  to accessing it in any way, the following
   code could be used:

     int value = 10;

     ret = gdbm_setopt( dbf, GDBM_CACHESIZE, &value, sizeof(int));

   If the database was opened with the GDBM_NOLOCK flag, the user may wish
   to  perform  their  own  file  locking on the database file in order to
   prevent multiple writers operating on the same file simultaneously.

   In order to support this, the gdbm_fdesc routine is provided.

     ret = gdbm_fdesc ( dbf )

   Where dbf is the return value from a previous call to  gdbm_open.   The
   return value will be the file descriptor of the database.

   The following two external variables may be useful:

   gdbm_errno  is  the  variable that contains more information about gdbm
   errors.  (gdbm.h has the definitions of the error  values  and  defines
   gdbm_errno as an external variable.)
   gdbm_version is the string containing the version information.

   There  are  a  few  more things of interest.  First, gdbm files are not
   "sparse".  You can copy them with the UNIX cp(1) command and they  will
   not expand in the copying process.  Also, there is a compatibility mode
   for use with programs that already use UNIX dbm.  In this compatibility
   mode,  no gdbm file pointer is required by the programmer, and only one
   file may be opened at a time.  All  users  in  compatibility  mode  are
   assumed  to  be writers.  If the gdbm file is a read only, it will fail
   as a writer, but will also try to open it as a  reader.   All  returned
   pointers  in  datum structures point to data that gdbm WILL free.  They
   should be treated as static pointers (as standard UNIX dbm does).


   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



   dbm, ndbm


   by Philip A. Nelson and Jason Downs.  Copyright (C) 1990  -  1999  Free
   Software Foundation, Inc.

   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

   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; see the file COPYING.  If not, write to  the  Free  Software
   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

   You may contact the original author by:
     us-mail:  Philip A. Nelson
   Computer Science Department
   Western Washington University
   Bellingham, WA 98226

   You may contact the current maintainer by:

                              10/15/2002                           GDBM(3)


Personal Opportunity - Free software gives you access to billions of dollars of software at no cost. Use this software for your business, personal use or to develop a profitable skill. Access to source code provides access to a level of capabilities/information that companies protect though copyrights. Open source is a core component of the Internet and it is available to you. Leverage the billions of dollars in resources and capabilities to build a career, establish a business or change the world. The potential is endless for those who understand the opportunity.

Business Opportunity - Goldman Sachs, IBM and countless large corporations are leveraging open source to reduce costs, develop products and increase their bottom lines. Learn what these companies know about open source and how open source can give you the advantage.

Free Software

Free Software provides computer programs and capabilities at no cost but more importantly, it provides the freedom to run, edit, contribute to, and share the software. The importance of free software is a matter of access, not price. Software at no cost is a benefit but ownership rights to the software and source code is far more significant.

Free Office Software - The Libre Office suite provides top desktop productivity tools for free. This includes, a word processor, spreadsheet, presentation engine, drawing and flowcharting, database and math applications. Libre Office is available for Linux or Windows.

Free Books

The Free Books Library is a collection of thousands of the most popular public domain books in an online readable format. The collection includes great classical literature and more recent works where the U.S. copyright has expired. These books are yours to read and use without restrictions.

Source Code - Want to change a program or know how it works? Open Source provides the source code for its programs so that anyone can use, modify or learn how to write those programs themselves. Visit the GNU source code repositories to download the source.


Study at Harvard, Stanford or MIT - Open edX provides free online courses from Harvard, MIT, Columbia, UC Berkeley and other top Universities. Hundreds of courses for almost all major subjects and course levels. Open edx also offers some paid courses and selected certifications.

Linux Manual Pages - A man or manual page is a form of software documentation found on Linux/Unix operating systems. Topics covered include computer programs (including library and system calls), formal standards and conventions, and even abstract concepts.