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