path: root/plugins/LotusNotify/src/cnotesapi/include/nsfdb.h

#if defined(OS400) && (__OS400_TGTVRM__ >= 510)
#pragma datamodel(P128)
#endif

/*********************************************************************/
/*                                                                   */
/* Licensed Materials - Property of IBM                              */
/*                                                                   */
/* L-GHUS-5RWNHM, L-GHUS-5RWNFH                                      */
/* (C) Copyright IBM Corp. 1989, 2005  All Rights Reserved           */
/*                                                                   */
/* US Government Users Restricted Rights - Use, duplication or       */
/* disclosure restricted by GSA ADP Schedule Contract with           */
/* IBM Corp.                                                         */
/*                                                                   */
/*********************************************************************/


#ifndef NSF_DB_DEFS
#define NSF_DB_DEFS

#ifndef NSF_DEFS
#include "nsfdata.h"
#endif

#ifndef EVENT_DEFS
#include "event.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif


/* Note Storage File Database Definitions */

/*	NSF File Information Buffer size.  This buffer is defined to contain
	Text (host format) that is NULL-TERMINATED.  This is the ONLY null-terminated
	field in all of NSF. */

#define	NSF_INFO_SIZE 128
#define NSF_INFO_WILD_CARD_SERVER_CHAR '*'

/*  Define NSFDbOpenExtended option bits.  These bits select individual
	open options. */

#define DBOPEN_WITH_SCAN_LOCK		0x0001	/* Open with scan lock to prevent
												other opens with scan lock
												(used by replicator) */
#define DBOPEN_PURGE				0x0002	/* DbPurge while opening */
#define DBOPEN_NO_USERINFO			0x0004	/* No user info may be available, so don't ask for it */
#define DBOPEN_FORCE_FIXUP			0x0008	/* Force a database fixup */
#define DBOPEN_FIXUP_FULL_NOTE_SCAN	0x0010	/* Scan all notes and all items (not incremental) */
#define DBOPEN_FIXUP_NO_NOTE_DELETE	0x0020	/* Do not delete bad notes during note scan */
#define DBOPEN_CLUSTER_FAILOVER		0x0080	/* If open fails try cluster failover */
#define DBOPEN_CLOSE_SESS_ON_ERROR	0x0100	/* Close session on error paths */
#define DBOPEN_NOLOG				0x0200	/* don't log errors - used when opening log database! */
/* Define NSFDB2GetInfo infotypes */
#define DB2NSF_INFO_IS_DB2_BACKED 			1	/* Is database DB2-backed: 1/0 */
#define DB2NSF_INFO_SCHEMA_NAME				2	/* Group schema containing NSFDB2 data */
#define DB2NSF_INFO_TABLESPACE_NAME			3	/* Tablespace name */
#define DB2NSF_INFO_TSID                    4   /* Tablespace ID */
#define DB2NSF_INFO_USERSCHEMA_NAME         5   /* Schema containing DAVs */
#define DB2NSF_INFO_CLASS_DESC              6   /* NSFDB2 grouping class description */

/* Define NSFDB2GetServerInfo infotypes */
#define DB2NSF_SERVINFO_SERVER_DEFAULT_TYPE	1	/* Server default type:  'DB2' or 'NSF' */
#define DB2NSF_SERVINFO_NSFDB2_CAPABLE      2   /* Can Domino serve NSFDB2 data?        */
#define DB2NSF_SERVINFO_DB2_DATABASE_NAME   3

#define DBCOMPACT_NO_INDEXES			0x00000001	/* Don't preserve view indexes */
#define DBCOMPACT_NO_LOCKOUT			0x00000002	/* Don't lock out database users */
#define DBCOMPACT_REVERT_ODS			0x00000004	/* Revert current ODS to the previous ODS version */
#define DBCOMPACT_MAX_4GB				0x00000020	/* Create new file with 4GB file size limit */
#define DBCOMPACT_MAILBOX				0x00000080	/* Compact XXXX.BOX for mail router and other MTAs */
#define DBCOMPACT_NO_INPLACE			0x00000100	/* Don't do in-place compaction */
#define DBCOMPACT_DISABLE_UNREAD		0x00002000	/* Disable unread marks in destination database */
#define DBCOMPACT_ENABLE_UNREAD			0x00004000	/* Reenable unread marks in destination database (default) */
#define DBCOMPACT_DISABLE_RESPONSE_INFO	0x00008000	/* Disable response info in resulting database */
#define DBCOMPACT_ENABLE_RESPONSE_INFO	0x00010000	/* Disable response info in resulting database (default) */
#define DBCOMPACT_ENABLE_FORM_BKT_OPT	0x00020000	/* Enable form/bucket bitmap optimization */
#define DBCOMPACT_DISABLE_FORM_BKT_OPT	0x00040000	/* Diable form/bucket bitmap optimization (default) */
#define	DBCOMPACT_IGNORE_ERRORS			0x00080000	/* Ignore errors encountered during compaction.  That is,
														make best effort to get something at the end */
#define DBCOMPACT_RECOVER_SPACE_ONLY	0x00400000	/* If set, do only bitmap correction if in-place can be done */
#define DBCOMPACT_ARCHIVE				0x00800000  /* Archive/delete, then compact the database */
#define DBCOMPACT_ARCHIVE_ONLY        	0x01000000  /* Just archive/delete, no need to compact */
#define DBCOMPACT_RECOVER_ALL_SPACE		0x04000000	/* If set, always do full space recovery compaction */

/*	Define NSF DB Classes - These all begin with 0xf000 for no good
	reason other than to ENSURE that callers of NSFDbCreate call the
	routine with valid parameters, since in earlier versions of NSF
	the argument to the call was typically 0. */

#define	DBCLASS_BY_EXTENSION	0	/* automatically figure it out */

#define	DBCLASS_NSFTESTFILE			0xff00
#define	DBCLASS_NOTEFILE			0xff01
#define	DBCLASS_DESKTOP				0xff02
#define	DBCLASS_NOTECLIPBOARD		0xff03
#define	DBCLASS_TEMPLATEFILE		0xff04
#define	DBCLASS_GIANTNOTEFILE		0xff05
#define	DBCLASS_HUGENOTEFILE		0xff06
#define	DBCLASS_ONEDOCFILE			0xff07	/* Not a mail message */
#define	DBCLASS_V2NOTEFILE			0xff08
#define	DBCLASS_ENCAPSMAILFILE		0xff09	/* Specifically used by alt mail */
#define	DBCLASS_LRGENCAPSMAILFILE	0xff0a	/* Specifically used by alt mail */
#define	DBCLASS_V3NOTEFILE			0xff0b
#define	DBCLASS_OBJSTORE			0xff0c	/* Object store */
#define DBCLASS_V3ONEDOCFILE		0xff0d
#define	DBCLASS_V4NOTEFILE			0xff0e
#define	DBCLASS_V5NOTEFILE			0xff0f
#define	DBCLASS_V6NOTEFILE			0xff10

#define	DBCLASS_MASK			0x00ff
#define	DBCLASS_VALID_MASK		0xff00

