int main(int argc, char *argv[]) {
NWDSCCODE dserr;
NWCONN_HANDLE conn;
int opt;
struct NWCCRootEntry nwccre;
unsigned int searchattr = SA_ALL;
u_int32_t destns = NW_NS_DOS;
int searchmode = 0;
const char* sstr = "\xFF*";
setlocale(LC_ALL, "");
bindtextdomain(NCPFS_PACKAGE, LOCALEDIR);
textdomain(NCPFS_PACKAGE);
progname = argv[0];
NWCallsInit(NULL, NULL);
// NWDSInitRequester();
while ((opt = getopt(argc, argv, "h?n:s:m:")) != EOF)
{
switch (opt)
{
case 'n':
destns = strtoul(optarg, NULL, 0);
break;
case 's':
searchattr = strtoul(optarg, NULL, 0);
break;
case 'm':
searchmode = strtoul(optarg, NULL, 0);
break;
case 'h':
case '?':
help();
goto finished;
default:
usage();
goto finished;
}
}
/* NFS and MAC do not handle wildcards :-( */
if ((destns == NW_NS_NFS) || (destns == NW_NS_MAC))
sstr = NULL;
dserr = ncp_open_mount(argv[optind++], &conn);
if (dserr) {
fprintf(stderr, "ncp_open_mount failed: %s\n",
strnwerror(dserr));
return 123;
}
dserr = NWCCGetConnInfo(conn, NWCC_INFO_ROOT_ENTRY, sizeof(nwccre), &nwccre);
if (dserr) {
fprintf(stderr, "Cannot get entry info: %s\n",
strerror(dserr));
} else {
struct ncp_search_seq seq;
struct nw_info_struct nw;
dserr = ncp_obtain_file_or_subdir_info(conn, NW_NS_DOS, destns, SA_ALL, RIM_DIRECTORY,
nwccre.volume, nwccre.dirEnt, NULL, &nw);
if (dserr)
fprintf(stderr, "Cannot convert DOS entry to %u-NS entry: %s (%08X)\n", destns, strnwerror(dserr), dserr);
else {
dserr = ncp_initialize_search(conn, &nw, destns, &seq);
if (dserr)
fprintf(stderr, "Initialize search failed: %s (%08X)\n", strnwerror(dserr), dserr);
else {
switch (searchmode) {
case 1:
while (1) {
int more;
size_t itemcnt = 1000;
unsigned char buffer[16384];
size_t sbuffer = sizeof(buffer);
void* bptr;
dserr = ncp_ns_search_entry_set(conn,
searchattr, sstr, 0, RIM_ALL, &more, &itemcnt, &seq,
buffer, &sbuffer);
if (dserr)
break;
printf("Search sequence: %02X:%08X:%08X, items: %u, more: %02X\n",
seq.s.volNumber, seq.s.dirBase, seq.s.sequence,
itemcnt, more);
printf("Buffer size: %d\n", sbuffer);
bptr = buffer;
while (itemcnt-- > 0) {
struct nw_info_struct* nwp = bptr;
char tmpname[1000];
memcpy(tmpname, nwp->entryName, nwp->nameLen);
tmpname[nwp->nameLen] = 0;
printf(" Entry %08X: %s\n", nwp->dirEntNum, tmpname);
/* fixed size + variable size */
((char*)bptr) += sizeof(*nwp) - 256 + nwp->nameLen;
}
}
fprintf(stderr, "Search finished: %s (%08X)\n", strnwerror(dserr), dserr);
break;
case 2:
while (1) {
int more;
size_t itemcnt = 1000;
unsigned char buffer[16384];
size_t sbuffer = sizeof(buffer);
void* bptr;
dserr = ncp_ns_search_entry_set(conn,
searchattr, sstr, 0,
RIM_NAME | RIM_COMPRESSED_INFO, &more, &itemcnt, &seq,
buffer, &sbuffer);
if (dserr)
break;
printf("Search sequence: %02X:%08X:%08X, items: %u, more: %02X\n",
seq.s.volNumber, seq.s.dirBase, seq.s.sequence,
itemcnt, more);
printf("Buffer size: %d\n", sbuffer);
bptr = buffer;
while (itemcnt-- > 0) {
unsigned char* nwp = bptr;
char tmpname[1000];
memcpy(tmpname, nwp+1, nwp[0]);
tmpname[nwp[0]] = 0;
printf(" Entry: %s\n", tmpname);
/* fixed size + variable size */
((char*)bptr) += nwp[0] + 1;
}
}
fprintf(stderr, "Search finished: %s (%08X)\n", strnwerror(dserr), dserr);
break;
default:
while ((dserr = ncp_search_for_file_or_subdir2(conn,
searchattr, RIM_ALL, &seq, &nw)) == 0) {
nw.entryName[nw.nameLen] = 0;
printf("Search sequence: %02X:%08X:%08X\n",
seq.s.volNumber, seq.s.dirBase, seq.s.sequence);
printf(" Entry %08X: %s\n", nw.dirEntNum, nw.entryName);
}
fprintf(stderr, "Search finished: %s (%08X)\n", strnwerror(dserr), dserr);
break;
}
}
}
}
ncp_close(conn);
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";
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;
}
//
// Check_Configuration
//
// This function reads the configuration files and/or interacts with the
// user to insure that required configuration items are set to
// something. This function depends on bindery emulation. It should be
// updated sometime to use NDS facilities instead.
//
static void Check_Configuration()
{
// Read the configuration files.
spica::read_config_files(MASTER_CONFIGPATH);
// Do we have the required configuration items?
string *Name = spica::lookup_parameter("Full_Name");
string *Address = spica::lookup_parameter("Email_Address");
// If so, load the current options.
if (Name != 0 && Address != 0) {
*Full_Name = Name->c_str();
*Email_Address = Address->c_str();
}
// Otherwise try to compute this information or, as a last ditch,
// ask the user.
//
else {
#ifndef ON_NETWORK
bool Ask_User = true;
#endif
#ifdef ON_NETWORK
NWCONN_HANDLE Connection;
BYTE *Buffer = new BYTE[128];
NWFLAGS More_Data;
char Username[MAX_DN_CHARS+1];
bool Ask_User = false;
// Can we initialize the NetWare client?
if (NWCallsInit(0, 0) != SUCCESSFUL) {
Ask_User = true;
}
// Can we figure out our username?
else if (!Get_Username(Username)) {
Ask_User = true;
}
// Can we get a valid connection handle?
else if (NWGetConnectionHandle("NIGHT", 0, &Connection, 0)) {
Ask_User = true;
}
// Can we figure out our full name?
else if (NWReadPropertyValue(Connection, Username, OT_USER, "IDENTIFICATION", 1, Buffer, &More_Data, 0)) {
Ask_User = true;
}
// All of that worked. Update our internal information *and* the
// config file.
//
else {
Full_Name = reinterpret_cast<char *>(Buffer);
Email_Address = Username;
Email_Address.Append("@vtc.vsc.edu");
spica::Register_Parameter("Full_Name", Full_Name, false);
spica::Register_Parameter("Email_Address", Email_Address, false);
spica::Write_ConfigFile();
}
delete [] Buffer;
#endif
// Something didn't work. Ask the user.
if (Ask_User) {
DialogBox(Global::Get_Instance(), MAKEINTRESOURCE(CONFIG_DIALOG), 0, Config_Dialog);
}
}
}
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;
NWCONN_HANDLE conn;
char volume[1000];
char volpath[1000];
int opt;
int len;
unsigned char buffer[1000];
u_int32_t rim = 0;
u_int32_t destns = NW_NS_DOS;
u_int32_t searchattr = 0x8006;
char* s = NULL;
int doraw = 0;
setlocale(LC_ALL, "");
bindtextdomain(NCPFS_PACKAGE, LOCALEDIR);
textdomain(NCPFS_PACKAGE);
progname = argv[0];
NWCallsInit(NULL, NULL);
// NWDSInitRequester();
while ((opt = getopt(argc, argv, "h?r:n:s:p:R")) != EOF)
{
switch (opt)
{
case 'r':
rim = strtoul(optarg, NULL, 0);
break;
case 'n':
destns = strtoul(optarg, NULL, 0);
break;
case 's':
searchattr = strtoul(optarg, NULL, 0);
break;
case 'p':
s = optarg;
break;
case 'R':
doraw = 1;
break;
case 'h':
case '?':
help();
goto finished;
default:
usage();
goto finished;
}
}
dserr = NWParsePath(argv[optind++], NULL, &conn, volume, volpath);
if (dserr) {
fprintf(stderr, "NWParsePath failed: %s\n",
strnwerror(dserr));
return 123;
}
if (!conn) {
fprintf(stderr, "Path is not remote\n");
return 124;
}
strcat(volume, ":");
strcat(volume, volpath);
len = ncp_path_to_NW_format(s?s:volume, buffer, sizeof(buffer));
if (len < 0) {
fprintf(stderr, "Cannot convert path: %s\n",
strerror(-len));
} else {
struct nw_info_struct2 iii;
memset(&iii, 0xCC, sizeof(iii));
if (doraw) {
dserr = ncp_ns_obtain_entry_info_raw(conn,
NW_NS_DOS, searchattr,
0xFF, 0, 0, buffer, len, destns, rim, &iii, sizeof(iii));
if (dserr) {
fprintf(stderr, "Cannot obtain info: %s\n",
strnwerror(dserr));
} else {
size_t i;
unsigned char* p = (unsigned char*)&iii;
for (i = 0; i < sizeof(iii); i++) {
printf("%02X ", p[i]);
}
printf("\n");
}
} else {
dserr = ncp_ns_obtain_entry_info(conn,
NW_NS_DOS, searchattr,
0xFF, 0, 0, buffer, len, destns, rim, &iii, sizeof(iii));
if (dserr) {
fprintf(stderr, "Cannot obtain info: %s\n",
strnwerror(dserr));
} else {
printstruct2(rim, &iii);
}
}
}
ncp_close(conn);
finished:;
return 0;
}
int main(int argc, char *argv[]) {
NWDSCCODE dserr;
NWCONN_HANDLE conn;
char volume[1000];
char volpath[1000];
int opt;
u_int32_t rim = 0;
u_int32_t destns = NW_NS_DOS;
u_int32_t searchattr = 0x8006;
char* s = NULL;
setlocale(LC_ALL, "");
bindtextdomain(NCPFS_PACKAGE, LOCALEDIR);
textdomain(NCPFS_PACKAGE);
progname = argv[0];
NWCallsInit(NULL, NULL);
// NWDSInitRequester();
while ((opt = getopt(argc, argv, "h?r:n:s:p:")) != EOF)
{
switch (opt)
{
case 'r':
rim = strtoul(optarg, NULL, 0);
break;
case 'n':
destns = strtoul(optarg, NULL, 0);
break;
case 's':
searchattr = strtoul(optarg, NULL, 0);
break;
case 'p':
s = optarg;
break;
case 'h':
case '?':
help();
goto finished;
default:
usage();
goto finished;
}
}
dserr = NWParsePath(argv[optind++], NULL, &conn, volume, volpath);
if (dserr) {
fprintf(stderr, "NWParsePath failed: %s\n",
strnwerror(dserr));
return 123;
}
if (!conn) {
fprintf(stderr, "Path is not remote\n");
return 124;
}
strcpy(volume + 2, s);
volume[0] = 1;
volume[1] = strlen(s);
{
struct nw_info_struct2 iii;
u_int8_t fh[10];
memset(&iii, 0xCC, sizeof(iii));
dserr = ncp_ns_open_create_entry(conn, destns, searchattr, NCP_DIRSTYLE_DIRBASE,
3, rim, volume, strlen(s) + 2, -1, 0x0B, 0, 0, 0xFF,
&iii, sizeof(iii), NULL, NULL, fh);
if (dserr) {
fprintf(stderr, "Cannot obtain info: %s\n",
strnwerror(dserr));
} else {
printstruct2(0xFF, &iii);
}
ncp_close_file(conn, fh);
}
ncp_close(conn);
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;
}
