home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Network Support Encyclopedia 96-1
/
novell-nsepro-1996-1-cd2.iso
/
download
/
netware
/
spclas.exe
/
SNAPCLAS.C
next >
Wrap
C/C++ Source or Header
|
1995-02-15
|
57KB
|
1,487 lines
/*-------------------------------------------------------------------------*/
/* snapclas.c */
/* */
/* (c) Copyright 1992-1994 Novell, Inc. All rights reserved. */
/* */
/* The following source code is provided to aid in the development of */
/* NetWare (TM) compatible products and is provided "AS IS" AND WITHOUT */
/* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING WITHOUT LIMITATION ANY */
/* IMPLIED WARRANTIES OF MERCHANTABILITY, TITLE AND FITNESS FOR A */
/* PARTICULAR PURPOSE. Some states do not allow limitations on how long */
/* an implied warranty lasts, so the above limitation may not apply to */
/* You. This warranty gives you specific legal rights which vary from */
/* state to state. Some states do not allow the exclusion or limitation */
/* of incidental or consequential damages, so the above limitation or */
/* exclusion may not apply to You. */
/* */
/*-------------------------------------------------------------------------*/
#include <windows.h>
#include <toolhelp.h>
#include <string.h>
#include <stdio.h>
#include <nwnet.h>
#include <nwsnapin.h>
#include "snapclas.h"
/*------------------------------------------------------------------------*/
/* Function Prototypes */
/*------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
{
#endif
N_EXTERN_LIBRARY (NWRCODE)
SnapinSoldierProc (pnstr8 name, nuint16 msg, nparam p1, nparam p2);
N_EXTERN_LIBRARY (void)
ShowInfoMenuAction (void) ;
N_EXTERN_LIBRARY (void)
ShowInfoMenuValid (pnuint16 pFlags) ;
N_EXTERN_LIBRARY (void)
DefineClassMenuAction (void) ;
N_EXTERN_LIBRARY (void)
DefineClassMenuValid (pnuint16 pFlags) ;
N_EXTERN_LIBRARY (void)
RemoveClassMenuAction (void) ;
N_EXTERN_LIBRARY (void)
RemoveClassMenuValid (pnuint16 pFlags) ;
BOOL _export FAR PASCAL AddSoldierObjectDialogProc (HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam);
BOOL _export FAR PASCAL SoldierIdentificationDlg (HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam);
BOOL AddSoldierObject (char *strName, char *spouseDN);
NWRCODE AddSoldierClassDefinition (void);
NWRCODE RemoveSoldierClassDefinition (void);
int ReadObjectData (void);
int ModifyObjectData (char *name);
#ifdef __cplusplus
}
#endif
/*------------------------------------------------------------------------*/
/* Type Definitions And MACROS */
/* -- This is where original DS attributes and updates are stored */
/*------------------------------------------------------------------------*/
typedef struct tagSoldierObjData
{
HWND hDialogIdent;
char name[256];
char surname[256];
char surnameChange[256];
char rank[64];
char rankChange[64];
char serialNo[64];
char serialNoChange[64];
} TSoldierObject;
#define NUM_SOLDIER_PAGES 1
/*------------------------------------------------------------------------*/
/* Global Used for this snapin's handling of Soldier objects */
/*------------------------------------------------------------------------*/
NWAPageStruct soldierPages[NUM_SOLDIER_PAGES];
static int classDefinedFlag=0;
static int createAnotherFlag=0;
static int showDetailsFlag=0;
static char nameBuf[256];
static char theSurname[MAX_DN_BYTES];
static TSoldierObject soldierObjData;
HINSTANCE hDLL;
HINSTANCE hCtrlDLL;
/*-------------------------------------------------------------------------*/
/* DLL Entry Point */
/*-------------------------------------------------------------------------*/
int FAR PASCAL LibMain (HINSTANCE hInstance, WORD wDataSeg,
WORD cbHeapSize, LPSTR lpCmdLine)
{
hDLL = hInstance;
if (cbHeapSize != 0)
UnlockData (0);
return 1;
};
/*-------------------------------------------------------------------------*/
/* Function : InitSnapin (void) */
/* Description : */
/* Every Snapin DLL must provide this function. In this function, */
/* snapin menu items (under Tools) may be registered. Also, object */
/* procs, which handle object-level events, are registered. */
/* */
/*-------------------------------------------------------------------------*/
int _export FAR PASCAL InitSnapin()
{
nuint16 menuIDShowInfo=0;
nuint16 menuIDAddClassDefs=0;
nuint16 menuIDRemClassDefs=0;
/*----------------------------------------------------------*/
/* Load MUSCROLL.DLL */
/* MUSCROLL support is needed in MVED control. */
/*----------------------------------------------------------*/
hCtrlDLL = LoadLibrary ("muscroll.dll");
/*----------------------------------------------------------*/
/* Registering Soldier Object Class Proc */
/*----------------------------------------------------------*/
NWARegisterObjectProc (NWA_DS_OBJECT_TYPE,
"Soldier",
"Novell, Inc. (C) All rights reserved.",
hDLL,
(NWASnapinObjectProc) SnapinSoldierProc,
NWA_SNAPIN_VERSION);
/*----------------------------------------------------------*/
/* Registering Menu Items */
/* -- These are used for creating and removing the Soldier */
/* -- class in the NDS Schema, so that the rest of the demo */
/* -- makes sense. Schema extension is usually done in an */
/* -- installation NLM on the application's server side. */
/*----------------------------------------------------------*/
NWARegisterMenu (NWA_VIEW_CONSOLE,
0,
NULL,
MF_STRING,
&menuIDShowInfo,
"NWAdmin Info...",
"Display info obtained through the Snapin interface.",
ShowInfoMenuAction, ShowInfoMenuValid,
NWA_SNAPIN_VERSION);
NWARegisterMenu (NWA_VIEW_CONSOLE,
0,
NULL,
MF_STRING,
&menuIDAddClassDefs,
"Define Class",
"Add the Soldier class definition in DS database.",
DefineClassMenuAction, DefineClassMenuValid,
NWA_SNAPIN_VERSION);
NWARegisterMenu (NWA_VIEW_CONSOLE,
0,
NULL,
MF_STRING,
&menuIDRemClassDefs,
"Remove Class",
"Removes the Soldier class definition in DS database.",
RemoveClassMenuAction, RemoveClassMenuValid,
NWA_SNAPIN_VERSION);
return NWA_RET_SUCCESS;
}
/*-------------------------------------------------------------------------*/
/* Function : ShutDown (void) */
/* Description : */
/* Free up muscroll.dll */
/*-------------------------------------------------------------------------*/
void FAR PASCAL ShutDown (void)
{
FreeLibrary (hCtrlDLL);
}
/*-------------------------------------------------------------------------*/
/* Function : ShowInfoMenuAction (void) */
/* Description : */
/* Menu Action Callback Proc for ShowInfo Menu */
/* This function is executed when the "Define Class" menu item is */
/* clicked on. */
/*-------------------------------------------------------------------------*/
N_GLOBAL_LIBRARY (void) _export
ShowInfoMenuAction
(
void
)
{
int err;
UINT32 nwaVersion;
UINT8 nwaVerMajor;
UINT8 nwaVerMinor;
UINT8 nwaVerRevision;
INT32 selObjectCount;
NWASelObject selectedObject;
char selectedObjectClass[255];
char selectedObjectName[255];
char xlatedClassName[255];
char xlatedPropName[255];
char buf[1024];
{
err = NWAGetNWAdminVersion(&nwaVersion); /* ##### */
if (err != NWA_RET_SUCCESS) /* # */
return; /* #### */
nwaVerMajor = (BYTE)(nwaVersion >> 24 & 0xff); /* # */
nwaVerMinor = (BYTE)(nwaVersion >> 16 & 0xff); /* ##### */
nwaVerRevision = (BYTE)(nwaVersion & 0xff);
err = NWAGetSelObjectCount((pnint32)&selObjectCount); /* ##### */
if (err != NWA_RET_SUCCESS) /* # */
return; /* #### */
if (selObjectCount) /* # */
err = NWAGetSelObject(0, &selectedObject); /* # */
if (err != NWA_RET_SUCCESS)
return;
strcpy (selectedObjectName, selectedObject.objName);
strcpy (selectedObjectClass, selectedObject.objClass);
err = NWAGetTranslatedClassName("Soldier", /* #### */
xlatedClassName, 254); /* # */
if (err != NWA_RET_SUCCESS) /* # ## */
return; /* # # */
xlatedPropName[0] = '\0'; /* ### */
err = NWAGetTranslatedPropertyName("Rank", "Soldier",
xlatedPropName, 254);
if (err != NWA_RET_SUCCESS)
return;
wsprintf (buf,
"Info retrieved:\n"
" Version=%d.%d rev%d\n"
" Selected Object Count=%d\n"
" First Selected Object='",
nwaVerMajor, nwaVerMinor, nwaVerRevision,
selObjectCount);
strcat (buf, selectedObjectName);
strcat (buf, "' of class '");
strcat (buf, selectedObjectClass);
strcat (buf, "'\n Soldier's Translated Class Name='");
strcat (buf, xlatedClassName);
strcat (buf, "'\n Translated Prop Name of Rank='");
strcat (buf, xlatedPropName);
strcat (buf, "'");
MessageBox (NULL, buf, "Information from NWAdmin", MB_OK);
}
}
/*-------------------------------------------------------------------------*/
/* Function : ShowInfoMenuValid (void) */
/* Description : */
/* Menu Valid Callback Proc for ShowInfo Menu */
/* -- This function is called to determine whether or not to inactivate */
/* -- (gray out) the menu item */
/*-------------------------------------------------------------------------*/
N_GLOBAL_LIBRARY (void) _export
ShowInfoMenuValid (pnuint16 pFlags)
{
*pFlags=MF_ENABLED;
}
/*-------------------------------------------------------------------------*/
/* Function : DefineClassMenuAction (void) */
/* Description : */
/* Menu Action Callback Proc for DefineClass Menu */
/* This function is executed when the "Define Class" menu item is */
/* clicked on. */
/*-------------------------------------------------------------------------*/
N_GLOBAL_LIBRARY (void) _export
DefineClassMenuAction
(
void
)
{
int err;
char buf[128];
if (!classDefinedFlag)
{
err = (int) AddSoldierClassDefinition();
wsprintf (buf, " AddSoldierClassDefinition() returned = %d", err);
MessageBox (NULL, buf, "Add Class Definition", MB_OK);
classDefinedFlag=1;
}
else
{
MessageBox (NULL, "Class definition for Soldier already exist.\n",
"Add Class Definition", MB_OK);
}
}
/*-------------------------------------------------------------------------*/
/* Function : DefineClassMenuValid (void) */
/* Description : */
/* Menu Valid Callback Proc for DefineClass Menu */
/* -- This function is called to determine whether or not to inactivate */
/* -- (gray out) the menu item */
/*-------------------------------------------------------------------------*/
N_GLOBAL_LIBRARY (void) _export
DefineClassMenuValid (pnuint16 pFlags)
{
if (!classDefinedFlag)
{
*pFlags=FALSE;
}
else
{
*pFlags=TRUE;
}
}
/*-------------------------------------------------------------------------*/
/* Function : RemoveClassMenuAction (void) */
/* Description : */
/* Menu Action Callback Proc for RemoveClass Menu */
/* -- This function is executed when the menu item is clicked on */
/*-------------------------------------------------------------------------*/
N_GLOBAL_LIBRARY (void) _export
RemoveClassMenuAction
(
void
)
{
int err;
char buf[128];
if (classDefinedFlag)
{
err = (int) RemoveSoldierClassDefinition();
wsprintf (buf, " RemoveSoldierClassDefinition() returned = %d", err);
MessageBox (NULL, buf, "Remove Class Definition", MB_OK);
classDefinedFlag=0;
}
else
{
MessageBox (NULL, "Class definition for Soldier does not exist.\n",
"Add Class Definition", MB_OK);
}
}
/*-------------------------------------------------------------------------*/
/* Function : RemoveClassMenuValid (void) */
/* Description : */
/* Menu Valid Callback Proc for RemoveClass Menu */
/* -- This function is called to determine whether or not to inactivate */
/* -- (gray out) the menu item */
/*-------------------------------------------------------------------------*/
N_GLOBAL_LIBRARY (void) _export
RemoveClassMenuValid (pnuint16 pFlags)
{
if (classDefinedFlag)
{
*pFlags=FALSE;
}
else
{
*pFlags=TRUE;
}
}
/*-------------------------------------------------------------------------*/
/* Function : SnapinSoldierProc (void) */
/* Description : */
/* Soldier Snapin Callback Proc */
/*-------------------------------------------------------------------------*/
N_GLOBAL_LIBRARY (NWRCODE) _export
SnapinSoldierProc (pnstr8 name, nuint16 msg, nparam p1, nparam p2)
{
static HBITMAP hBitmap;
static HBITMAP hAlias;
static HBITMAP hReadOnly;
char translatedName[MAX_SCHEMA_NAME_BYTES];
switch (msg)
{
case NWA_MSG_INITSNAPIN:
{
/*-------------------------------------------------*/
/* initialize pages */
/*-------------------------------------------------*/
soldierPages[0].dlgProc = (DLGPROC)SoldierIdentificationDlg;
soldierPages[0].resName = "SOLDIER_IDENTIFICATION";
soldierPages[0].pageTitle = "Identification";
/*-------------------------------------------------*/
/* Register bitmaps here */
/*-------------------------------------------------*/
hBitmap = LoadBitmap (hDLL, "Soldier");
hAlias = LoadBitmap (hDLL, "SoldierAlias");
hReadOnly = LoadBitmap (hDLL, "SoldierRO");
LoadString (hDLL, IDS_SOLDIER, translatedName,
MAX_SCHEMA_NAME_BYTES-1);
NWAAddClassData ("Soldier", translatedName, hBitmap, /* # */
hAlias, hReadOnly); /* # # */
/* # # */
LoadString (hDLL, IDS_RANK, translatedName, /* ##### */
MAX_SCHEMA_NAME_BYTES-1); /* # # */
NWAAddPropertyNameTranslation ("Rank",
"Soldier",
translatedName);
// The following calls are for demonstration only-- /* #### */
// They are NOT required at this point. /* # # */
NWAGetClassBitmap("Soldier", &hBitmap); /* #### */
NWAGetClassAliasBitmap("Soldier", &hBitmap); /* # # */
NWAGetClassReadOnlyBitmap("Soldier", &hBitmap); /* #### */
return NWA_RET_SUCCESS;
}
case NWA_MSG_GETVALIDOPERATIONS : /* #### */
{ /* # */
/*------------------------------------------------*/ /* # */
/* These are operations that are allowed on the */ /* # */
/* objects of Soldier class in the browser: the */ /* #### */
/* object may have details shown on it, it may be */
/* renamed, it may be deleted, DS rights may be */
/* established and/or modified on it, and objects */
/* of the Soldier class may be created. */
/*------------------------------------------------*/
return (NWA_OP_DETAILS | NWA_OP_RENAME | NWA_OP_DELETE |
NWA_OP_DSTYPE | NWA_OP_CREATE) ;
}
case NWA_MSG_CREATEOBJECT: /* #### */
{ /* # # */
/*------------------------------------------------*/ /* # # */
/* The Create dialog was just executed, and the */ /* # # */
/* Soldier icon was selected: put up a dialog for */ /* #### */
/* entering the CN of a new Soldier object, then */
/* create it using DS calls in AddSoldierObject().*/
/*------------------------------------------------*/
int rcode;
int retValue;
retValue = DialogBox (hDLL, "DIALOG_SOLDIER_ADD",
NULL, (DLGPROC)AddSoldierObjectDialogProc) ;
if (retValue)
{
lstrcat (nameBuf, ".");
lstrcat (nameBuf, name);
rcode = AddSoldierObject (nameBuf, theSurname);
if (rcode)
{
//successfully added
lstrcpy ((char*)p1, nameBuf);
if (createAnotherFlag)
return NWA_RET_CREATEANOTHER;
else if (showDetailsFlag)
{
showDetailsFlag=0;
return NWA_RET_SHOWDETAILS;
}
}
else
return NWA_ERR_ERROR;
}
return NWA_RET_SUCCESS;
}
case NWA_MSG_GETPAGECOUNT:
{
/*------------------------------------------------*/
/* Initialize Soldier Data by reading it from NDS */
/*------------------------------------------------*/
lstrcpy (soldierObjData.name, name);
soldierObjData.surname[0]='\0';
soldierObjData.surnameChange[0]='\0';
soldierObjData.rank[0]='\0';
soldierObjData.rankChange[0]='\0';
soldierObjData.serialNo[0]='\0';
soldierObjData.serialNoChange[0]='\0';
ReadObjectData();
return NUM_SOLDIER_PAGES;
}
case NWA_MSG_REGISTERPAGE:
{
/*------------------------------------------------*/
/* Register the Nth page, as specified in p1, by */
/* specifying its dialog procedure name, its */
/* dialog resource name, and the page's title. */
/*------------------------------------------------*/
NWAPageStruct *pageInfo = (NWAPageStruct *)p2;
pageInfo->dlgProc = soldierPages[p1].dlgProc;
pageInfo->resName = soldierPages[p1].resName;
pageInfo->pageTitle = soldierPages[p1].pageTitle;
pageInfo->hDLL = hDLL;
pageInfo->initParam = 0;
return NWA_RET_SUCCESS;
}
case NWA_MSG_MODIFY:
{
/*------------------------------------------------*/
/* The OK button was clicked on, and info on the */
/* object was modified. The DS is updated with */
/* the changes in the function ModifyObjectData() */
/*------------------------------------------------*/
MessageBox (NULL, "NWA_MSG_MODIFY received",
"Soldier proc", MB_OK);
ModifyObjectData (name);
return NWA_RET_SUCCESS;
}
case NWA_MSG_QUERYCOPY: /* # # */
{ /* # # */
/*------------------------------------------------*/ /* ##### */
/* Return NWA_RET_SUCCESS if you want the object */ /* # # */
/* copied; otherwise return NWA_ERR_ERROR. */ /* # # */
/*------------------------------------------------*/
MessageBox (NULL, "Copy the object.",
"Copy Object", MB_OK);
return NWA_RET_SUCCESS;
}
case NWA_MSG_QUERYDELETE: /* ### */
{ /* # */
/*------------------------------------------------*/ /* # */
/* Return TRUE if you want the object deleted; */ /* # */
/* otherwise return FALSE. */ /* ### */
/*------------------------------------------------*/
MessageBox (NULL, "Delete the object.",
"Delete Object", MB_OK);
return TRUE;
}
case NWA_MSG_QUERYMOVE: /* ### */
{ /* # */
/*------------------------------------------------*/ /* # */
/* Return NWA_RET_SUCCESS if you want the object */ /* # # */
/* moved; otherwise return NWA_ERR_ERROR. */ /* ### */
/*------------------------------------------------*/
MessageBox (NULL, "Move the object.",
"Move Object", MB_OK);
return TRUE;
}
case NWA_MSG_RENAME: /* # # */
{ /* # # */
/*------------------------------------------------*/ /* ### */
/* Just do the default DS renaming operation, with*/ /* # # */
/* no side-effects or application-specific */ /* # # */
/* validation */
/*------------------------------------------------*/
MessageBox (NULL, "NWA_MSG_RENAME received",
"Rename Object", MB_OK);
return NWA_RET_DODEFAULT;
}
case NWA_MSG_CLOSESNAPIN:
{
/*------------------------------------------------*/
/* unregister bitmaps and delete them */
/*------------------------------------------------*/
NWARemoveClassData ("Soldier", &hBitmap, /* # */
&hAlias, &hReadOnly); /* # */
if (hBitmap) /* # */
DeleteObject (hBitmap); /* # */
if (hAlias) /* ##### */
DeleteObject (hAlias);
if (hReadOnly)
DeleteObject (hReadOnly);
NWARemovePropertyNameTranslation("Rank", "Soldier"); /* # # */
MessageBox (NULL, "NWA_MSG_CLOSESNAPIN received", /* ## ## */
"Soldier proc", MB_OK); /* # # # */
return NWA_RET_SUCCESS; /* # # */
} /* # # */
default:
break;
}
return NWA_RET_SUCCESS;
}
/*-------------------------------------------------------------------------*/
/* Function : AddSoldierObject (objectName, spouseDN) */
/* Description : */
/* The Create dialog was just executed. Create a new object of class */
/* Soldier in DS with the name specified. */
/*-------------------------------------------------------------------------*/
BOOL AddSoldierObject (char *objName, char *surname)
{
UINT dsErr=0;
Buf_T *ObjectInfo;
NWDSContextHandle context;
uint32 flags;
context = NWDSCreateContext();
dsErr = NWDSSetContext (context, DCK_NAME_CONTEXT, DS_ROOT_NAME);
dsErr = NWDSGetContext (context, DCK_FLAGS, (void *)&flags);
flags |= DCV_TYPELESS_NAMES;
flags |= DCV_XLATE_STRINGS;
flags |= DCV_DEREF_ALIASES;
flags |= DCV_DEREF_BASE_CLASS;
dsErr = NWDSSetContext (context, DCK_FLAGS, (void *)&flags) ;
dsErr = NWDSAllocBuf (DEFAULT_MESSAGE_LEN, &ObjectInfo);
dsErr = NWDSInitBuf (context, DSV_ADD_ENTRY, ObjectInfo);
if (ObjectInfo)
{
dsErr = NWDSPutAttrName (context, ObjectInfo, "Object Class");
dsErr = NWDSPutAttrVal (context, ObjectInfo, SYN_CLASS_NAME,
"Soldier");
dsErr = NWDSPutAttrName (context, ObjectInfo, "Surname");
dsErr = NWDSPutAttrVal (context, ObjectInfo, SYN_CI_STRING, surname);
dsErr = NWDSAddObject (context, objName, NULL, 0, ObjectInfo);
NWDSFreeBuf (ObjectInfo);
}
NWDSFreeContext (context);
if (dsErr)
return FALSE;
else
return TRUE;
}
/*-------------------------------------------------------------------------*/
/* Function : AddSoldierObjectDialogProc (void) */
/* Description : */
/* Dialog Procedure for the Create Soldier object dialog */
/*-------------------------------------------------------------------------*/
BOOL _export FAR PASCAL AddSoldierObjectDialogProc (HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
int state;
switch (message)
{
case WM_INITDIALOG:
{
nameBuf[0]='\0';
SendDlgItemMessage (hwnd, IDC_ADD_ANOTHER, BM_SETCHECK,
createAnotherFlag, 0L);
SendDlgItemMessage (hwnd, IDC_ADD_DETAILS, BM_SETCHECK,
showDetailsFlag, 0L);
return TRUE;
}
case WM_COMMAND:
{
switch (wParam)
{
case IDC_CREATE :
GetDlgItemText (hwnd, IDC_SOLDIER_NAME, nameBuf, 255);
GetDlgItemText (hwnd, IDC_SURNAME, theSurname, 255);
createAnotherFlag=(int)SendDlgItemMessage (hwnd,
IDC_ADD_ANOTHER,
BM_GETCHECK, 0, 0L);
showDetailsFlag=(int)SendDlgItemMessage (hwnd, IDC_ADD_DETAILS,
BM_GETCHECK, 0, 0L);
EndDialog (hwnd, TRUE);
return TRUE;
case IDC_CANCEL :
createAnotherFlag=0;
showDetailsFlag=0;
EndDialog (hwnd, FALSE);
return TRUE;
case IDC_ADD_DETAILS :
/*-------------------------------------------------*/
/* Automatically brings up details on the newly */
/* created object once created, if checked */
/*-------------------------------------------------*/
state =(int) SendDlgItemMessage (hwnd, IDC_ADD_DETAILS,
BM_GETCHECK, 0, 0L);
SendDlgItemMessage (hwnd, IDC_ADD_DETAILS, BM_SETCHECK,
!state, 0L);
if (!state)
SendDlgItemMessage (hwnd, IDC_ADD_ANOTHER, BM_SETCHECK,
state, 0L);
EnableWindow (GetDlgItem (hwnd, IDC_ADD_ANOTHER), state);
break;
case IDC_ADD_ANOTHER :
/*-------------------------------------------------*/
/* Automatically brings up this create dialog */
/* again once this object is created, allowing the */
/* administrator to add many objects of one class */
/* until the "add another" checkbox is unchecked. */
/*-------------------------------------------------*/
state = (int) SendDlgItemMessage (hwnd, IDC_ADD_ANOTHER,
BM_GETCHECK, 0, 0L);
SendDlgItemMessage (hwnd, IDC_ADD_ANOTHER, BM_SETCHECK,
!state, 0L);
EnableWindow (GetDlgItem (hwnd, IDC_ADD_DETAILS), state);
break;
}
}
return TRUE;
}
return FALSE ;
}
/*-------------------------------------------------------------------------*/
/* Function : SoldierIdentificationDlg */
/* Description : */
/* Identification Page Dialog Proc */
/*-------------------------------------------------------------------------*/
BOOL _export FAR PASCAL SoldierIdentificationDlg (HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
{
/*-------------------------------------------------*/
/* Initialize the dialog by inserting current DS */
/* values into the controls on the identification */
/* page. These values were previously fetched */
/* from DS by the ReadData() function. */
/*-------------------------------------------------*/
soldierObjData.hDialogIdent = hwnd;
SetDlgItemText (hwnd, IDC_NAME, soldierObjData.name);
SendDlgItemMessage (hwnd, IDC_SURNAME, EM_LIMITTEXT, 255, 0L);
SetDlgItemText (hwnd, IDC_SURNAME, soldierObjData.surname);
SendDlgItemMessage (hwnd, IDC_RANK, EM_LIMITTEXT, 63, 0L);
SetDlgItemText (hwnd, IDC_RANK, soldierObjData.rank);
SendDlgItemMessage (hwnd, IDC_SERIALNO, EM_LIMITTEXT, 63, 0L);
SetDlgItemText (hwnd, IDC_SERIALNO, soldierObjData.serialNo);
return TRUE;
}
case NWA_WM_F1HELP:
{
MessageBox (NULL, "Identification Page help", "Snapin Help",
MB_OK);
return TRUE;
}
case WM_COMMAND:
switch (wParam)
{
/*-------------------------------------------------*/
/* Handle messages from the controls on the page. */
/* If any of the edit controls is changed, flag */
/* the page as modified (which shows as a black */
/* corner on the page icon, and enabling of the OK */
/* button, if not already enabled. */
/* The MVED control is already inextricably linked */
/* to the page, and does its message interaction */
/* with the page automatically. */
/*-------------------------------------------------*/
case IDC_SURNAME:
if (HIWORD (lParam) == EN_CHANGE)
{
SendMessage (hwnd, NWA_WM_SETPAGEMODIFY, (WORD)hwnd,
MAKELONG (0,TRUE));
GetDlgItemText (hwnd, IDC_SURNAME,
soldierObjData.surnameChange, 255);
}
break;
case IDC_RANK:
if (HIWORD (lParam) == EN_CHANGE)
{
SendMessage (hwnd, NWA_WM_SETPAGEMODIFY, (WORD)hwnd,
MAKELONG (0,TRUE));
GetDlgItemText (hwnd, IDC_RANK,
soldierObjData.rankChange, 63);
}
break;
case IDC_SERIALNO:
if (HIWORD (lParam) == EN_CHANGE)
{
SendMessage (hwnd, NWA_WM_SETPAGEMODIFY, (WORD)hwnd,
MAKELONG (0,TRUE));
GetDlgItemText (hwnd, IDC_SERIALNO,
soldierObjData.serialNoChange, 63);
}
break;
}
break;
case NWA_WM_CANCLOSE:
{
/*-------------------------------------------------*/
/* Transfer modified data from the dialog's */
/* controls to a global data structure, before the */
/* page dialog goes away. */
/*-------------------------------------------------*/
int i;
GetDlgItemText (hwnd, IDC_SURNAME, soldierObjData.surnameChange,
127);
GetDlgItemText (hwnd, IDC_RANK, soldierObjData.rankChange, 127);
GetDlgItemText (hwnd, IDC_SERIALNO, soldierObjData.serialNoChange,
127);
return TRUE;
}
}
return FALSE ;
}
/*------------------------------------------------------------------------*/
/* Function : AddSoldierClassDefinition */
/* Description : */
/* Adds the Soldier object class in the DS schema */
/* class Name : Soldier */
/* super class : Person */
/* */
/* Optional Attributes Added : */
/* Spouse : SYN_DIST_NAME (single-valued) */
/* Rank : SYN_CI_STRING (single-valued) */
/* Military Serial Number : SYN_CI_STRING (single-valued) */
/* Commanding Officer : SYN_DIST_NAME (multi-valued) */
/*------------------------------------------------------------------------*/
NWRCODE AddSoldierClassDefinition()
{
NWDSContextHandle context;
int err=0;
Class_Info_T classInfo;
Attr_Info_T attrInfo;
Buf_T *classBuf;
char attrName[MAX_SCHEMA_NAME_CHARS+2];
char className[MAX_SCHEMA_NAME_CHARS+2];
char superClass[MAX_SCHEMA_NAME_CHARS+2];
char contClass[MAX_SCHEMA_NAME_CHARS+2];
char nameAttr[MAX_SCHEMA_NAME_CHARS+2];
char manAttr[MAX_SCHEMA_NAME_CHARS+2];
char optAttr[MAX_SCHEMA_NAME_CHARS+2];
context = NWDSCreateContext();
if (context == (NWDSContextHandle) ERR_CONTEXT_CREATION)
return ((NWRCODE) context) ;
memset (&attrInfo, (int) '\0', sizeof (Attr_Info_T));
attrInfo.asn1ID.length = 0;
memset (attrInfo.asn1ID.data, 0, MAX_ASN1_NAME);
/*-------------------------------------------------*/
/* Add the Spouse attribute to the schema */
/*-------------------------------------------------*/
attrInfo.attrFlags = DS_SINGLE_VALUED_ATTR;
attrInfo.attrSyntaxID = SYN_DIST_NAME;
strcpy (attrName, "Spouse");
err = NWDSDefineAttr (context, attrName, &attrInfo);
if (err < 0)
{
return ((NWRCODE) err) ;
}
/*-------------------------------------------------*/
/* Add the Rank attribute to the schema */
/*-------------------------------------------------*/
attrInfo.attrFlags = DS_SINGLE_VALUED_ATTR;
attrInfo.attrSyntaxID = SYN_CI_STRING;
strcpy (attrName, "Rank");
err = NWDSDefineAttr (context, attrName, &attrInfo);
if (err < 0)
{
return ((NWRCODE) err) ;
}
/*-------------------------------------------------*/
/* Add the Military Serial Number attribute to the */
/* schema */
/*-------------------------------------------------*/
attrInfo.attrFlags = DS_SINGLE_VALUED_ATTR;
attrInfo.attrSyntaxID = SYN_CI_STRING;
strcpy (attrName, "Military Serial Number");
err = NWDSDefineAttr (context, attrName, &attrInfo);
if (err < 0)
{
return ((NWRCODE) err) ;
}
/*-------------------------------------------------*/
/* Add the Commanding Officer attribute to the */
/* schema */
/*-------------------------------------------------*/
attrInfo.attrFlags = 0; // (default is multi-valued)
attrInfo.attrSyntaxID = SYN_DIST_NAME;
strcpy (attrName, "Commanding Officer");
err = NWDSDefineAttr (context, attrName, &attrInfo);
if (err < 0)
{
return ((NWRCODE) err) ;
}
/*-------------------------------------------------*/
/* Now, define the Soldier class in the schema. */
/* The buffer is built in five "string arrays": */
/* 1. Super Class names */
/* 2. Containment Class names */
/* 3. Naming Attribute names */
/* 4. Mandatory Attribute names */
/* 5. Optional Attribute names */
/* But first, get the DS buffer allocated, etc. */
/*-------------------------------------------------*/
strcpy (className, "Soldier");
strcpy (superClass, "Person");
classInfo.classFlags = 2;
classInfo.asn1ID.length = 32;
memset (&classInfo.asn1ID, 0x00, sizeof (Asn1ID_T));
err = NWDSAllocBuf (DEFAULT_MESSAGE_LEN, &classBuf);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
err = NWDSInitBuf (context, DSV_DEFINE_CLASS, classBuf);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
/*-------------------------------------------------*/
/* 1. entries for super class names */
/*-------------------------------------------------*/
err = NWDSBeginClassItem (context, classBuf);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
err = NWDSPutClassItem (context, classBuf, superClass);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
/*-------------------------------------------------*/
/* 2. entries for containment class names */
/*-------------------------------------------------*/
err = NWDSBeginClassItem (context, classBuf);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
strcpy (contClass, "Organization");
err = NWDSPutClassItem (context, classBuf, contClass);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
strcpy (contClass, "Organizational Unit");
err = NWDSPutClassItem (context, classBuf, contClass);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
/*-------------------------------------------------*/
/* 3. entries for naming attribute names */
/*-------------------------------------------------*/
err = NWDSBeginClassItem (context, classBuf);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
strcpy (nameAttr, "CN");
err = NWDSPutClassItem (context, classBuf, nameAttr);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
/*-------------------------------------------------*/
/* 4. entries for mandatory attribute names */
/* (no additional mandatory attributes) */
/*-------------------------------------------------*/
err = NWDSBeginClassItem (context, classBuf);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
/*-------------------------------------------------*/
/* 5. entries for optional attribute names */
/* (four of them) */
/*-------------------------------------------------*/
err = NWDSBeginClassItem (context, classBuf);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
strcpy (optAttr, "Spouse");
err = NWDSPutClassItem (context, classBuf, optAttr);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
strcpy (optAttr, "Rank");
err = NWDSPutClassItem (context, classBuf, optAttr);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
strcpy (optAttr, "Military Serial Number");
err = NWDSPutClassItem (context, classBuf, optAttr);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
strcpy (optAttr, "Commanding Officer");
err = NWDSPutClassItem (context, classBuf, optAttr);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
/*-------------------------------------------------*/
/* Now, define the class in the schema, now that */
/* buffer is completed. */
/*-------------------------------------------------*/
err = NWDSDefineClass (context, className, &classInfo, classBuf);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
NWDSFreeBuf (classBuf);
NWDSFreeContext (context);
return (err);
}
/*-------------------------------------------------------------------------*/
/* Function : RemoveSoldierClassDefinition */
/* Description : */
/* Removes the class definition from the DS schema */
/*-------------------------------------------------------------------------*/
NWRCODE RemoveSoldierClassDefinition()
{
NWDSContextHandle context;
int err=0;
char className[MAX_SCHEMA_NAME_CHARS+2];
char attrName[MAX_SCHEMA_NAME_CHARS+2];
context = NWDSCreateContext();
if (context == (NWDSContextHandle) ERR_CONTEXT_CREATION)
return ((NWRCODE) context) ;
/*-------------------------------------------------*/
/* First, remove the Soldier class definition from */
/* the schema. */
/*-------------------------------------------------*/
strcpy (className, "Soldier");
err = NWDSRemoveClassDef (context, className);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
/*-------------------------------------------------*/
/* Now, remove all of the attributes that we */
/* defined when we defined the Soldier class */
/*-------------------------------------------------*/
strcpy (attrName, "Spouse");
err = NWDSRemoveAttrDef (context, attrName);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
strcpy (attrName, "Rank");
err = NWDSRemoveAttrDef (context, attrName);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
strcpy (attrName, "Military Serial Number");
err = NWDSRemoveAttrDef (context, attrName);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
strcpy (attrName, "Commanding Officer");
err = NWDSRemoveAttrDef (context, attrName);
if (err < 0)
{
return ( (NWRCODE) err) ;
}
NWDSFreeContext (context);
return (err);
}
/*-------------------------------------------------------------------------*/
/* Function : ReadObjectData */
/* Description : */
/* Function for reading / modifying object data in DS */
/*-------------------------------------------------------------------------*/
int ReadObjectData()
{
NWDSContextHandle context;
int err=0, i, j;
int32 iterHandle=-1L;
Buf_T *resBuf, *nameBuf;
char *attributes[]={"Surname",
"Rank",
"Military Serial Number"};
uint32 totAttr, valCount, synID;
char attrName[MAX_DN_CHARS+1];
uint32 flags;
totAttr = sizeof (attributes) / sizeof (attributes[0]);
context = NWDSCreateContext();
if (context == (NWDSContextHandle) ERR_CONTEXT_CREATION)
return ((int) context) ;
err=NWDSSetContext (context, DCK_NAME_CONTEXT, DS_ROOT_NAME);
if (err < 0)
{
NWDSFreeContext (context);
return err;
}
err = NWDSGetContext (context, DCK_FLAGS, (void *)&flags);
if (err < 0)
{
NWDSFreeContext (context);
return err;
}
flags |= DCV_TYPELESS_NAMES;
flags |= DCV_XLATE_STRINGS;
flags |= DCV_DEREF_ALIASES;
flags |= DCV_DEREF_BASE_CLASS;
err = NWDSSetContext (context, DCK_FLAGS, (void *)&flags) ;
if (err < 0)
{
NWDSFreeContext (context);
return err;
}
/*-------------------------------------------------------*/
/* There are two buffers: one used to send the names of */
/* attributes we are interested in, and the other to */
/* receive the values of those attributes for the */
/* specified Soldier object. */
/*-------------------------------------------------------*/
err=NWDSAllocBuf (DEFAULT_MESSAGE_LEN, &resBuf);
if (err < 0)
{
NWDSFreeContext (context);
return err;
}
err=NWDSAllocBuf (DEFAULT_MESSAGE_LEN, &nameBuf);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (resBuf);
return err;
}
/*-------------------------------------------------------*/
/* Initialize input buffer and check for errors. The */
/* output buffer does not need to be initialized. This */
/* buffer will be initialized to DSV_READ operations. */
/*-------------------------------------------------------*/
err=NWDSInitBuf (context, DSV_READ, nameBuf);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (resBuf);
NWDSFreeBuf (nameBuf);
return err;
}
/*-------------------------------------------------------*/
/* Put object attributes that are to be read into the */
/* input buffer. */
/*-------------------------------------------------------*/
for (i=0; i < totAttr; i++)
{
err= NWDSPutAttrName (context, nameBuf, attributes[i]);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (resBuf);
NWDSFreeBuf (nameBuf);
return err;
}
}
/*-------------------------------------------------------*/
/* Read the data. */
/*-------------------------------------------------------*/
iterHandle=NO_MORE_ITERATIONS;
do
{
err=NWDSRead (context, soldierObjData.name, DS_ATTRIBUTE_VALUES,
FALSE, nameBuf, &iterHandle, resBuf);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (resBuf);
NWDSFreeBuf (nameBuf);
return err;
}
/*-----------------------------------------------------*/
/* pull stuff out of the output buffer, checking for */
/* errors. First, get total number of attributes in */
/* the buffer. */
/*-----------------------------------------------------*/
err=NWDSGetAttrCount (context, resBuf, &totAttr);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (resBuf);
NWDSFreeBuf (nameBuf);
return err;
}
for (i=0; i< totAttr; i++)
{
err=NWDSGetAttrName (context, resBuf, attrName, &valCount, &synID);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (resBuf);
NWDSFreeBuf (nameBuf);
return err;
}
if (lstrcmp (attrName, "Surname") == 0)
{
err=NWDSGetAttrVal (context, resBuf, synID, soldierObjData.surname);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (resBuf);
NWDSFreeBuf (nameBuf);
return err;
}
}
else if (lstrcmp (attrName, "Rank") == 0)
{
err=NWDSGetAttrVal (context, resBuf, synID, soldierObjData.rank);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (resBuf);
NWDSFreeBuf (nameBuf);
return err;
}
}
else if (lstrcmp (attrName, "Military Serial Number") == 0)
{
err=NWDSGetAttrVal (context, resBuf, synID, soldierObjData.serialNo);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (resBuf);
NWDSFreeBuf (nameBuf);
return err;
}
}
}
} while (iterHandle != NO_MORE_ITERATIONS) ;
NWDSFreeContext (context);
NWDSFreeBuf (resBuf);
NWDSFreeBuf (nameBuf);
return 0;
}
/*-------------------------------------------------------------------------*/
/* Function : ModifyObjectData (void) */
/* Description : */
/* Modifies a Soldier Object's Attribute Values */
/*-------------------------------------------------------------------------*/
int ModifyObjectData (char *name)
{
NWDSContextHandle context;
int err=0, i, j;
Buf_T *inpBuf;
uint32 flags;
uint32 syntaxID;
context = NWDSCreateContext();
if (context == (NWDSContextHandle) ERR_CONTEXT_CREATION)
return ((int) context);
err=NWDSSetContext (context, DCK_NAME_CONTEXT, DS_ROOT_NAME);
if (err < 0)
{
NWDSFreeContext (context);
return err;
}
err = NWDSGetContext (context, DCK_FLAGS, (void *)&flags);
flags |= DCV_TYPELESS_NAMES;
flags |= DCV_XLATE_STRINGS;
flags |= DCV_DEREF_ALIASES;
flags |= DCV_DEREF_BASE_CLASS;
err = NWDSSetContext (context, DCK_FLAGS, (void *)&flags) ;
err=NWDSAllocBuf (DEFAULT_MESSAGE_LEN, &inpBuf);
if (err < 0)
{
NWDSFreeContext (context);
return err;
}
err=NWDSInitBuf (context, DSV_MODIFY_ENTRY, inpBuf);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
/*------------------------------------------------------------*/
/* Handle modifications of the Surname attribute */
/*------------------------------------------------------------*/
if (strcmp (soldierObjData.surname, soldierObjData.surnameChange) != 0)
{
if (soldierObjData.surname[0])
{
err = NWDSPutChange (context, inpBuf, DS_REMOVE_VALUE, "Surname");
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
err = NWDSPutAttrVal (context, inpBuf, SYN_CI_STRING,
soldierObjData.surname);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
}
err = NWDSPutChange (context, inpBuf, DS_ADD_VALUE, "Surname");
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
err = NWDSPutAttrVal (context, inpBuf, SYN_CI_STRING,
soldierObjData.surnameChange);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
}
/*------------------------------------------------------------*/
/* Handle modifications of the Rank attribute */
/*------------------------------------------------------------*/
if (strcmp (soldierObjData.rank, soldierObjData.rankChange) != 0)
{
if (soldierObjData.rank[0])
{
err = NWDSPutChange (context, inpBuf, DS_REMOVE_VALUE, "Rank");
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
err = NWDSPutAttrVal (context, inpBuf, SYN_CI_STRING,
soldierObjData.rank);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
}
err = NWDSPutChange (context, inpBuf, DS_ADD_VALUE, "Rank");
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
err = NWDSPutAttrVal (context, inpBuf, SYN_CI_STRING,
soldierObjData.rankChange);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
}
/*------------------------------------------------------------*/
/* Handle modifications of the Military Serial Number attr */
/*------------------------------------------------------------*/
if (strcmp (soldierObjData.serialNo, soldierObjData.serialNoChange) != 0)
{
if (soldierObjData.serialNo[0])
{
err = NWDSPutChange (context, inpBuf, DS_REMOVE_VALUE,
"Military Serial Number");
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
err = NWDSPutAttrVal (context, inpBuf, SYN_CI_STRING,
soldierObjData.serialNo);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
}
err = NWDSPutChange (context, inpBuf, DS_ADD_VALUE,
"Military Serial Number");
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
err = NWDSPutAttrVal (context, inpBuf, SYN_CI_STRING,
soldierObjData.serialNoChange);
if (err < 0)
{
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}
}
/*---------------------------------------------------------------*/
/* Finally, send the buffer with modification requests to DS */
/*---------------------------------------------------------------*/
err= NWDSModifyObject (context, name, NULL, 0, inpBuf);
NWDSFreeContext (context);
NWDSFreeBuf (inpBuf);
return err;
}