/*	Define NSF Special Note ID Indices.  The first 16 of these are reserved
	for "default notes" in each of the 16 note classes.  In order to access
	these, use SPECIAL_ID_NOTE+NOTE_CLASS_XXX.  This is generally used
	when calling NSFDbGetSpecialNoteID. NOTE: NSFNoteOpen, NSFDbReadObject
	and NSFDbWriteObject support reading special notes or objects directly
	(without calling NSFDbGetSpecialNoteID).  They use a DIFFERENT flag
	with a similar name: NOTE_ID_SPECIAL (see nsfnote.h).  Remember this
	rule:

	SPECIAL_ID_NOTE is a 16 bit mask and is used as a NoteClass argument.
	NOTE_ID_SPECIAL is a 32 bit mask and is used as a NoteID or RRV argument.
*/

#define	SPECIAL_ID_NOTE			0x8000	/* use in combination w/NOTE_CLASS 
											when calling NSFDbGetSpecialNoteID */
/*	Get/Set DbOption routines */
STATUS LNPUBLIC NSFDbGetOptions (DBHANDLE hDB, DWORD far *retDbOptions);
STATUS LNPUBLIC NSFDbSetOptions (DBHANDLE hDB, DWORD DbOptions, DWORD Mask);
#define	DBOPTION_FT_INDEX			0x00000001	/* Enable full text indexing */
#define DBOPTION_IS_OBJSTORE		0x00000002	/* TRUE if database is being used
												   as an object store - for garbage collection */
#define DBOPTION_USES_OBJSTORE		0x00000004	/* TRUE if database has notes which refer to an
												   object store - for garbage collection*/
#define DBOPTION_OBJSTORE_NEVER		0x00000008	/* TRUE if NoteUpdate of notes in this db should
												   never use an object store. */
#define DBOPTION_IS_LIBRARY			0x00000010  /* TRUE if database is a library */
#define DBOPTION_UNIFORM_ACCESS		0x00000020	/* TRUE if uniform access control
												   across all replicas */
#define DBOPTION_OBJSTORE_ALWAYS	0x00000040	/* TRUE if NoteUpdate of notes in this db should
												   always try to use an object store. */
#define DBOPTION_NO_BGAGENT			0x00000200	/* TRUE if db has no background agent */
#define DBOPTION_OUT_OF_SERVICE		0x00000400	/* TRUE is db is out-of-service, no new opens allowed. */
#define DBOPTION_IS_PERSONALJOURNAL	0x00000800	/* TRUE if db is personal journal */
#define DBOPTION_MARKED_FOR_DELETE	0x00001000	/* TRUE if db is marked for delete.  no new opens allowed,
													cldbdir will delete the database when ref count = 0 */
#define DBOPTION_HAS_CALENDAR		0x00002000	/* TRUE if db stores calendar events */
#define DBOPTION_IS_CATALOG_INDEX	0x00004000	/* TRUE if db is a catalog index */
#define DBOPTION_IS_ADDRESS_BOOK	0x00008000	/* TRUE if db is an address book */
#define DBOPTION_IS_SEARCH_SCOPE	0x00010000	/* TRUE if db is a "multi-db-search" repository */
#define DBOPTION_IS_UA_CONFIDENTIAL	0x00020000	/* TRUE if db's user activity log is confidential, only
												*  		viewable by designer and manager */
#define DBOPTION_RARELY_USED_NAMES	0x00040000	/* TRUE if item names are to be treated as
												*  if the ITEM_RARELY_USED_NAME flag is set. */
#define DBOPTION_IS_SITEDB			0x00080000	/* TRUE if db is a "multi-db-site" repository */
/*	This is the structure used for the Item Definition Table */

typedef struct {
	WORD Length;				/* total length of this buffer */
	WORD Items;					/* number of items in the table */
								/* now come the ITEM_DEFINITION structures */
								/* now comes the packed text */
} ITEM_DEFINITION_TABLE;

typedef struct {
	WORD Spare;					/* Spare */
	WORD ItemType;				/* default data type of the item */
	WORD NameLength;			/* length of the item's name */
} ITEM_DEFINITION;

/*	Database Activity Structure */

typedef struct {
	TIMEDATE First;				/* Beginning of reporting period */
	TIMEDATE Last;				/* End of reporting period */
	DWORD Uses;					/* # of uses in reporting period */
	DWORD Reads;				/* # of reads in reporting period */
	DWORD Writes;				/* # of writes in reporting period */
	DWORD PrevDayUses;			/* # of uses in previous 24 hours */
	DWORD PrevDayReads;			/* # of reads in previous 24 hours */
	DWORD PrevDayWrites;		/* # of writes in previous 24 hours */
	DWORD PrevWeekUses;			/* # of uses in previous week */
	DWORD PrevWeekReads;		/* # of reads in previous week */
	DWORD PrevWeekWrites;		/* # of writes in previous week */
	DWORD PrevMonthUses;		/* # of uses in previous month */
	DWORD PrevMonthReads;		/* # of reads in previous month */
	DWORD PrevMonthWrites;		/* # of writes in previous month */
} DBACTIVITY;

typedef struct {
	TIMEDATE Time;				/* Time of record */
	WORD Reads;					/* # of data notes read */
 	WORD Writes;				/* # of data notes written */
	DWORD UserNameOffset;		/* Offset of the user name from the beginning
								   of this memory block */
								/* User names follow -- '\0' terminated */	
} DBACTIVITY_ENTRY;

#define NSFDbGetActivityUserNamePtr(DbActivity, Index) 	\
				(((char FAR *) DbActivity) + DbActivity[Index].UserNameOffset)

/*	Define NSF DB open modes */

#define DB_LOADED 1					/* hDB refers to a normal database file */
#define DB_DIRECTORY 2				/* hDB refers to a "directory" and not a file */

/*	Define argument to NSFDbInfoParse/Modify to manipulate components from DbInfo */

#define INFOPARSE_TITLE			0
#define INFOPARSE_CATEGORIES	1
#define INFOPARSE_CLASS			2
#define INFOPARSE_DESIGN_CLASS	3


/* 	Array entry returned from NSFDbGetReplHistorySummary */

typedef struct {
	TIMEDATE		ReplicationTime;	/*	Time returned from last replciation */
	WORD			AccessLevel;		/*	Access level at time of replication */
	WORD			AccessFlags;		/*	Access flags at time of replication */
	WORD			Direction;			/*	NEVER, SEND, RECEIVE */
	DWORD			ServerNameOffset;	/*	Server name offset in packed data */
	WORD			ServerNameLength;	/*	Server name length in packed data */
	WORD			FileNameLength;		/*	File name length in packed data */
										/*	Total server!!file length is */ 
										/*	ServerNameLength + FileNameLength + 2 */
										/*	to compensate for the !! separator */
	WORD			MoreInfo;			/*	contains MoreInfo from cache - includes complete replication flag */
	WORD			wSpare;				/*	Room for growth */
	DWORD			dwSpare;			/*	Room for growth */
										/*	Server/file name pairs follow as */
										/*	"<server name>!!<file name>" with */
										/*	NULL after each pairing */
} REPLHIST_SUMMARY;

/*	Types for REPLHISTORY.Direction */

#define	DIRECTION_NEVER		0
#define	DIRECTION_SEND		1
#define	DIRECTION_RECEIVE	2

