diff options
Diffstat (limited to 'plugins/LotusNotify/src/cnotesapi/include/nsfdb.h')
| -rw-r--r-- | plugins/LotusNotify/src/cnotesapi/include/nsfdb.h | 924 |
1 files changed, 924 insertions, 0 deletions
diff --git a/plugins/LotusNotify/src/cnotesapi/include/nsfdb.h b/plugins/LotusNotify/src/cnotesapi/include/nsfdb.h new file mode 100644 index 0000000000..678bb6d7b1 --- /dev/null +++ b/plugins/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
+
|