all protocols (even virtual ones) moved to the Protocols folder

1 files changed, 924 insertions, 0 deletions

diff --git a/protocols/LotusNotify/src/cnotesapi/include/nsfdb.h b/protocols/LotusNotify/src/cnotesapi/include/nsfdb.h
new file mode 100644
index 0000000000..2978ab8178
--- /dev/null
+++ b/protocols/LotusNotify/src/cnotesapi/include/nsfdb.h
@@ -0,0 +1,924 @@
+
+#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
+