/*	Macros for accessing packed data following the REPLHISTORY_SUMMARY array.

	NOTE: The server name pointer is NOT null-terminated, but the file name
	pointer is.  This is so the caller can use the "server file" string 
	directly.
*/

#define NSFGetSummaryServerNamePtr(Summary, Index) 	\
				(((char FAR *) Summary) + Summary[Index].ServerNameOffset)
#define NSFGetSummaryFileNamePtr(Summary, Index) 	\
				(((char FAR *) Summary) + Summary[Index].ServerNameOffset + \
					Summary[Index].ServerNameLength + 2)

/*	Option flags for NSFDbGetReplHistorySummary */

#define REPLHIST_REMOVE_WILDCARDS	0x00000001L	/*	Don't copy wild card entries */
#define REPLHIST_SORT_BY_DATE		0x00000002L	/*	Sort by date.  Default is
													by server name */
#define REPLHIST_ONLY_COMPLETE		0x00000004L	/*	Only return complete entries */

/*	Structure returned from NSFDbGetMajMinVersion

	NOTE:	For release 5.0.4a, the values would be:

				MajorVersion = 5
				MinorVersion = 0
				QMRNumber	 = 4
				QMUNumber	 = 1

*/
typedef struct {
	DWORD	MajorVersion;						/*	Major version identifier */
	DWORD	MinorVersion;						/*	Minor version identifier */
	DWORD	QMRNumber;							/*	Maintenance Release identifier */
	DWORD	QMUNumber;							/*	Maintenance Update identifier */
	DWORD	HotfixNumber;						/*	Hotfixes installed on machine */	
	DWORD	Flags;								/*	See BUILDVERFLAGS_xxx */
	DWORD	FixpackNumber;						/*	Fixpack version installed on machine */
	DWORD	Spare[2];							/*	Room for growth */
	} BUILDVERSION;

/*	Flags returned in the 'Flags' section of the BUILDVERSION structure */
#define BLDVERFLAGS_NONPRODUCTION	0x00000001L	/*	Non-production style build (internal only). */


/* 	Option flags for NSFDbCreateExtended */

#define	DBCREATE_LOCALSECURITY			0x0001
#define	DBCREATE_OBJSTORE_NEVER			0x0002
#define DBCREATE_MAX_SPECIFIED			0x0004
#define DBCREATE_NORESPONSE_INFO		0x0010	/* Don't support note hierarchy - ODS21 and up only */
#define DBCREATE_NOUNREAD				0x0020	/* Don't maintain unread lists for this DB */
#define DBCREATE_NO_FREE_OVERWRITE		0x0200	/* Skip overwriting freed disk buffer space */
#define DBCREATE_FORM_BUCKET_OPT		0x0400	/* Maintain form/bucket bitmap */
#define	DBCREATE_DISABLE_TXN_LOGGING	0x0800	/* Disable transaction logging for this database if specified */
#define DBCREATE_MAINTAIN_LAST_ACCESSED	0x1000	/* Enable maintaining last accessed time */
#define DBCREATE_IS_MAILBOX				0x4000	/* TRUE if database is a mail[n].box database */
#define DBCREATE_LARGE_UNKTABLE			0x8000	/* TRUE if database should allow "large" (>64K bytes) UNK table */


/* Values for EncryptStrength of NSFDbCreateExtended */

#define	DBCREATE_ENCRYPT_NONE			0x00	
#define	DBCREATE_ENCRYPT_SIMPLE			0x01	
#define DBCREATE_ENCRYPT_MEDIUM			0x02
#define DBCREATE_ENCRYPT_STRONG			0x03
/* NSFDbCreateExtendedWithOptions Option2 flags */

/* NOTE: When you define a new Option2 flag, OR that flag into the 
   DBCREATE_UNDEFINED_OPTIONS2 definition below */

#define	DBCREATE_USE_SERVER_DEFAULT_DATASTORE			0x00000000
#define	DBCREATE_FORCE_NSF_DATASTORE					0x00000001
#define DBCREATE_FORCE_DB2_DATASTORE					0x00000002

#define DBCREATE_UNDEFINED_OPTIONS2		~(DBCREATE_USE_SERVER_DEFAULT_DATASTORE | \
										  DBCREATE_FORCE_NSF_DATASTORE | \
										  DBCREATE_FORCE_DB2_DATASTORE | \
										  DBCREATE_OVERRIDE_ADMINP)


STATUS LNPUBLIC NSFDbGetReplHistorySummary (DBHANDLE hDb, DWORD Flags,
							HANDLE *rethSummary, DWORD * retNumEntries);

STATUS LNPUBLIC NSFDbGetMajMinVersion (DBHANDLE hDb, BUILDVERSION far *retVersion);

#if !defined(DB2GetInfo)
STATUS LNPUBLIC NSFDB2GetInfo( DBHANDLE hDB, DWORD infotype, void far *buffer, DWORD *size );
#endif

/* \client\cldbinfo.c */
#if !defined(DB2GetServerInfo)
STATUS LNPUBLIC NSFDB2GetServerInfo( char *szServerName, DWORD infotype, void far *buffer, DWORD *size );
#endif

STATUS LNPUBLIC NSFDbIsDB2 (DBHANDLE hDB, BOOL *isDB2);

/* Option flags for NSFDbCreateAndCopy */

#define	DBCOPY_REPLICA					0x00000001L
#define	DBCOPY_SUBCLASS_TEMPLATE		0x00000002L
#define	DBCOPY_DBINFO2					0x00000004L	
#define	DBCOPY_SPECIAL_OBJECTS			0x00000008L
#define	DBCOPY_NO_ACL					0x00000010L
#define	DBCOPY_NO_FULLTEXT				0x00000020L
#define DBCOPY_ENCRYPT_SIMPLE			0x00000040L
#define DBCOPY_ENCRYPT_MEDIUM			0x00000080L
#define DBCOPY_ENCRYPT_STRONG			0x00000100L
#define DBCOPY_KEEP_NOTE_MODTIME		0x00000200L
#define DBCOPY_REPLICA_NAMELIST			0x01000000L	/* Copy the NameList (applicable only when DBCOPY_REPLICA is specified) */
#define DBCOPY_DEST_IS_NSF				0x02000000L	/* Destination is NSF-backed database */
#define DBCOPY_DEST_IS_DB2				0x04000000L	/* Destination is DB2-backed database */
#define DBCOPY_OVERRIDE_DEST			0x08000000L	/* Destination should override default if able to */


STATUS LNPUBLIC NSFDbCopyExtended (DBHANDLE hSrcDB, DBHANDLE hDstDB, 
						TIMEDATE Since, WORD NoteClassMask, DWORD Flags, 
						TIMEDATE far *retUntil);
STATUS LNPUBLIC NSFDbOpen (const char far *PathName, DBHANDLE far *rethDB);
STATUS LNPUBLIC NSFDbOpenTemplate (const char far *PathName, DBHANDLE far *rethDB);
STATUS LNPUBLIC NSFDbOpenExtended (const char far *PathName, WORD Options,
								HANDLE hNames,
								TIMEDATE far *ModifiedTime,
								DBHANDLE far *rethDB,
								TIMEDATE far *retDataModified,
								TIMEDATE far *retNonDataModified);
