Home | History | Annotate | Line # | Download | only in rpc.pcnfsd
pcnfsd_test.c revision 1.3 
      1 /*	$NetBSD: pcnfsd_test.c,v 1.3 2003/07/16 08:22:01 itojun Exp $	*/
      2 
      3 /* RE_SID: @(%)/usr/dosnfs/shades_SCCS/unix/pcnfsd/v2/src/SCCS/s.pcnfsd_test.c 1.2 92/01/27 18:00:39 SMI */
      4 #include <stdio.h>
      5 #include <rpc/rpc.h>
      6 #include <malloc.h>
      7 #include "pcnfsd.h"
      8 
      9 CLIENT *cl;
     10 CLIENT *cl2;
     11 char *server;
     12 char spooldirbuff[256];
     13 char filenamebuff[256];
     14 char last_id[32] = "";
     15 
     16 void free_pr_list_item();
     17 void free_pr_queue_item();
     18 void good();
     19 void bad();
     20 
     21 
     22 main(argc, argv)
     23 int argc;
     24 char *argv[];
     25 {
     26 
     27 char *host_name;
     28 char *printer;
     29 char *user_name;
     30 char *passwd;
     31 char *transport = "udp";
     32 
     33 	if((argc < 6) || (argc > 7)) {
     34 		fprintf(stderr, "usage: %s server host printer user password [transport]\n",
     35 			argv[0]);
     36 		exit(1);
     37 	}
     38 
     39 	server = argv[1];
     40 	host_name = argv[2];
     41 	printer = argv[3];
     42 	user_name = argv[4];
     43 	passwd = argv[5];
     44 	if (argc == 7)
     45 		transport = argv[6];
     46 
     47 	cl = clnt_create(server, PCNFSDPROG, PCNFSDVERS, transport);
     48 	if(cl == NULL) {
     49 		clnt_pcreateerror(server);
     50 		exit(1);
     51 	}
     52 	cl2 = clnt_create(server, PCNFSDPROG, PCNFSDV2, transport);
     53 	if(cl2 == NULL) {
     54 		clnt_pcreateerror(server);
     55 		exit(1);
     56 	}
     57 	good();
     58 	test_v2_info();
     59 	good();
     60 	test_v2_auth(host_name, user_name, passwd);
     61 	bad("Invalid password");
     62 	test_v2_auth(host_name, user_name, "bogus");
     63 	good();
     64 	test_v2_list();
     65 	good();
     66 	test_v2_init(host_name, printer);
     67 	good();
     68 	test_v2_start(host_name, printer, user_name, "foo", "foo");
     69 	good();
     70 	test_v2_start(host_name, printer, user_name, "bar", "bar");
     71 	bad("No such file to print");
     72 	test_v2_start(host_name, printer, user_name, "bletch", "gack");
     73 	good();
     74 	test_v2_queue(printer, user_name, FALSE);
     75 	if(strlen(last_id)) {
     76 		bad("Cancelling job with bad username");
     77 		test_v2_cancel(host_name, printer, "nosuchuser", last_id);
     78 		good();
     79 		test_v2_cancel(host_name, printer, user_name, last_id);
     80 	}
     81 	bad("Cancelling unknown job");
     82 	test_v2_cancel(host_name, printer, user_name, "99999");
     83 	bad("Cancelling job on invalid printer");
     84 	test_v2_cancel(host_name, "nosuchprinter", user_name, last_id);
     85 	good();
     86 	test_v2_queue(printer, user_name, TRUE);
     87 	bad("Checking queue on invalid printer");
     88 	test_v2_queue("nosuchprinter", user_name, TRUE);
     89 	good();
     90 	test_v2_stat(printer);
     91 	bad("Checking status of invalid printer");
     92 	test_v2_stat("nosuchprinter");
     93 	good();
     94 	test_v2_map();
     95 	exit(0);
     96 /*NOTREACHED*/
     97 }
     98 
     99 #define zchar           0x5b
    100 
    101 void
    102 scramble(s1, s2)
    103 char           *s1;
    104 char           *s2;
    105 {
    106         while (*s1)
    107               {
    108               *s2++ = (*s1 ^ zchar) & 0x7f;
    109               s1++;
    110               }
    111         *s2 = 0;
    112 }
    113 
    114 
    115 
    116 test_v2_info()
    117 {
    118 v2_info_args a;
    119 v2_info_results *rp;
    120 int          *gp;
    121 int             i;
    122 
    123 	a.vers = "Sun Microsystems PCNFSD test subsystem V1";
    124 	a.cm = "-";
    125 	printf("\ninvoking pr_info_2\n");
    126 
    127 	rp = pcnfsd2_info_2(&a, cl2);
    128 
    129 	if(rp == NULL) {
    130 		clnt_perror(cl2, server);
    131 		return(1);
    132 	}
    133 
    134 	printf("results: vers = '%s', cm = '%s'\n",
    135 		rp->vers, rp->cm);
    136 	printf("facilities_len = %d\n", rp->facilities.facilities_len);
    137 	if (rp->facilities.facilities_len) {
    138 		gp = rp->facilities.facilities_val;
    139 		for(i = 0; i < rp->facilities.facilities_len; i++)
    140 			printf(" procedure %2d: %6d\n", i, *gp++);
    141 		printf("\n");
    142 	}
    143 /* free up allocated strings */
    144 	if(rp->cm)
    145 		free(rp->cm);
    146 	if(rp->facilities.facilities_val)
    147 		free(rp->facilities.facilities_val);
    148 	if(rp->vers)
    149 		free(rp->vers);
    150 
    151 	return(0);
    152 }
    153 
    154 test_v2_auth(host_name, user_name , pwrd)
    155 char *host_name;
    156 char *user_name;
    157 char *pwrd;
    158 {
    159 v2_auth_args a;
    160 v2_auth_results *rp;
    161 char            uname[32];
    162 char            pw[64];
    163 u_int          *gp;
    164 int             i;
    165 
    166 	scramble(user_name, uname);
    167 	scramble(pwrd, pw);
    168 	a.system = host_name;
    169 	a.id = uname;
    170 	a.pw = pw;
    171 	a.cm = "-";
    172 	printf("\ninvoking pr_auth_2\n");
    173 
    174 	rp = pcnfsd2_auth_2(&a, cl2);
    175 
    176 	if(rp == NULL) {
    177 		clnt_perror(cl2, server);
    178 		return(1);
    179 	}
    180 
    181 	if(rp->stat == AUTH_RES_FAIL)
    182 		printf("results: stat = AUTH_RES_FAIL\n");
    183 	else {
    184 	printf("results: stat = %d, uid = %u, gid = %u,\n homedir= '%s', cm = '%s'\n",
    185 		rp->stat, rp->uid, rp->gid, rp->home, rp->cm);
    186 	printf("gids_len = %d", rp->gids.gids_len);
    187 	if (rp->gids.gids_len) {
    188 		gp = rp->gids.gids_val;
    189 		for(i = 0; i < rp->gids.gids_len; i++)
    190 			printf(" %u", *gp++);
    191 		printf("\n");
    192 	}
    193 	}
    194 /* free up allocated strings */
    195 	if(rp->cm)
    196 		free(rp->cm);
    197 	if(rp->gids.gids_val)
    198 		free(rp->gids.gids_val);
    199 	if(rp->home)
    200 		free(rp->home);
    201 
    202 	return(0);
    203 }
    204 
    205 test_v2_init(host_name, printer)
    206 char *host_name;
    207 char *printer;
    208 {
    209 v2_pr_init_args a;
    210 v2_pr_init_results *rp;
    211 
    212 	a.system = host_name;
    213 	a.pn = printer;
    214 	a.cm = "-";
    215 	printf("\ninvoking pr_init_2\n");
    216 
    217 	rp = pcnfsd2_pr_init_2(&a, cl2);
    218 
    219 	if(rp == NULL) {
    220 		clnt_perror(cl2, server);
    221 		return(1);
    222 	}
    223 	printf("results: stat = %d, dir = '%s', cm = '%s'\n",
    224 		rp->stat, rp->dir, rp->cm);
    225 	strlcpy(spooldirbuff, rp->dir, sizeof(spooldirbuff));
    226 /* free up allocated strings */
    227 	if(rp->cm)
    228 		free(rp->cm);
    229 	if(rp->dir)
    230 		free(rp->dir);
    231 	return(0);
    232 }
    233 
    234 
    235 test_v2_start(host_name, printer, user_name, tag1, tag2)
    236 char *host_name;
    237 char *printer;
    238 char *user_name;
    239 char *tag1;
    240 char *tag2;
    241 {
    242 v2_pr_start_args a;
    243 v2_pr_start_results *rp;
    244 FILE *fp;
    245 	printf("\ntesting start print v2\n");
    246 
    247 	if(strcmp(server, "localhost")) {
    248 		printf("sorry - can only test start print on 'localhost'\n");
    249 		return(1);
    250 	}
    251 
    252 	snprintf(filenamebuff, sizeof(filenamebuff), "%s/%s",
    253 	    spooldirbuff, tag1);
    254 
    255 	fp = fopen(filenamebuff, "w");
    256 	if(fp == NULL) {
    257 		perror("creating test file");
    258 		return(1);
    259 	}
    260 	(void)fputs("foo bar bletch\n", fp);
    261 	(void)fclose(fp);
    262 
    263 	a.system = host_name;
    264 	a.pn = printer;
    265 	a.user = user_name;
    266 	a.file = tag2;
    267 	a.opts = "xxxx";
    268 	a.copies = 1;
    269 	a.cm = "-";
    270 
    271 	printf("\ninvoking pr_start_2\n");
    272 
    273 	rp = pcnfsd2_pr_start_2(&a, cl2);
    274 
    275 	if(rp == NULL) {
    276 		clnt_perror(cl2, server);
    277 		return(1);
    278 	}
    279 	printf("results: stat = %d, jobid = '%s', cm = '%s'\n",
    280 		rp->stat, rp->id, rp->cm);
    281 	if(rp->stat == PS_RES_OK)
    282 		strlcpy(last_id, rp->id, sizeof(last_id));
    283 /* free up allocated strings */
    284 	if(rp->cm)
    285 		free(rp->cm);
    286 	if(rp->id)
    287 		free(rp->id);
    288 	return(0);
    289 }
    290 
    291 
    292 test_v2_cancel(host_name, printer, user_name, id)
    293 char *host_name;
    294 char *printer;
    295 char *user_name;
    296 char *id;
    297 {
    298 v2_pr_cancel_args a;
    299 v2_pr_cancel_results *rp;
    300 	printf("\ntesting cancel print v2\n");
    301 
    302 	a.system = host_name;
    303 	a.pn = printer;
    304 	a.user = user_name;
    305 	a.id = id;
    306 	a.cm = "-";
    307 
    308 	printf("\ninvoking pr_cancel_2 for job %s on printer %s\n",
    309 		id, printer);
    310 
    311 	rp = pcnfsd2_pr_cancel_2(&a, cl2);
    312 
    313 	if(rp == NULL) {
    314 		clnt_perror(cl2, server);
    315 		return(1);
    316 	}
    317 	printf("results: stat = %d, cm = '%s'\n",
    318 		rp->stat, rp->cm);
    319 /* free up allocated strings */
    320 	if(rp->cm)
    321 		free(rp->cm);
    322 	return(0);
    323 }
    324 test_v2_list()
    325 {
    326 char a;
    327 v2_pr_list_results *rp;
    328 pr_list curr;
    329 
    330 
    331 	printf("\ninvoking pr_list_2\n");
    332 
    333 	rp = pcnfsd2_pr_list_2(&a, cl2);
    334 
    335 	if(rp == NULL) {
    336 		clnt_perror(cl2, server);
    337 		return(1);
    338 	}
    339 	printf("results: cm = '%s', printerlist:\n", rp->cm);
    340 	curr = rp->printers;
    341 	while(curr) {
    342 		printf("  name '%s' ", curr->pn);
    343 		if(strlen(curr->remhost))
    344 			printf("remote: srvr '%s', name '%s'",
    345 				curr->remhost,
    346 				curr->device);
    347 		else
    348 			printf("local device = '%s'", curr->device);
    349 		printf(", cm = '%s'\n", curr->cm);
    350 		curr = curr->pr_next;
    351 	}
    352 	printf("end of list\n");
    353 /* free up allocated strings */
    354 	if(rp->cm)
    355 		free(rp->cm);
    356 	if(rp->printers) {
    357 		printf("freeing results\n");
    358 		free_pr_list_item(rp->printers);
    359 	}
    360 	return(0);
    361 }
    362 
    363 
    364 void
    365 free_pr_list_item(curr)
    366 pr_list curr;
    367 {
    368 	if(curr->pn)
    369 		free(curr->pn);
    370 	if(curr->remhost)
    371 		free(curr->remhost);
    372 	if(curr->device)
    373 		free(curr->device);
    374 	if(curr->cm)
    375 		free(curr->cm);
    376 	if(curr->pr_next)
    377 		free_pr_list_item(curr->pr_next); /* recurse */
    378 	free(curr);
    379 }
    380 
    381 
    382 
    383 test_v2_queue(printer, user_name, private)
    384 char *printer;
    385 char *user_name;
    386 int private;
    387 {
    388 struct v2_pr_queue_args a;
    389 v2_pr_queue_results *rp;
    390 pr_queue curr;
    391 
    392 	a.pn = printer;
    393 	a.system = "foo";
    394 	a.user = user_name;
    395 	a.just_mine = private;
    396 	a.cm = "no";
    397 
    398 	printf("\ninvoking pr_queue_2 (just_mine = %d)\n", private);
    399 
    400 	rp = pcnfsd2_pr_queue_2(&a, cl2);
    401 
    402 	if(rp == NULL) {
    403 		clnt_perror(cl2, server);
    404 		return(1);
    405 	}
    406 	printf("results: stat = %d, qlen = %d, qshown = %d cm = '%s', queue:\n",
    407 		rp->stat, rp->qlen, rp->qshown, rp->cm);
    408 	curr = rp->jobs;
    409 	while(curr) {
    410 		printf("rank = %2d, id = '%s', size = '%s', status = '%s'\n",
    411 			curr->position,
    412 			curr->id,
    413 			curr->size,
    414 			curr->status);
    415 		printf("            user = '%s', file = '%s', cm = '%s'\n",
    416 			curr->user,
    417 			curr->file,
    418 			curr->cm);
    419 		curr = curr->pr_next;
    420 	}
    421 	printf("end of list\n");
    422 /* free up allocated strings */
    423 	if(rp->cm)
    424 		free(rp->cm);
    425 	if(rp->jobs) {
    426 		printf("freeing results\n");
    427 		free_pr_queue_item(rp->jobs);
    428 	}
    429 	return(0);
    430 }
    431 
    432 
    433 
    434 void
    435 free_pr_queue_item(curr)
    436 pr_queue curr;
    437 {
    438 	if(curr->id)
    439 		free(curr->id);
    440 	if(curr->size)
    441 		free(curr->size);
    442 	if(curr->status)
    443 		free(curr->status);
    444 	if(curr->system)
    445 		free(curr->system);
    446 	if(curr->user)
    447 		free(curr->user);
    448 	if(curr->file)
    449 		free(curr->file);
    450 	if(curr->cm)
    451 		free(curr->cm);
    452 	if(curr->pr_next)
    453 		free_pr_queue_item(curr->pr_next); /* recurse */
    454 	free(curr);
    455 }
    456 
    457 
    458 
    459 test_v2_stat(printer)
    460 char *printer;
    461 {
    462 v2_pr_status_args a;
    463 v2_pr_status_results *rp;
    464 
    465 	printf("\ntesting status print v2\n");
    466 
    467 	a.pn = printer;
    468 	a.cm = "-";
    469 
    470 	printf("\ninvoking pr_status_2\n");
    471 
    472 	rp = pcnfsd2_pr_status_2(&a, cl2);
    473 
    474 	if(rp == NULL) {
    475 		clnt_perror(cl2, server);
    476 		return(1);
    477 	}
    478 	printf("results: stat = %d, cm = '%s'\n",
    479 		rp->stat, rp->cm);
    480 	if(rp->stat == PI_RES_OK) {
    481 		printf("avail = %s, ", (rp->avail ? "YES" : "NO"));
    482 		printf("printing = %s, ", (rp->printing ? "YES" : "NO"));
    483 		printf("needs_operator = %s, ", (rp->needs_operator ? "YES" : "NO"));
    484 		printf("qlen = %d, status = '%s'\n", rp->qlen, rp->status);
    485 	}
    486 /* free up allocated strings */
    487 	if(rp->cm)
    488 		free(rp->cm);
    489 	if(rp->status)
    490 		free(rp->status);
    491 	return(0);
    492 }
    493 
    494 struct mapreq_arg_item * make_mapreq_entry(t, i, n, next)
    495 mapreq	t;
    496 int i;
    497 char *n;
    498 struct mapreq_arg_item *next;
    499 {
    500 struct mapreq_arg_item *x;
    501 	x = (struct mapreq_arg_item *)malloc(sizeof(struct mapreq_arg_item));
    502 	if(x == NULL) {
    503 		fprintf(stderr, "out of memory\n");
    504 		exit(123);
    505 	}
    506 	x->req = t;
    507 	x->id = i;
    508 	x->name = (n ? n : "");
    509 	x->mapreq_next = next;
    510 	return(x);
    511 }
    512 
    513 test_v2_map()
    514 {
    515 v2_mapid_args a;
    516 v2_mapid_results *rp;
    517 struct mapreq_res_item *rip;
    518 
    519 	a.cm = "-";
    520 	a.req_list = make_mapreq_entry(MAP_REQ_UID, 906, NULL,
    521 		make_mapreq_entry(MAP_REQ_GID, 1, NULL,
    522 		 make_mapreq_entry(MAP_REQ_UNAME, 0, "root",
    523 		   make_mapreq_entry(MAP_REQ_GNAME, 0, "wheel",
    524 		      make_mapreq_entry(MAP_REQ_UNAME, 0, "bogus", NULL)))));
    525 
    526 	printf("\ninvoking pr_mapid_2\n");
    527 	rp = pcnfsd2_mapid_2(&a, cl2);
    528 
    529 	if(rp == NULL) {
    530 		clnt_perror(cl2, server);
    531 		return(1);
    532 	}
    533 	printf("results: cm = '%s', result list %s\n",
    534 		rp->cm, rp->res_list ? "follows" : "omitted");
    535 	rip = rp->res_list;
    536 	while(rip) {
    537 		printf("request type = %d, status = %d, id = %d, name = '%s'\n",
    538 			rip->req, rip->stat, rip->id,
    539 			(rip->name ? rip->name : "(NULL)"));
    540 		rip = rip->mapreq_next;
    541 	}
    542 /* XXX should free up results */
    543 
    544 
    545 
    546 return(0);
    547 }
    548 
    549 
    550 void
    551 good()
    552 {
    553 printf("\n");
    554 printf("********************************************************\n");
    555 printf("********************************************************\n");
    556 printf("**      The following test is expected to SUCCEED     **\n");
    557 printf("********************************************************\n");
    558 printf("********************************************************\n");
    559 }
    560 
    561 void
    562 bad(reason)
    563 char *reason;
    564 {
    565 printf("\n");
    566 printf("********************************************************\n");
    567 printf("********************************************************\n");
    568 printf("**      The following test is expected to FAIL        **\n");
    569 printf("**                    Reason:                         **\n");
    570 printf("** %50s **\n", reason);
    571 printf("********************************************************\n");
    572 printf("********************************************************\n");
    573 }
    574