NWDSCCODE nds_login(
NWDSContextHandle ctx,
const NWDSChar* objectName,
const char *objectPassword) {
NWCONN_HANDLE conn;
NWObjectID objectID;
NWObjectID pseudoID;
nuint8 rndseed[4];
nuint8* serverPublicKey;
NWDSCCODE err;
size_t pwdLen;
nuint8 pwdHash[16];
nuint8* privKey;
size_t privKeyLen;
nuint8 logindata[8];
NWDSCCODE grace_err;
wchar_t unaliasedName[MAX_DN_CHARS + 1];
NWDSContextHandle wctx;
err = __NWDSGenerateObjectKeyPairStep1(ctx, objectName,
&conn, &objectID, &pseudoID, rndseed,
&serverPublicKey);
if (err)
return err;
err = NWDSDuplicateContextHandleInt(ctx, &wctx);
if (err) {
__NWDSGenerateObjectKeyPairStep3(conn, serverPublicKey);
return err;
}
err = NWDSMapIDToName(wctx, conn, objectID, (NWDSChar*)unaliasedName);
if (err) {
NWDSFreeContext(wctx);
__NWDSGenerateObjectKeyPairStep3(conn, serverPublicKey);
return err;
}
/* compute key... */
pwdLen = strlen(objectPassword);
/* BEWARE! other NWDS*Password functions do NOT uppercase password */
__NWDSHashPasswordUpper(objectPassword, pseudoID, pwdLen, pwdHash);
grace_err = __NWDSGetPrivateKey(conn, serverPublicKey,
rndseed, objectID, pwdHash, logindata, &privKey, &privKeyLen);
__NWDSGenerateObjectKeyPairStep3(conn, serverPublicKey);
if (!grace_err || grace_err == NWE_PASSWORD_EXPIRED) {
err = NWDSSetKeys(wctx, logindata, unaliasedName, privKey, privKeyLen);
memset(privKey, 0, privKeyLen);
free(privKey);
if (err)
goto err_exit;
}
err = grace_err;
err_exit:
NWDSFreeContext(wctx);
memset(logindata, 0, sizeof(logindata));
return err;
}
static NWDSCCODE __NWDSGenerateObjectKeyPairStep1(
NWDSContextHandle ctx,
const NWDSChar* objectName,
NWCONN_HANDLE* conn,
NWObjectID* objectID,
NWObjectID* oldPseudoID,
nuint8 rndseed[4],
nuint8** connPublicKey
) {
NWDSCCODE err;
NWDSContextHandle unictx;
NWCONN_HANDLE lconn;
*connPublicKey = NULL;
err = NWDSResolveName2DR(ctx, objectName, DS_RESOLVE_DEREF_ALIASES | DS_RESOLVE_WRITEABLE,
&lconn, objectID);
if (err)
return err;
err = __NWDSBeginLoginV0(lconn, *objectID, oldPseudoID, rndseed);
if (err)
goto err_free_conn;
err = NWDSDuplicateContextHandle(ctx, &unictx);
if (err)
goto err_free_conn;
unictx->dck.flags = DCV_TYPELESS_NAMES | DCV_XLATE_STRINGS;
err = NWDSSetContext(unictx, DCK_LOCAL_CHARSET, "WCHAR_T//");
if (err)
goto err_free_ctx_conn;
err = __NWDSGetPublicKeyFromConnection(unictx, lconn, connPublicKey);
NWDSFreeContext(unictx);
if (err)
goto err_free_conn;
*conn = lconn;
return 0;
err_free_ctx_conn:;
NWDSFreeContext(unictx);
err_free_conn:;
NWCCCloseConn(*conn);
return err;
}
void Cleanup (void)
{
NWDSCCODE res;
// set the auto screen destroy mode based on the command line arguments
SetAutoScreenDestructionMode (AutoDestroyScreen);
// if we logged in, we should logout
if (DoLogin == 1)
if ((res = NWDSLogout (NDSContext)) != 0)
printf ("NWDSLogout returned: %d\n", res);
// free the context handle
if ((res = NWDSFreeContext (NDSContext)) != 0)
printf ("NWDSFreeContext returned: %d\n", res);
// decrement the thread counter
ThreadCount--;
}
int main(int argc, char *argv[]) {
NWDSCCODE dserr;
NWDSContextHandle ctx;
NWCONN_HANDLE conn;
const char* objectname = "[Root]";
const char* context = "OrgUnit.Org.Country";
const char* server = "CDROM";
const char* pwd = "TEST";
int opt;
int raw = 0;
int ret = 2;
u_int32_t ctxflag = 0;
u_int32_t confidence = 0;
#ifndef N_PLAT_MSW4
setlocale(LC_ALL, "");
bindtextdomain(NCPFS_PACKAGE, LOCALEDIR);
textdomain(NCPFS_PACKAGE);
#endif
progname = argv[0];
NWCallsInit(NULL, NULL);
#ifndef N_PLAT_MSW4
NWDSInitRequester();
#endif
dserr = NWDSCreateContextHandle(&ctx);
if (dserr) {
fprintf(stderr, "NWDSCretateContextHandle failed with %s\n", strnwerror(dserr));
return 123;
}
while ((opt = getopt(argc, argv, "h?o:c:v:S:C:P:r")) != EOF)
{
switch (opt)
{
case 'C':
confidence = strtoul(optarg, NULL, 0);
break;
case 'o':
objectname = optarg;
break;
case 'c':
context = optarg;
break;
case 'P':
pwd = optarg;
break;
case 'v':
ctxflag = strtoul(optarg, NULL, 0);
break;
case 'h':
case '?':
help();
goto finished;
case 'S':
server = optarg;
break;
case 'r':
raw = 1;
break;
default:
usage();
goto finished;
}
}
if (!raw) {
char* p;
char c;
for (p = pwd; (c = *p) != 0; p++) {
if (islower(c))
*p = toupper(c);
}
}
ctxflag |= DCV_XLATE_STRINGS;
dserr = NWDSSetContext(ctx, DCK_FLAGS, &ctxflag);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_FLAGS) failed: %s\n",
strnwerror(dserr));
return 123;
}
dserr = NWDSSetContext(ctx, DCK_NAME_CONTEXT, context);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_NAME_CONTEXT) failed: %s\n",
strnwerror(dserr));
return 122;
}
dserr = NWDSSetContext(ctx, DCK_CONFIDENCE, &confidence);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_CONFIDENCE) failed: %s\n",
strnwerror(dserr));
return 122;
}
#ifndef N_PLAT_MSW4
{
static const u_int32_t add[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
dserr = NWDSSetTransport(ctx, 16, add);
if (dserr) {
fprintf(stderr, "NWDSSetTransport failed: %s\n",
strnwerror(dserr));
return 124;
}
}
#endif
#ifdef N_PLAT_MSW4
dserr = NWDSOpenConnToNDSServer(ctx, server, &conn);
#else
if (server[0] == '/') {
dserr = ncp_open_mount(server, &conn);
if (dserr) {
fprintf(stderr, "ncp_open_mount failed with %s\n",
strnwerror(dserr));
return 111;
}
} else {
struct ncp_conn_spec connsp;
long err;
memset(&connsp, 0, sizeof(connsp));
strcpy(connsp.server, server);
conn = ncp_open(&connsp, &err);
if (!conn) {
fprintf(stderr, "ncp_open failed with %s\n",
strnwerror(err));
return 111;
}
}
dserr = NWDSAddConnection(ctx, conn);
#endif
if (dserr) {
fprintf(stderr, "Cannot bind connection to context: %s\n",
strnwerror(dserr));
}
dserr = NWDSVerifyObjectPassword(ctx, NDS_PASSWORD, objectname, pwd);
if (dserr) {
fprintf(stderr, "Verify password failed: %s\n",
strnwerror(dserr));
ret = 1;
} else {
ret = 0;
}
NWCCCloseConn(conn);
dserr = NWDSFreeContext(ctx);
if (dserr) {
fprintf(stderr, "NWDSFreeContext failed with %s\n", strnwerror(dserr));
return 121;
}
finished:
return ret;
}
int main(int argc, char *argv[]) {
NWDSCCODE dserr;
NWDSContextHandle ctx;
NWCONN_HANDLE conn;
const char* context = "[Root]";
const char * server=NULL;
const char * scanFilter="*";
int allTrees=1;
int opt;
u_int32_t ctxflag = 0;
u_int32_t confidence = 0;
long err;
#ifndef N_PLAT_MSW4
setlocale(LC_ALL, "");
bindtextdomain(NCPFS_PACKAGE, LOCALEDIR);
textdomain(NCPFS_PACKAGE);
#endif
progname = argv[0];
NWCallsInit(NULL, NULL);
#ifndef N_PLAT_MSW4
NWDSInitRequester();
#endif
dserr = NWDSCreateContextHandle(&ctx);
if (dserr) {
fprintf(stderr, "NWDSCreateContextHandle failed with %s\n", strnwerror(dserr));
return 123;
}
while ((opt = getopt(argc, argv, "h?c:v:S:C:F:f:a")) != EOF)
{
switch (opt)
{
case 'C':
confidence = strtoul(optarg, NULL, 0);
break;
case 'c':
context = optarg;
break;
case 'a':
allTrees=0;
break;
case 'v':
ctxflag = strtoul(optarg, NULL, 0);
break;
case 'h':
case '?':
help();
goto finished;
case 'S':
server = optarg;
break;
case 'F':
case 'f':
scanFilter =optarg; break;
default:
usage();
goto finished;
}
}
ctxflag |= DCV_XLATE_STRINGS;
dserr = NWDSSetContext(ctx, DCK_FLAGS, &ctxflag);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_FLAGS) failed: %s\n",
strnwerror(dserr));
return 123;
}
dserr = NWDSSetContext(ctx, DCK_NAME_CONTEXT, context);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_NAME_CONTEXT) failed: %s\n",
strnwerror(dserr));
err = 122;
goto closing_ctx;
}
dserr = NWDSSetContext(ctx, DCK_CONFIDENCE, &confidence);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_CONFIDENCE) failed: %s\n",
strnwerror(dserr));
err=121;
goto closing_ctx;
}
#ifndef N_PLAT_MSW4
{
static const u_int32_t add[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
dserr = NWDSSetTransport(ctx, 16, add);
if (dserr) {
fprintf(stderr, "NWDSSetTransport failed: %s\n",
strnwerror(dserr));
err= 124;
goto closing_ctx;
}
}
#endif
#ifdef N_PLAT_MSW4
dserr = NWDSOpenConnToNDSServer(ctx, server, &conn);
#else
{
conn=ncp_initialize(&argc,argv,0,&err); /* no login required*/
if (!conn) {
fprintf(stderr, "ncp_initialize failed with %s\n",strnwerror(err));
err= 111;
goto closing_ctx;
}
}
dserr = NWDSAddConnection(ctx, conn);
#endif
if (dserr) {
fprintf(stderr, "failed: Cannot bind connection to context: %s\n",
strnwerror(dserr));
err=dserr;
goto closing_all;
}
// testing code goes here
{
#define NB 64
nuint32 i,cnt,totTrees;
char* table[NB];
char * nextBlock;
for (i=0;i<NB;i++) {
table[i]=(char *)malloc (MAX_TREE_NAME_CHARS);
if (!table[i]) {
fprintf(stderr, "failed: out of memory\n");
}
}
if (allTrees) {
/* request a count only*/
err=NWDSReturnBlockOfAvailableTrees (ctx,conn,scanFilter,NULL,NULL,0,NULL,NULL,&totTrees);
if (err) {
fprintf(stderr, "NWDSReturnBlockOfAvailableTres failed: %s\n",strnwerror(err));
goto closing_all;
}
nextBlock=NULL;
do {
if (totTrees >NB)
totTrees=NB;
err=NWDSReturnBlockOfAvailableTrees (ctx,conn,scanFilter,nextBlock,NULL,totTrees,table,&cnt,&totTrees);
if (err) {
fprintf(stderr, "NWDSReturnBlockOfAvailableTrees failed: %s\n",strnwerror(err));
goto closing_all;
}
for (i=0; i<cnt;i++) {
printf( "%s\n",table[i]);
}
nextBlock=table[cnt-1];
} while (cnt);
}else {
err=NWDSScanConnsForTrees (ctx,NB,&totTrees,table);
if (err) {
fprintf(stderr, "NWDSScanConnsForTreesfailed: %s\n",strnwerror(err));
goto closing_all;
}
for (i=0; i<totTrees;i++) {
printf( "%s\n",table[i]);
}
}
/* end of test block*/
}
err=0;
closing_all:
NWCCCloseConn(conn);
closing_ctx:
dserr = NWDSFreeContext(ctx);
if (dserr) {
fprintf(stderr, "NWDSFreeContext failed with %s\n", strnwerror(dserr));
return 121;
}
finished:
return err;
}
int main(int argc, char *argv[]) {
NWDSCCODE dserr;
NWDSContextHandle ctx;
NWCONN_HANDLE conn;
const char* context = "[Root]";
const char* server = "CDROM.VC.CVUT.CZ";
int opt;
u_int32_t ctxflag = 0;
u_int32_t confidence = 0;
#ifdef N_PLAT_LINUX
setlocale(LC_ALL, "");
bindtextdomain(NCPFS_PACKAGE, LOCALEDIR);
textdomain(NCPFS_PACKAGE);
#endif
progname = argv[0];
NWCallsInit(NULL, NULL);
dserr = NWDSCreateContextHandle(&ctx);
if (dserr) {
fprintf(stderr, "NWDSCretateContextHandle failed with %s\n", strnwerror(dserr));
return 123;
}
while ((opt = getopt(argc, argv, "h?o:c:v:S:C:t:")) != EOF)
{
switch (opt)
{
case 'C':
confidence = strtoul(optarg, NULL, 0);
break;
case 'c':
context = optarg;
break;
case 'v':
ctxflag = strtoul(optarg, NULL, 0);
break;
case 'h':
case '?':
help();
goto finished;
case 'S':
server = optarg;
break;
default:
usage();
goto finished;
}
}
ctxflag |= DCV_XLATE_STRINGS;
dserr = NWDSSetContext(ctx, DCK_FLAGS, &ctxflag);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_FLAGS) failed: %s\n",
strnwerror(dserr));
return 123;
}
dserr = NWDSSetContext(ctx, DCK_NAME_CONTEXT, context);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_NAME_CONTEXT) failed: %s\n",
strnwerror(dserr));
return 122;
}
dserr = NWDSSetContext(ctx, DCK_CONFIDENCE, &confidence);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_CONFIDENCE) failed: %s\n",
strnwerror(dserr));
return 122;
}
#ifdef N_PLAT_LINUX
{
static const u_int32_t add[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
dserr = NWDSSetTransport(ctx, 16, add);
if (dserr) {
fprintf(stderr, "NWDSSetTransport failed: %s\n",
strnwerror(dserr));
return 124;
}
}
if (server[0] == '/') {
dserr = ncp_open_mount(server, &conn);
if (dserr) {
fprintf(stderr, "ncp_open_mount failed with %s\n",
strnwerror(dserr));
return 111;
}
} else {
struct ncp_conn_spec connsp;
long err;
memset(&connsp, 0, sizeof(connsp));
strcpy(connsp.server, server);
conn = ncp_open(&connsp, &err);
if (!conn) {
fprintf(stderr, "ncp_open failed with %s\n",
strnwerror(err));
return 111;
}
}
dserr = NWDSAddConnection(ctx, conn);
#else
dserr = NWDSOpenConnToNDSServer(ctx, server, &conn);
#endif
if (dserr) {
fprintf(stderr, "Cannot bind connection to context: %s\n",
strnwerror(dserr));
}
DemoGetTime(conn);
printf("Waiting 500 ms\n");
#ifdef N_PLAT_LINUX
usleep(500000);
#else
Sleep(500);
#endif
DemoGetTime(conn);
DemoGetVersion(conn);
DemoGetGarbage(conn);
NWCCCloseConn(conn);
dserr = NWDSFreeContext(ctx);
if (dserr) {
fprintf(stderr, "NWDSFreeContext failed with %s\n", strnwerror(dserr));
return 121;
}
finished:
return 0;
}
int main(int argc, char *argv[]) {
NWDSCCODE dserr;
NWDSContextHandle ctx;
NWCONN_HANDLE conn;
const char* objectname = "[Root]";
const char* context = "OrgUnit.Org.Country";
const char* server = "CDROM";
int opt;
u_int32_t ctxflag = 0;
u_int32_t confidence = 0;
u_int32_t req = 0;
int req_present = 0;
nuint32 ih = NO_MORE_ITERATIONS;
Buf_T* buf;
size_t size = DEFAULT_MESSAGE_LEN;
#ifndef N_PLAT_MSW4
setlocale(LC_ALL, "");
bindtextdomain(NCPFS_PACKAGE, LOCALEDIR);
textdomain(NCPFS_PACKAGE);
#endif
progname = argv[0];
NWCallsInit(NULL, NULL);
#ifndef N_PLAT_MSW4
NWDSInitRequester();
#endif
dserr = NWDSCreateContextHandle(&ctx);
if (dserr) {
fprintf(stderr, "NWDSCretateContextHandle failed with %s\n", strnwerror(dserr));
return 123;
}
while ((opt = getopt(argc, argv, "h?o:c:v:S:C:q:s:")) != EOF)
{
switch (opt)
{
case 'C':
confidence = strtoul(optarg, NULL, 0);
break;
case 'o':
objectname = optarg;
break;
case 'c':
context = optarg;
break;
case 'v':
ctxflag = strtoul(optarg, NULL, 0);
break;
case 'q':
req = strtoul(optarg, NULL, 0);
req_present = 1;
break;
case 's':
size = strtoul(optarg, NULL, 0);
break;
case 'h':
case '?':
help();
goto finished;
case 'S':
server = optarg;
break;
default:
usage();
goto finished;
}
}
ctxflag |= DCV_XLATE_STRINGS;
dserr = NWDSSetContext(ctx, DCK_FLAGS, &ctxflag);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_FLAGS) failed: %s\n",
strnwerror(dserr));
return 123;
}
dserr = NWDSSetContext(ctx, DCK_NAME_CONTEXT, context);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_NAME_CONTEXT) failed: %s\n",
strnwerror(dserr));
return 122;
}
dserr = NWDSSetContext(ctx, DCK_CONFIDENCE, &confidence);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_CONFIDENCE) failed: %s\n",
strnwerror(dserr));
return 122;
}
#ifndef N_PLAT_MSW4
{
static const u_int32_t add[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
dserr = NWDSSetTransport(ctx, 16, add);
if (dserr) {
fprintf(stderr, "NWDSSetTransport failed: %s\n",
strnwerror(dserr));
return 124;
}
}
#endif
#ifdef N_PLAT_MSW4
dserr = NWDSOpenConnToNDSServer(ctx, server, &conn);
#else
if (server[0] == '/') {
dserr = ncp_open_mount(server, &conn);
if (dserr) {
fprintf(stderr, "ncp_open_mount failed with %s\n",
strnwerror(dserr));
return 111;
}
} else {
struct ncp_conn_spec connsp;
long err;
memset(&connsp, 0, sizeof(connsp));
strcpy(connsp.server, server);
conn = ncp_open(&connsp, &err);
if (!conn) {
fprintf(stderr, "ncp_open failed with %s\n",
strnwerror(err));
return 111;
}
}
dserr = NWDSAddConnection(ctx, conn);
#endif
if (dserr) {
fprintf(stderr, "Cannot bind connection to context: %s\n",
strnwerror(dserr));
}
dserr = NWDSAllocBuf(size, &buf);
if (dserr) {
fprintf(stderr, "Cannot create reply buffer: %s\n",
strnwerror(dserr));
}
do {
if (req_present)
dserr = NWDSListPartitionsExtInfo(ctx, &ih, objectname, req, buf);
else
dserr = NWDSListPartitions(ctx, &ih, objectname, buf);
if (dserr) {
fprintf(stderr, "ListPartitions failed with %s\n",
strnwerror(dserr));
} else {
unsigned char* pp;
NWObjectCount cnt;
char sn[MAX_DN_CHARS + 1];
size_t pcnt;
printf("Iteration handle: %08X\n", ih);
dserr = NWDSGetServerName(ctx, buf, sn, &cnt);
if (dserr) {
fprintf(stderr, "GetServerName failed with %s\n",
strnwerror(dserr));
} else {
pcnt = 0;
printf("Server %s holds %u partitions\n",
sn, cnt);
while (!dserr && cnt--) {
printf("Partition #%u\n", pcnt++);
if (req_present) {
char* start;
char* end;
dserr = NWDSGetPartitionExtInfoPtr(
ctx, buf, &start, &end);
if (dserr) {
fprintf(stderr, " NWDSGetPartitionExtInfoPtr failed with %s\n",
strnwerror(dserr));
} else {
nuint32 pt;
union {
nuint32 x32;
TimeStamp_T ts;
NWObjectID id;
char name[MAX_DN_CHARS + 1];
} info;
nuint32 bit;
size_t len;
printf(" Partition info length: %10u\n", end - start);
if (req & DSP_OUTPUT_FIELDS) {
dserr = NWDSGetPartitionExtInfo(ctx, start, end, DSP_OUTPUT_FIELDS, &len, &pt);
if (dserr) {
fprintf(stderr, " NWDSGetPartitionExtInfo(DSP_OUTPUT_FIELDS) failed with %s\n",
strnwerror(dserr));
pt = req;
} else {
printf(" Output fields: %08X (%u bytes)\n", pt, len);
}
} else {
pt = req;
}
for (bit = DSP_PARTITION_ID; bit; bit <<= 1) {
if (pt & bit) {
dserr = NWDSGetPartitionExtInfo(ctx, start, end, bit, &len, &info);
if (dserr)
fprintf(stderr, " NWDSGetPartitionExtInfo(0x%08X) failed with %s\n",
bit, strnwerror(dserr));
else {
switch (bit) {
case DSP_PARTITION_ID:
printf(" Partition ID: %08X (%u bytes)\n", info.id, len);
break;
case DSP_REPLICA_STATE:
printf(" Replica state: %10u (%u bytes)\n", info.x32, len);
break;
case DSP_MODIFICATION_TIMESTAMP:
printf(" Modification timestamp: %10u.%u.%u (%u bytes)\n",
info.ts.wholeSeconds, info.ts.replicaNum,
info.ts.eventID, len);
break;
case DSP_PURGE_TIME:
printf(" Purge time: %10u (%u bytes)\n",
info.x32, len);
break;
case DSP_LOCAL_PARTITION_ID:
printf(" Local partition ID: %10u (%u bytes)\n",
info.x32, len);
break;
case DSP_PARTITION_DN:
printf(" Partition DN: %s (%u bytes)\n",
info.name, len);
break;
case DSP_REPLICA_TYPE:
printf(" Replica type: %10u (%u bytes)\n",
info.x32, len);
break;
case DSP_PARTITION_BUSY:
printf(" Partition busy: %10u (%u bytes)\n",
info.x32, len);
break;
default:
printf(" Unknown %08X: %10u (%u bytes)\n",
bit, info.x32, len);
break;
}
}
}
}
}
} else {
nuint32 pt;
dserr = NWDSGetPartitionInfo(ctx, buf, sn, &pt);
if (dserr) {
fprintf(stderr, " NWDSGetPartitionInfo failed with %s\n",
strnwerror(dserr));
} else {
printf(" Partition DN: %s\n", sn);
printf(" Replica type: %u\n", pt);
}
}
#if 0
Object_Info_T tt;
char name[8192];
size_t attrs;
dserr = NWDSGetObjectName(ctx, buf, name, &attrs, &tt);
if (dserr) {
fprintf(stderr, "GetObjectName failed with %s\n",
strnwerror(dserr));
break;
}
printf("Name: %s\n", name);
printf(" Attrs: %u\n", attrs);
printf(" Flags: %08X\n", tt.objectFlags);
printf(" Subordinate Count: %u\n", tt.subordinateCount);
printf(" Modification Time: %lu\n", tt.modificationTime);
printf(" Base Class: %s\n", tt.baseClass);
#endif
}
}
#ifndef N_PLAT_MSW4
pp = buf->curPos;
for (; pp < buf->dataend; pp++) {
printf("%02X ", *pp);
}
printf("\n");
#endif
}
} while ((dserr == 0) && (ih != NO_MORE_ITERATIONS));
NWCCCloseConn(conn);
dserr = NWDSFreeContext(ctx);
if (dserr) {
fprintf(stderr, "NWDSFreeContext failed with %s\n", strnwerror(dserr));
return 121;
}
finished:
return 0;
}
int main(int argc, char *argv[]) {
NWDSCCODE dserr;
NWDSContextHandle ctx;
NWCONN_HANDLE conn;
const char* objectname = "[Root]";
const char* context = "OrgUnit.Org.Country";
const char* server = "CDROM";
int opt;
u_int32_t ctxflag = 0;
u_int32_t confidence = 0;
Buf_T* buf;
size_t size = DEFAULT_MESSAGE_LEN;
#ifndef N_PLAT_MSW4
setlocale(LC_ALL, "");
bindtextdomain(NCPFS_PACKAGE, LOCALEDIR);
textdomain(NCPFS_PACKAGE);
#endif
progname = argv[0];
NWCallsInit(NULL, NULL);
#ifndef N_PLAT_MSW4
NWDSInitRequester();
#endif
dserr = NWDSCreateContextHandle(&ctx);
if (dserr) {
fprintf(stderr, "NWDSCretateContextHandle failed with %s\n", strnwerror(dserr));
return 123;
}
dserr = NWDSAllocBuf(size, &buf);
if (dserr) {
fprintf(stderr, "Cannot create request buffer: %s\n",
strnwerror(dserr));
}
dserr = NWDSInitBuf(ctx, DSV_MODIFY_CLASS_DEF, buf);
if (dserr) {
fprintf(stderr, "Cannot init buffer: %s\n",
strnwerror(dserr));
}
while ((opt = getopt(argc, argv, "h?o:c:v:S:C:s:A:")) != EOF)
{
switch (opt)
{
case 'C':
confidence = strtoul(optarg, NULL, 0);
break;
case 'o':
objectname = optarg;
break;
case 'c':
context = optarg;
break;
case 'v':
ctxflag = strtoul(optarg, NULL, 0);
break;
case 's':
size = strtoul(optarg, NULL, 0);
break;
case 'A':
dserr = NWDSPutClassItem(ctx, buf, optarg);
if (dserr) {
fprintf(stderr, "Cannot NWDSPutClassItem `%s': %s\n",
optarg, strnwerror(dserr));
}
break;
case 'h':
case '?':
help();
goto finished;
case 'S':
server = optarg;
break;
default:
usage();
goto finished;
}
}
ctxflag |= DCV_XLATE_STRINGS;
dserr = NWDSSetContext(ctx, DCK_FLAGS, &ctxflag);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_FLAGS) failed: %s\n",
strnwerror(dserr));
return 123;
}
dserr = NWDSSetContext(ctx, DCK_NAME_CONTEXT, context);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_NAME_CONTEXT) failed: %s\n",
strnwerror(dserr));
return 122;
}
dserr = NWDSSetContext(ctx, DCK_CONFIDENCE, &confidence);
if (dserr) {
fprintf(stderr, "NWDSSetContext(DCK_CONFIDENCE) failed: %s\n",
strnwerror(dserr));
return 122;
}
#ifndef N_PLAT_MSW4
{
static const u_int32_t add[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
dserr = NWDSSetTransport(ctx, 16, add);
if (dserr) {
fprintf(stderr, "NWDSSetTransport failed: %s\n",
strnwerror(dserr));
return 124;
}
}
#endif
#ifdef N_PLAT_MSW4
dserr = NWDSOpenConnToNDSServer(ctx, server, &conn);
#else
if (server[0] == '/') {
dserr = ncp_open_mount(server, &conn);
if (dserr) {
fprintf(stderr, "ncp_open_mount failed with %s\n",
strnwerror(dserr));
return 111;
}
} else {
struct ncp_conn_spec connsp;
long err;
memset(&connsp, 0, sizeof(connsp));
strcpy(connsp.server, server);
conn = ncp_open(&connsp, &err);
if (!conn) {
fprintf(stderr, "ncp_open failed with %s\n",
strnwerror(err));
return 111;
}
}
dserr = NWDSAddConnection(ctx, conn);
#endif
if (dserr) {
fprintf(stderr, "Cannot bind connection to context: %s\n",
strnwerror(dserr));
}
dserr = NWDSModifyClassDef(ctx, objectname, buf);
if (dserr) {
fprintf(stderr, "ModifyClassDef failed with %s\n",
strnwerror(dserr));
} else {
printf("ModifyClassDef suceeded\n");
}
NWCCCloseConn(conn);
dserr = NWDSFreeContext(ctx);
if (dserr) {
fprintf(stderr, "NWDSFreeContext failed with %s\n", strnwerror(dserr));
return 121;
}
finished:
return 0;
}
/*************************************************************************
** main
*/
int main (int argc, char** argv) {
NWDSContextHandle context;
NWDSCCODE ccode;
nint32 iterationHandle;
nint32 countObjectsSearched;
nuint32 objCntr,attrCntr,valCntr;
nuint32 objCount;
nuint32 attrCount;
char admin[MAX_DN_CHARS+1];
char password[MAX_VALUE_LEN+1];
char objectName[MAX_DN_CHARS+1];
char attrName[MAX_SCHEMA_NAME_CHARS+1];
nuint32 attrValCount;
nuint32 syntaxID;
nuint32 attrValSize;
char* attrVal;
nint32 screenCntr=0;
nuint32 contextFlags;
// buffers
pBuf_T searchFilter=NULL; // search filter
pBuf_T retBuf=NULL; // result buffer for NWDSSearch
pBuf_T attrNames=NULL; // specify which attribute values to return
Filter_Cursor_T* cur=NULL; // search expression tree temporary buffer
Object_Info_T objectInfo;
/*******************************************************************
create context and set current context to Root
*******************************************************************/
ccode = NWDSCreateContextHandle(&context);
if((long)context == ERR_CONTEXT_CREATION) {
printf("Error creating context.\n");
goto Exit1;
}
ccode=NWDSSetContext(context, DCK_NAME_CONTEXT, "[Root]");
if(ccode){
printf("Error NWDSSetContext(): %d\n",ccode);
goto Exit2;
}
ccode= NWDSGetContext(context, DCK_FLAGS, &contextFlags);
if( ccode != 0)
{
printf("NWDSGetContext (DCK_FLAGS) failed, returns %d\n", ccode);
}
contextFlags|= DCV_TYPELESS_NAMES;
/*****************************************************
In order to see the problem, first compile, and run with the line below
commented out. The program will display a list of users on the NDS.
Now, un-comment the line belog, compile, and re-run the NLM, and the
NWDSSearch function fails with error code -601
*****************************************************/
/* contextFlags &= ~DCV_XLATE_STRINGS; */
ccode= NWDSSetContext( context, DCK_FLAGS, &contextFlags);
if( ccode != 0)
{
printf("NWDSSetContext (DCK_FLAGS DCV_TYPELESS_NAMES) failed, returns %d\n", ccode);
}
/*******************************************************************
Login to NDS
*/
//ccode = NWDSLoginAsServer( context );
{
NWCONN_HANDLE conn;
// ccode = ncp_open_mount("/root/fdnet", &conn);
ccode = NWCCOpenConnByName(NULL, "FDNET", NWCC_NAME_FORMAT_BIND, 0, 0, &conn);
if (!ccode)
NWDSAddConnection(context, conn);
}
if(ccode){
switch (ccode) {
case -601:
// user object not found
printf("User object not found: %s\n",admin);
break;
case -669:
// auth failed
printf("Failed authentication. Check Password\n");
break;
default:
printf("Error: NWDSLogin failed (%s) for %s\n",strnwerror(ccode),admin);
}
goto Exit2;
}
/*******************************************************************
In order to search, we need:
A Filter Cursor (to build the search expression)
A Filter Buffer (to store the expression; used by NWDSSearch)
A Buffer to store which attributes we need information on
A Result Buffer (to store the search results)
*/
/*******************************************************************
** Allocate Filter buffer and Cursor and populate
*/
ccode = NWDSAllocBuf(DEFAULT_MESSAGE_LEN,&searchFilter);
if (ccode < 0) {
printf("NWDSAllocBuf returned: %d\n", ccode);
goto Exit3;
}
// Initialize the searchFilter buffer
ccode = NWDSInitBuf(context,DSV_SEARCH_FILTER,searchFilter);
if (ccode < 0) {
printf("NWDSInitBuf returned: %d\n", ccode);
goto Exit4;
}
// Allocate a filter cursor to put the search expression
ccode = NWDSAllocFilter(&cur);
if (ccode < 0) {
printf("NWDSAllocFilter returned: %d\n", ccode);
goto Exit4;
}
// Build the expression tree in cur, then place into searchFilter
// Object Class = User
ccode = NWDSAddFilterToken(cur,FTOK_ANAME,"Object Class",SYN_CLASS_NAME);
if (ccode < 0) {
printf("NWDSAddFilterToken returned: %d\n", ccode);
goto Exit4;
}
ccode = NWDSAddFilterToken(cur,FTOK_EQ,NULL,0);
if (ccode < 0) {
printf("NWDSAddFilterToken returned: %d\n", ccode);
goto Exit4;
}
ccode = NWDSAddFilterToken(cur,FTOK_AVAL,"User",SYN_CLASS_NAME);
if (ccode < 0) {
printf("NWDSAddFilterToken returned: %d\n", ccode);
goto Exit4;
}
// now place the cursor into the searchFilter buffer
// NWDSPutFilter frees the expression tree filter (cur)
// so if it succeeds, set cur to NULL so it won't be
// freed below
ccode = NWDSPutFilter(context,searchFilter,cur,NULL);
if (ccode < 0) {
printf("NWDSPutFilter returned: %d\n", ccode);
goto Exit4;
}
else
cur=NULL;
/*******************************************************************
** Specify which attributes we want information on
*/
// allocate and initialize the attrNames buffer
ccode = NWDSAllocBuf(DEFAULT_MESSAGE_LEN,&attrNames);
if (ccode < 0) {
printf("NWDSAllocBuf returned: %d\n", ccode);
goto Exit4;
}
ccode = NWDSInitBuf(context,DSV_SEARCH,attrNames);
if (ccode < 0) {
printf("NWDSInitBuf returned: %d\n", ccode);
goto Exit4;
}
// specify the attributes to retrieve for the objects
// In this case: Given Name and Full Name
ccode = NWDSPutAttrName(context,attrNames,"Given Name");
if (ccode < 0) {
printf("NWDSPutAttrName returned: %d\n", ccode);
goto Exit4;
}
ccode = NWDSPutAttrName(context,attrNames,"Full Name");
if (ccode < 0) {
printf("NWDSPutAttrName returned: %d\n", ccode);
goto Exit4;
}
ccode = NWDSPutAttrName(context,attrNames,"Surname");
if (ccode < 0) {
printf("NWDSPutAttrName returned: %d\n", ccode);
goto Exit4;
}
ccode = NWDSPutAttrName(context,attrNames,"Title");
if (ccode < 0) {
printf("NWDSPutAttrName returned: %d\n", ccode);
goto Exit4;
}
/*******************************************************************
** Allocate a result buffer
*/
ccode = NWDSAllocBuf(65500,&retBuf);
if (ccode < 0) {
printf("NWDSAllocBuf returned: %d\n", ccode);
goto Exit4;
}
/*******************************************************************
** We are now ready to do the search
*/
iterationHandle = NO_MORE_ITERATIONS;
// while NWDSSearch still can get some objects...
do {
ccode = NWDSSearch(context,
"[Root]",
DS_SEARCH_SUBTREE,
FALSE, // don't dereference aliases
searchFilter,
TRUE, // we want attributes and values
FALSE, // only want information in attrNames
attrNames,
&iterationHandle,
0, // reserved
&countObjectsSearched,
retBuf);
if (ccode) {
printf("NWDSSearch returned: %s\n", strnwerror(ccode));
goto Exit4;
}
// count the object returned in the buffer
ccode = NWDSGetObjectCount(context,retBuf,&objCount);
if (ccode) {
printf("NWDSGetObjectCount returned: %d\n", ccode);
goto Exit4;
}
printf("Objects found: %d\n",objCount);
printf("-----------------------------------------\n");
screenCntr+=2;
// for the number of objects returned...
for (objCntr=0;objCntr<objCount;objCntr++) {
// get an object name
ccode = NWDSGetObjectName(context,retBuf,objectName,&attrCount,&objectInfo);
if (ccode) {
printf("NWDSGetObjectName returned: %d\n", ccode);
goto Exit4;
}
printf("%s\n",objectName);
screenCntr++;
// for the number of attributes returned with the object...
for (attrCntr=0;attrCntr<attrCount;attrCntr++) {
// get the attribute name
ccode = NWDSGetAttrName(context,retBuf,attrName,&attrValCount,&syntaxID);
if (ccode) {
printf("NWDSGetAttrName returned: %d\n", ccode);
goto Exit4;
}
// compute and allocate space for the value
ccode = NWDSComputeAttrValSize(context,retBuf,syntaxID,&attrValSize);
if (ccode) {
printf("NWDSComputeAttrValSize returned: %d\n", ccode);
goto Exit4;
}
attrVal = malloc(attrValSize);
// for the number of values returned with the attribute...
for (valCntr=0;valCntr<attrValCount;valCntr++) {
// get the value
ccode = NWDSGetAttrVal(context,retBuf,syntaxID,attrVal);
if (ccode) {
printf("NWDSGetAttrVal returned: %d\n", ccode);
goto Exit4;
}
printf(" %s =\t%s\n",attrName,attrVal);
screenCntr++;
} // valCntr
free(attrVal);
} // attrCntr
printf("\n");
} // objCntr
} while ((nuint32)iterationHandle != NO_MORE_ITERATIONS);
Exit4:
if (retBuf)
NWDSFreeBuf(retBuf);
if (cur)
NWDSFreeFilter(cur, NULL);
if (searchFilter)
NWDSFreeBuf(searchFilter);
if (attrNames)
NWDSFreeBuf(attrNames);
Exit3:
// NWDSLogout(context);
Exit2:
NWDSFreeContext(context);
Exit1:
exit(0);
}