STATUS LNPUBLIC NSFDbOpenTemplateExtended (const char far *PathName, WORD Options,
								HANDLE hNames,
								TIMEDATE far *ModifiedTime,
								DBHANDLE far *rethDB,
								TIMEDATE far *retDataModified,
								TIMEDATE far *retNonDataModified);
STATUS LNPUBLIC NSFDbClose (DBHANDLE hDB);
STATUS LNPUBLIC NSFDbCreate (const char far *PathName, USHORT DbClass, BOOL ForceCreation);
STATUS LNPUBLIC NSFDbCreateObjectStore (const char far *PathName, BOOL ForceCreation);
STATUS LNPUBLIC NSFDbDelete (const char far *PathName);
STATUS LNPUBLIC NSFDbCreateExtended (const char far *PathName, WORD DbClass, 
									 BOOL ForceCreation, WORD Options, 
									 BYTE EncryptStrength, DWORD MaxFileSize);
STATUS LNPUBLIC NSFDbCreateExtendedWithOptions(const char far *filename, WORD dbclass, BOOL force,
									 WORD Option, DWORD Option2, BYTE EncryptStrength, DWORD MaxFileSize,
									 const char far *String1, const char far *String2, 
									 WORD ReservedListLength, WORD ReservedListCount, HANDLE hReservedList);
STATUS LNPUBLIC NSFDbCreateWithUserNameList(const char far *PathName, WORD DbClass, 
									 BOOL ForceCreation, WORD Options, 
									 BYTE EncryptStrength, DWORD MaxFileSize, HANDLE hNamesList);
STATUS LNPUBLIC NSFDbDeleteExtended (const char far *PathName, HANDLE hNameList);

STATUS LNPUBLIC NSFDbCopy (DBHANDLE hSrcDB, DBHANDLE hDstDB, TIMEDATE Since, WORD NoteClassMask);
STATUS LNPUBLIC NSFDbCopyNote (DBHANDLE hSrcDB, DBID far *SrcDbID, DBID far *SrcReplicaID,
								NOTEID SrcNoteID,
								DBHANDLE hDstDB, DBID far *DstDbID, DBID far *DstReplicaID,
								NOTEID far *retDstNoteID, WORD far *retNoteClass);

STATUS LNPUBLIC NSFDbCreateAndCopyExtended(const char far* srcDb,const char far* dstDb, WORD NoteClass, WORD limit, 
	DWORD flags, HANDLE hNames, DBHANDLE far* retHandle);
STATUS LNPUBLIC NSFDbCreateAndCopy(const char far* srcDb,const char far* dstDb, WORD NoteClass, WORD limit, DWORD flags, DBHANDLE far* retHandle);
STATUS LNPUBLIC NSFDbMarkInServiceExtended(const char far* dbPathPtr, HANDLE hNames);
STATUS LNPUBLIC NSFDbMarkForDelete(const char far* dbPathPtr);
STATUS LNPUBLIC NSFDbMarkInService(const char far* dbPathPtr);
STATUS LNPUBLIC NSFDbMarkOutOfService(const char far* dbPathPtr);

STATUS LNPUBLIC NSFDbCopyNoteExt(DBHANDLE hSrcDB,DBID *SrcDbID,DBID *SrcReplicaID,NOTEID SrcNoteID,
							DBHANDLE hDstDB,DBID *DstDbID,DBID *DstReplicaID,
							DWORD dwOpenFlags, DWORD dwUpdateFlags,
							NOTEID *retDstNoteID,WORD *retNoteClass);
STATUS LNPUBLIC NSFDbCopyACL (DBHANDLE hSrcDB, DBHANDLE hDstDB);
STATUS LNPUBLIC NSFDbCopyTemplateACL (DBHANDLE hSrcDB, DBHANDLE hDstDB, char far *Manager, WORD DefaultAccessLevel);
STATUS LNPUBLIC NSFDbCreateACLFromTemplate (DBHANDLE hNTF, DBHANDLE hNSF,
										const char far *Manager, WORD DefaultAccess,
										HANDLE far *rethACL);
STATUS LNPUBLIC NSFDbStoreACL (DBHANDLE hDB, HANDLE hACL, DWORD ObjectID, WORD Method);
STATUS LNPUBLIC NSFDbReadACL(DBHANDLE hDB, HANDLE far *rethACL);
STATUS LNPUBLIC NSFDbGenerateOID (DBHANDLE hDB, OID far *retOID);
STATUS LNPUBLIC NSFSetMaxPasswordAccess(DBHANDLE hDB, WORD Level);
STATUS LNPUBLIC NSFGetMaxPasswordAccess(DBHANDLE hDB, WORD *retLevel);
STATUS LNPUBLIC NSFDbModifiedTime (DBHANDLE hDB, TIMEDATE far *retDataModified, TIMEDATE far *retNonDataModified);
STATUS LNPUBLIC NSFDbPathGet (DBHANDLE hDB, char far *retCanonicalPathName, char far *retExpandedPathName);
STATUS LNPUBLIC NSFDbInfoGet (DBHANDLE hDB, char far *retBuffer);
STATUS LNPUBLIC NSFDbInfoSet (DBHANDLE hDB, char far *Buffer);
void LNPUBLIC   NSFDbInfoParse(char far *Info, WORD What, char far *Buffer, WORD Length);
void LNPUBLIC   NSFDbInfoModify(char far *Info, WORD What, const char far *Buffer);
STATUS LNPUBLIC NSFDbGetSpecialNoteID (DBHANDLE hDB, WORD Index, NOTEID far *retNoteID);
STATUS LNPUBLIC NSFDbIDGet (DBHANDLE hDB, DBID far *retDbID);
STATUS LNPUBLIC NSFDbReplicaInfoGet (DBHANDLE hDB, DBREPLICAINFO far *retReplicationInfo);
STATUS LNPUBLIC NSFDbReplicaInfoSet (DBHANDLE hDB, DBREPLICAINFO far *ReplicationInfo);
STATUS LNPUBLIC NSFDbReplicaInfoSetExtended (DBHANDLE hDB, DBREPLICAINFO far *ReplicationInfo, HANDLE hNamesList);
STATUS LNPUBLIC NSFDbGetNoteInfo (DBHANDLE hDB, NOTEID NoteID,
									OID far *retNoteOID,
									TIMEDATE far *retModified,
									WORD far *retNoteClass);
STATUS LNPUBLIC NSFDbHasProfileNoteChanged(DBHANDLE hDB, NOTEID noteid, DWORD *pSeqNum, TIMEDATE *Since, BOOL *HasChanged, TIMEDATE *retModTime);
#define DBQUOTA_NOT_SPECIFIED (-1)

STATUS LNPUBLIC NSFDbQuotaGet (const char far *Filename, DBQUOTAINFO far *retQuotaInfo);
STATUS LNPUBLIC NSFDbQuotaSetExt(const char far *Filename, DWORD Flags, DBQUOTAINFO far *QuotaInfo);

STATUS LNPUBLIC NSFDbQuotaGethDB(DBHANDLE hDB, DBQUOTAINFOEXT *QuotaInfo) ;

/* Options for quota detection,enforcement method */

#define NSF_QUOTA_METHOD_DEFAULT				0L
#define NSF_QUOTA_METHOD_USAGE					1L
#define NSF_QUOTA_METHOD_FILESIZE				2L
#define NSF_QUOTA_METHOD_FILESIZE_ADD			3L

STATUS LNPUBLIC NSFDbFTSizeGet(const char far *Filename, DWORD *FTSize);
STATUS LNPUBLIC NSFDbGetNoteInfoByUNID(DBHANDLE hDB, UNID far *pUNID, 
									NOTEID far *retNoteID, OID far *retOID, 
									TIMEDATE far *retModTime, WORD far *retClass);
STATUS LNPUBLIC NSFDbGetModifiedNoteTable (DBHANDLE hDB, WORD NoteClassMask, TIMEDATE Since,
									TIMEDATE far *retUntil,
									HANDLE far *rethTable);
STATUS LNPUBLIC NSFApplyModifiedNoteTable (HANDLE hModifiedNotes, HANDLE hTargetTable);
STATUS LNPUBLIC NSFDbLocateByReplicaID (DBHANDLE hDB, DBID far *ReplicaID, char far *retPathName, WORD PathMaxLen);
STATUS LNPUBLIC NSFDbStampNotes (DBHANDLE hDB, HANDLE hTable,
									const char far *ItemName, WORD ItemNameLength,
									void far *Data, WORD DataLength);
STATUS LNPUBLIC NSFDbStampNotesMultiItem (DBHANDLE hDB, HANDLE hTable, HANDLE hInNote);
STATUS LNPUBLIC NSFDbDeleteNotes (DBHANDLE hDB, HANDLE hTable, UNID far *retUNIDArray);
STATUS LNPUBLIC NSFDbUserNameGet (DBHANDLE hDB, char far *retUserName, WORD BufferLength);
STATUS LNPUBLIC NSFDbGetNamesList(DBHANDLE hDB, DWORD Flags, HANDLE *rethNamesList);
void LNPUBLIC NSFDbAccessGet(DBHANDLE hDB, WORD far *retAccessLevel, WORD far *retAccessFlag);
STATUS LNPUBLIC NSFDbRename (const char far *from, const char far *to);
STATUS LNPUBLIC NSFDbClassGet (DBHANDLE hDB, WORD far *retClass);
STATUS LNPUBLIC NSFDbModeGet (DBHANDLE hDB, USHORT far *retMode);
STATUS LNPUBLIC NSFDbGetUserActivity(DBHANDLE hDB, DWORD Flags, DBACTIVITY far *retDbActivity,
									HANDLE far *rethUserInfo, WORD far *retUserCount);
STATUS LNPUBLIC NSFDbCloseSession (DBHANDLE hDB);
STATUS LNPUBLIC NSFDbReopen (DBHANDLE hDB, DBHANDLE far *rethDB);
STATUS LNPUBLIC NSFDbMajorMinorVersionGet (DBHANDLE hDB, WORD far *retMajorVersion, 
											 WORD far *retMinorVersion);
STATUS LNPUBLIC NSFDbItemDefTable (DBHANDLE hDB,ITEMDEFTABLEHANDLE far *retItemNameTable);
STATUS LNPUBLIC NSFDbItemDefTableExt (DBHANDLE hDB,ITEMDEFTABLEEXTHANDLE far *retItemNameTable);
STATUS LNPUBLIC NSFDbGetBuildVersion (DBHANDLE hDB,WORD far *retVersion);
STATUS LNPUBLIC NSFDbSpaceUsage (DBHANDLE hDB, DWORD far *retAllocatedBytes, DWORD far *retFreeBytes);
STATUS LNPUBLIC NSFDbSpaceUsageScaled (DBHANDLE hDB, DWORD far *retAllocatedGranules, DWORD far *retFreeGranules, DWORD far *retGranularity);
DWORD LNPUBLIC NSFDbGetOpenDatabaseID (DBHANDLE hDB);
STATUS LNPUBLIC NSFGetServerStats(char far *ServerName, char far *Facility, char far *StatName, HANDLE far *rethTable, DWORD far *retTableSize);
STATUS LNPUBLIC NSFGetServerLatency(char far *ServerName, DWORD Timeout,
								DWORD far *retClientToServerMS,
								DWORD far *retServerToClientMS,
								WORD far *ServerVersion);
STATUS LNPUBLIC NSFRemoteConsole(char far *ServerName, char far *ConsoleCommand, HANDLE far *hResponseText);

STATUS LNPUBLIC NSFBuildNamesList(char *UserName, DWORD dwFlags, HANDLE *rethNamesList);
STATUS LNPUBLIC NSFDbClearReplHistory(DBHANDLE hDb, DWORD dwFlags);
STATUS LNPUBLIC NSFDbGetModifiedUnreadTables(DBHANDLE hDB, char* UserName, WORD UserNameLen, TIMEDATE Since, TIMEDATE *Until, HANDLE *hRead, HANDLE *hUnread);
STATUS LNPUBLIC NSFDbUpdateUnread (DBHANDLE hDataDB, HANDLE hUnreadList);
STATUS LNPUBLIC NSFDbGetUnreadNoteTable(DBHANDLE hDB,
						char far *UserName, WORD UserNameLength, BOOL fCreateIfNotAvailable,
						HANDLE far *rethUnreadList);
STATUS LNPUBLIC NSFDbGetUnreadNoteTable2(DBHANDLE hDB,
						char far *UserName, WORD UserNameLength, BOOL fCreateIfNotAvailable, BOOL fUpdateUnread,
						HANDLE far *rethUnreadList);
STATUS LNPUBLIC NSFDbSetUnreadNoteTable(DBHANDLE hDB, char far *UserName, WORD UserNameLength,
						BOOL fFlushToDisk, HANDLE hOriginalUnreadList, HANDLE hUnreadList);
STATUS LNPUBLIC NSFDbGetObjectStoreID(DBHANDLE dbhandle, BOOL far *Specified, DBID far *ObjStoreReplicaID);
STATUS LNPUBLIC NSFDbSetObjectStoreID(DBHANDLE dbhandle, DBID far *ObjStoreReplicaID);
STATUS LNPUBLIC NSFDbFilter(DBHANDLE hFilterDB, NOTEHANDLE hFilterNote,
								HANDLE hNotesToFilter, BOOL fIncremental,
								void far *Reserved1, void far *Reserved2,
								char far *DbTitle, char far *ViewTitle,
								void far *Reserved3, void far *Reserved4,
								HANDLE hDeletedList,
								HANDLE hSelectedList);
STATUS LNPUBLIC NSFDbCompact(const char far *Pathname, WORD Options, DWORD far *retStats);
STATUS LNPUBLIC NSFDbCompactExtended(const char *Pathname, DWORD Options, DWORD *retStats);
/*	Define flags for NSFFolderGetIDTable */
#define DB_GETIDTABLE_VALIDATE 0x00000001	/*	If set, return only "validated" noteIDs */
STATUS LNPUBLIC NSFFolderGetIDTable(HANDLE hViewDB, HANDLE hDataDB, NOTEID ViewNoteID, DWORD Flags, HANDLE *hTable);
STATUS LNPUBLIC NSFGetFolderChanges(DBHANDLE hViewDB, DBHANDLE hDataDB, NOTEID ViewNoteID, TIMEDATE *Since, DWORD Flags, 
											HANDLE *AddedNoteTable, HANDLE *RemovedNoteTable);
typedef STATUS (LNCALLBACKPTR NSFGETALLFOLDERCHANGESCALLBACK) (void *Param, UNID *NoteUNID, HANDLE AddedNoteTable, HANDLE RemovedNoteTable);
STATUS LNPUBLIC NSFGetAllFolderChanges(HANDLE hViewDB, HANDLE hDataDB, TIMEDATE *Since, DWORD Flags, 
											NSFGETALLFOLDERCHANGESCALLBACK Callback, void *Param, TIMEDATE *Until);
#define MAX_ITEMDEF_SEGMENTS 25

typedef struct {
	DWORD	Items;			/* number of items in the table */
	DWORD	ItemDefArray;   /* Memory handle of ITEM_DEFINITION_EXT structures */
	DWORD	NumSegments;	/* Number of non-null segments in ItemNameSegs */
	HANDLE	ItemNameSegs[MAX_ITEMDEF_SEGMENTS]; /* Segments of packed text */
	DWORD	ItemNameSegLengths[MAX_ITEMDEF_SEGMENTS];
							/* Length of each non-null text segment */
} ITEM_DEFINITION_TABLE_EXT;

typedef struct {
	DWORD	ItemOffset;			/* offset into ItemNameSegs to item name */
	WORD	ItemType;			/* default data type of the item */
	WORD	ItemNameLength;		/* length of the item's name */
} ITEM_DEFINITION_EXT;

typedef struct {
	DWORD	Items;
	void	*pItemDefArray;
	char	*ItemText[MAX_ITEMDEF_SEGMENTS];
	DWORD	NumSegments;
	DWORD	ItemNameSegLengths[MAX_ITEMDEF_SEGMENTS];
} ITEM_DEFINITION_TABLE_LOCK;

/* Accessor routines for item name table returned by NSFDbItemDefTableExt. */
STATUS LNPUBLIC NSFItemDefExtLock(ITEM_DEFINITION_TABLE_EXT *ItemDefTable, ITEM_DEFINITION_TABLE_LOCK *ItemDefTableLock);
STATUS LNPUBLIC NSFItemDefExtUnlock(ITEM_DEFINITION_TABLE_EXT *ItemDefTable, ITEM_DEFINITION_TABLE_LOCK *ItemDefTableLock);
STATUS LNPUBLIC NSFItemDefExtFree(ITEM_DEFINITION_TABLE_EXT *ItemDeftable);
STATUS LNPUBLIC NSFItemDefExtEntries(ITEM_DEFINITION_TABLE_LOCK *ItemDefTableLock, DWORD *NumEntries);
STATUS LNPUBLIC NSFItemDefExtGetEntry(ITEM_DEFINITION_TABLE_LOCK *ItemDefTableLock, DWORD ItemNum, 
										WORD *ItemType, WORD *ItemLength, char **ItemName);

STATUS LNPUBLIC NSFBackupStart(DBHANDLE hDB, DWORD Flags, HANDLE *BackupContext, DWORD *FileSizeLow, DWORD *FileSizeHigh);
STATUS LNPUBLIC NSFBackupStop(DBHANDLE hDB, HANDLE BackupContext);
#define BACKUPEND_ABORT		0x00000001			/* Abort curent database backup */
STATUS LNPUBLIC NSFBackupEnd(DBHANDLE hDB, HANDLE BackupContext, DWORD Options);
STATUS LNPUBLIC NSFBackupSetHighWaterMark(DBHANDLE hDB, HANDLE BackupContext, 
											DWORD HighWaterMarkLow, DWORD HighWaterMarkHigh);
STATUS LNPUBLIC NSFBackupGetChangeInfoSize(DBHANDLE hDB,
							HANDLE hBackupContext,										
							DWORD Flags,
							DWORD *InfoSizeLow,
							DWORD *InfoSizeHigh);
STATUS LNPUBLIC NSFBackupGetNextChangeInfo(DBHANDLE hDB,
							HANDLE hBackupContext,										
							DWORD Flags,
	                        char * Buffer,
							DWORD BufferSize,
							DWORD *FilledSize);

STATUS LNPUBLIC NSFBackupStartApplyChangeInfo(HANDLE *ApplyInfoContext,
							char * CopyFilePath,
							DWORD Flags,
							DWORD InfoSizeLow,
							DWORD InfoSizeHigh);

STATUS LNPUBLIC NSFBackupApplyNextChangeInfo(
							HANDLE ApplyInfoContext,
							DWORD Flags,
							char * Buffer,
							DWORD BufferSize);
#define APPLYEND_ABORT		0x00000001			/* Abort current change info appilcation */
STATUS LNPUBLIC NSFBackupEndApplyChangeInfo(HANDLE ApplyInfoContext,
							DWORD Flags);

STATUS LNPUBLIC NSFBringDatabaseOnline(const char far *	dbPath, 
										DWORD	options);

#define OFFLINE_NODELETE		0x00000001		/* Don't delete database file */
#define OFFLINE_KEEP_ACCESS_ENTITIES 0x00000002 /* Don't delete DB2 access entities */

STATUS LNPUBLIC NSFTakeDatabaseOffline(const char far *	dbPath, 
										DWORD	WaitTime,
										DWORD	options);
STATUS LNPUBLIC NSFDbGetLogInfo(DBHANDLE hDb, 
								DWORD Flags, 
								BOOL * LOGGED,
								UNID * LogID,
								UNID * Dbiid,
								DWORD * LogExtent);

#define DB2BACKUP_FASTCONNECT		0x1
#define DB2BACKUP_NEWREPLICA		0x2

#define DB2BACKUP_COPY_REPLACE			 0x8
#define DB2BACKUP_COPY_DELETE_SRC		 0x10
#define DB2BACKUP_COPY_ISOLATE           0x20
#define DB2BACKUP_COPY_CLOSE             0x40
#define DB2BACKUP_COPY_NONRECOVERABLE    0x80
#define DB2BACKUP_COPY_IGNORE_NIF        0x100
#define DB2BACKUP_COPY_VENDOR_LOAD       0X200

#define DB2BACKUP_LINKS_VERIFYEXISTING  0x01
#define DB2BACKUP_LINKS_SCANSCHEMAS		0x02
#define DB2BACKUP_LINKS_QUIET           0x04

#define DB2BACKUP_NONSFID 0xffffffff

STATUS LNPUBLIC NSFDB2ReconnectNotesDatabase(const char far *  FullPath,
											 const char far *  String1,
											 DWORD  nsfid,
											 DWORD  flags);

STATUS LNPUBLIC NSFDB2RegenerateLinks (DWORD flags);

STATUS LNPUBLIC NSFDB2ListNSFDB2Databases (HANDLE *pHDbList, void far **pDbList, const char far* tablespaceName);

STATUS LNPUBLIC NSFDB2FastCopy(
							   const char far*  srcDB2Database,
							   const char far*  tgtDB2Database, 
							   const char far*  sourceNSF,
							   const char far*  targetNSF,
							   const char far*  groupName, 
							   const char far*  loadParameter,
							   DWORD            WaitTime,
							   DWORD			flags,
							   DWORD            flags2);

STATUS LNPUBLIC NSFDB2GetDbInfoValidity  (const char* filePath,
										  char* Schema,
										  DWORD szSchema,
										  char* tableSpace,
										  DWORD szTableSpace,
										  char* actualTableSpace,
										  DWORD szActualTableSpace,
										  BOOL*	schemaExists,
										  BOOL* tsExists,
										  BOOL* tsMismatch,
										  DWORD flags);
/* Define NSF Group Properties */
#define DB2NSF_GROUP_PROPERTY_CLASS			1

STATUS LNPUBLIC  NSFGetNSFDB2GroupProperty( const char* group, DWORD infotype, void far *buffer, DWORD *size);

/* Definition of the log restore callback function that the backup */

/* utility will have to provide for archive logging.               */
typedef STATUS (LNCALLBACKPTR LOGRESTORECALLBACKFUNCTION)(UNID *LogID, DWORD LogNumber, char *LogSegmentPathName);

typedef enum {
	MediaCallback_NoteUpdate = 0x01,	/* Update of existing Note */
	MediaCallback_NoteInsert = 0x02,	/* Addition of new note */
	MediaCallback_NoteDelete = 0x04,	/* Delete of note */
	MediaCallback_CLR        = 0x08		/* Event is the undo of an action due to some failure */
} MediaCallbackFlags;


typedef struct {
	WORD			InfoSize;	/* Size of this structure, use this to determine if future fields are avail */ 
	NOTEID			NoteId;		/* NoteID for note being altered */
	NOTEHANDLE		hNote;		/* Handle to note being retrieved */
	TIMEDATE		TranTime;	/* Time the transaction ran for which you are being called */
	char far*		UserName;	/* If avail, else a pointer to "" */
	char far*		PathName;	/* Path & file name of DB */
} NOTE_RESTORE_CALLBACK_INFO;

/* Definition of the note restore callback function that the backup/archive */
/* utility will have to provide for monitoring notes during Media Recovery  */
typedef STATUS (LNCALLBACKPTR NOTERESTORECALLBACKFUNCTION)(	DWORD			state_flags,
															void far *		userParm,
															NOTE_RESTORE_CALLBACK_INFO far * info);


/* Log archiving API for backup utilities to call */
/* Possible values returned from NSFGetTransLogStyle */ 
#define TRANSLOG_STYLE_CIRCULAR 0  /* Circular logging is in effect */
#define TRANSLOG_STYLE_ARCHIVE  1  /* Archive logging is in effect */
#define TRANSLOG_STYLE_LINEAR   2  /* Linear logging is in effect */
STATUS LNPUBLIC NSFGetTransLogStyle(WORD far * LogType);
STATUS LNPUBLIC NSFBeginArchivingLogs(void);
STATUS LNPUBLIC NSFEndArchivingLogs(void);
STATUS LNPUBLIC  NSFGetFirstLogToArchive(UNID far * LogID, DWORD far * LogNumber, char far * LogPath);
STATUS LNPUBLIC NSFGetNextLogToArchive(UNID far * LogID, DWORD far * LogNumber, char far * LogPath);
STATUS LNPUBLIC NSFDoneArchivingLog(UNID far * LogID, DWORD far * LogSequenceNumber);
/* Wait for any other media recovery to finish, vs. return immed if busy */
#define  DBRECOVER_WAIT				0x0001
/* Make recovered db a new instance so it will not conflict with original */
#define  DBRECOVER_ZAP_ID			0x0002
/* Refresh a backup to the current level, mutually exclusive with DBRECOVER_ZAP_ID */
#define  DBRECOVER_REFRESH_BACKUP	0x0004
/* Recover database to a point in time, mutually exclusive with DBRECOVER_REFRESH_BACKUP */
#define  DBRECOVER_POINT_IN_TIME	0x0008
/* Give recovered db a new replica id so it will not conflict with original */
#define  DBRECOVER_ZAP_REPLICAID	0x0010
/* Make recovered db a new instance if another copy of the DB is on-line */
#define  DBRECOVER_ZAP_ID_IF_NECESSARY 0x0020
/* Allow alternate path from which to recover old log extents */
#define	 DBRECOVER_ALT_RETRIEVE_PATH 0x0040

STATUS LNPUBLIC NSFRecoverDatabases(const char far *		dbNames, 
									  LOGRESTORECALLBACKFUNCTION restoreCB,
									  DWORD					Flags, /* DBRECOVER_* flags */
									  WORD far *			errDbIndex,
									  TIMEDATE far *		recoveryTime);

STATUS LNPUBLIC NSFRecoverDatabasesWithCallback(const char far *	dbNames, 
									  LOGRESTORECALLBACKFUNCTION	restoreCB,
									  DWORD							Flags, /* DBRECOVER_* flags */
									  WORD far *					errDbIndex,
									  TIMEDATE far *				recoveryTime,
									  NOTERESTORECALLBACKFUNCTION	noteCB,
									  void far *					userParm);


/* rmmisc.cpp */

/* Return BOOL if span specified, else actual amount of log to process */
STATUS LNPUBLIC NSFIsNewBackupNeeded(const char far *		dbName, 
									 DWORD					comfortSpan, /* Requested Pad Log span in K */
									 DWORD far *			backupNeeded);
STATUS LNPUBLIC NSFDbCreateNoteID(DBHANDLE hDB, BOOL fData, NOTEID *retNoteID);
STATUS LNPUBLIC NSFDbAddItemName(DBHANDLE hDB, WORD type, char *string, WORD length, DWORD *rtnItemNumber); 

/*	Database Hook Drivers
*
* NSF hook drivers enable the API programmer to construct a set of
* subroutines, packaged as a DLL, that "hook" several NSF functions
* related to reading, modifying, and deleting notes.  The principal
* application of these hook drivers is intended to be auditing, that is,
* logging accesses to a database, however they can also be programmed
* to modify the contents of the notes and/or refuse requests.
*
* Hook Driver Packaging and Concurrency Requirements
*
* Like all Notes low-level subsystems, hook drivers must obey strict 
* rules to fit into their computing environment:
*
*    1. The drivers should be available on multiple computing platforms
*
*    2. The drivers are packaged as Dynamic Link Libraries under 
*    Windows, NT, and OS/2. Under Windows, the DEF file must specify the data 
*    as being MOVEABLE SINGLE so that it doesn't occupy GlobalDOS memory, and 
*    because Windows doesn't support multi-instance dynamic link libraries. 
*    For NT and OS/2, we recommend MULTIPLE data, but you can use whatever you 
*    wish.
*
*        For all four environments, Notes uses either LoadLibrary or 
*    DosLoadModule to load the driver. You must decide upon a mnemonic name 
*    for your driver, a maximum of 7 characters that is preferably 
*    nationality-neutral (obscure in all languages), such as NTAUDIT. In order
*    to load the library, Notes prefixes this name with 
*    _ under Windows, $ under OS/2 1.x, I under OS/2 2, and N under NT, 
*    and post-fixes the name with .DLL. The DLL is installed into Notes by 
*    simply placing its executable into the Notes Program Directory.
*
*        Notes automatically loads the hook drivers at initialization.
*    The list of hook drivers to be loaded is specified in NOTES.INI in a
*    variable called NSF_HOOKS with a comma separator. Thus, in order to load
*    three hook drivers, the variable might be specified as
*    NSF_HOOKS=drivera,driverb,driverc. Note that it isn't necessary to
*    specify the prefix character or the suffix .DLL.
*
*        Because of instantiation requirements of the operating systems, 
*    the library is loaded once per process. At load time, the first entry 
*    point address (entry point @1) is obtained by ordinal, and the driver's 
*    Init() function is invoked. The principal use of this function is to plug 
*    a data structure with vectors to other hook driver subroutines, 
*    including its Term() function which will be called by Notes when the 
*    process exits (or performs NotesTerm()).
*
*        Remember that in some environments (such as Windows), you must
*    export, in your DEF file, all of your functions that Notes will call
*    through these vectors. This is because Windows uses the fact that it's
*    exported to generate a thunk that sets up the DLL's DS appropriately on
*    all of these entry points.
*
*    3. All code executed by all entry points to the drivers must 
*    be 100% re-entrant by both multiple threads within a single process and 
*    multiple processes. In Windows, if you Yield() or make a call to a
*    Notes API function, you may also be preempted by another process that
*    does a hook driver call, so reentrancy is a requirement even in Windows.
*    (Notes makes heavy use of multiple threads and multiple processes, so
*    this must be treated as a required feature, not as something that can
*    be done "later".)
*
* Following is the data structure passed to your hook driver's Init routine.
* When your routine is called, the hModule is filled in (just in case you
* need it to load resources), and the rest of the vectors are zero'ed.
* If you don't need to hook any of these vectors, leave them NULL.  Otherwise,
* plug the vectors in your Init routine.
*
*/

//commented for LotusNotify Miranga NG plugin beacouse of conflicts with miranda headers (struct LIST at m_system_cpp.h) 
// typedef struct dbhookvec
	// {

	// /*	Module handle of the hook library */

	// HMODULE hModule;

	// /*	Initialization vector.  This is simply a pointer to the routine
		// exported as ordinal #1 in your DLL.  You needn't plug this
		// vector because it's plugged before calling through it to do
		// driver initializations.  This routine is called once for each
		// process that does a NotesInit(). */

	// STATUS (LNCALLBACKPTR Init)(struct dbhookvec far *vec);

	// /*	Termination vector.  This is called once for each process that
		// did an Init call, just prior to the process's exiting.  */

	// STATUS (LNCALLBACKPTR Term)(struct dbhookvec far *vec);

	// /*	Note open hook.  This routine is called just AFTER a note is opened
		// by the NSF subsystem.  It is called for both local and remote
		// databases.  UserName is the name of the user doing the open.
		// GroupList may be NULL, but when it's not it contains a list of
		// the groups that the user is in.  hDB and NoteID can be used
		// to identify the database and note (use NSFDbPathGet to get the
		// pathname of the database).  OpenFlags are the flags originally
		// passed into NSFNoteOpen.  hNote is the handle to the note that
		// is about to be returned to the caller.  Your hook driver may
		// modify the contents of the note, or may return an error from
		// this routine if you wish to fail the open call.  You may use any
		// standard Notes error code to fail the call. */

	// STATUS (LNCALLBACKPTR NoteOpen)(struct dbhookvec far *vec, char far *UserName, LIST far *GroupList, DBHANDLE hDB, NOTEID NoteID, NOTEHANDLE hNote, WORD OpenFlags);

	// /*	Note add/update hook, also handles deletion
		// This routine is called just BEFORE a note is updated
		// by the NSF subsystem.  It is called for both local and remote
		// databases.  UserName is the name of the user doing the open.
		// GroupList may be NULL, but when it's not it contains a list of
		// the groups that the user is in.  hDB and NoteID can be used
		// to identify the database and note (use NSFDbPathGet to get the
		// pathname of the database).  pUpdateFlags is a pointer to a WORD
		// of UpdateFlags originally passed into NSFNoteUpdate.  The hook
		// may examine and modify the UpdateFlags WORD before returning,
		// thus modifying the flags that will be passed into NSFNoteUpdate.
		// hNote is the handle to the note that is about to be updated.
		// Your hook driver may modify the contents of the note, or may
		// return an error from this routine if you wish to fail the update
		// call.  You may use any standard Notes error code to fail the call.
		// Note that you can use the following algorithm to determine
		// precisely the operation being performed:

		// *	if (NoteID == NOTEID_ADD
		// *			|| NoteID == NOTEID_ADD_OR_REPLACE
		// *			|| NoteID == NOTEID_ADD_UNID)
		// *		{
		// *		if ((*pUpdateFlags) & UPDATE_DELETED)
		// *			; ** Adding a new "deleted note stub" to a database **
		// *		else
		// *			; ** Adding a new document to a database **
		// *		}
		// *	else
		// *		{
		// *		if ((*pUpdateFlags) & UPDATE_DELETED)
		// *			; ** Deleting an existing document from the database. **
		// *			  ** Note that in this case, the contents of the hNote **
		// *			  ** may be nil and should be disregarded; because of **
	    // *			  ** this, there's no way to tell the class of a note **
		// *			  ** being deleted at this point **
		// *		else
		// *			; ** Updating an existing document in the database **
		// *		}

		// */

	// STATUS (LNCALLBACKPTR NoteUpdate)(struct dbhookvec far *vec, char far *UserName, LIST far *GroupList, DBHANDLE hDB, NOTEID NoteID, NOTEHANDLE hNote, WORD far *pUpdateFlags);

	// /*	Note stamp (Categorization) hook.
		// This routine is called just BEFORE a set of notes is Categorized
		// by the NSF subsystem.  It is called for both local and remote
		// databases.  UserName is the name of the user doing the categorization.
		// GroupList may be NULL, but when it's not it contains a list of
		// the groups that the user is in.  hDB and hTable can be used
		// to identify the database and notes (use NSFDbPathGet to get the
		// pathname of the database).  ItemName and Data indicate the data
		// being used in the categorization.  Your hook routine may return
		// an error if you wish to fail the Stamp call.  You may use any
		// standard Notes error code to fail the call. */

	// STATUS (LNCALLBACKPTR DbStampNotes)(struct dbhookvec far *vec, char far *UserName, LIST far *GroupList, DBHANDLE hDB, HANDLE hIDTable, char far *ItemName, WORD ItemNameLength, void far *Data, WORD Length);

	// /*	Flags used by Notes to describe the hook driver -- RESERVED */

	// DWORD	Flags;

	// } DBHOOKVEC;

STATUS LNPUBLIC NSFDbDirGet(DBHANDLE hDB, char *retDir);
STATUS LNPUBLIC NSFDbIsLocallyEncrypted (DBHANDLE hDB, BOOL *pRetval);
STATUS LNPUBLIC NSFGetOrgDir(char *UserName, char *retDir);

/* End of Note Storage File Database Definitions */

#ifdef __cplusplus
}
#endif

#endif


#if defined(OS400) && (__OS400_TGTVRM__ >= 510)
#pragma datamodel(pop)
#endif