1/* BEGIN LICENSE BLOCK 2 * Version: CMPL 1.1 3 * 4 * The contents of this file are subject to the Cisco-style Mozilla Public 5 * License Version 1.1 (the "License"); you may not use this file except 6 * in compliance with the License. You may obtain a copy of the License 7 * at www.eclipse-clp.org/license. 8 * 9 * Software distributed under the License is distributed on an "AS IS" 10 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See 11 * the License for the specific language governing rights and limitations 12 * under the License. 13 * 14 * The Original Code is The ECLiPSe Constraint Logic Programming System. 15 * The Initial Developer of the Original Code is Cisco Systems, Inc. 16 * Portions created by the Initial Developer are 17 * Copyright (C) 1994-2006 Cisco Systems, Inc. All Rights Reserved. 18 * 19 * Contributor(s): Kees Schuerman, ECRC 20 * 21 * END LICENSE BLOCK */ 22/********************************************************************** 23** System: Parallel Distributed System 24** File: nsrv_client.c 25** Author: Kees Schuerman 26** SccsId: "@(#)nsrv_client.c 1.31 24 Nov 1995" 27** Description: Name Service Client Stubs 28***********************************************************************/ 29 30#include "machine.h" /* architecture specific constant definitions */ 31 32#include <sys/types.h> 33#include <sys/param.h> 34#include <sys/stat.h> 35#include <sys/socket.h> 36#include <netinet/in.h> 37#include <netinet/tcp.h> 38#include <netdb.h> 39#include <arpa/inet.h> 40#include <errno.h> 41#include <unistd.h> 42#include <stdlib.h> 43#include <stdio.h> 44#include <string.h> 45#include <rpc/rpc.h> 46#include <fcntl.h> 47 48#include "pds.types.h" 49#include "pds.error.h" 50#include "pds.mem.h" 51#include "pds.mdt.h" 52#include "pds.xdr.h" 53#include "bmsg.msg.h" 54#include "bmsg.xdr.h" 55#include "amsg.msg.h" 56#include "amsg.xdr.h" 57#include "nsrv.h" 58#include "nsrv.xdr.h" 59#include "nsrv_int.h" 60 61 62/********************************************************************** 63** Global Variables 64***********************************************************************/ 65 66static int shm_enabled = 0; 67static int pds_enabled = 0; 68static int stubs_ready = 0; 69static int types_ready = 0; 70 71int nsrv_initialised = 0; 72static int nsrv_initialising = 0; 73int nsrv_exited = 0; 74int nsrv_exiting = 0; 75 76static bport_t nsrv_port; 77static unsigned nsrv_port_number; 78static inet_address_t nsrv_inet_address; 79 80 81 82/********************************************************************** 83************************* Local Primitives ************************* 84***********************************************************************/ 85 86#define AmsgCheck(aret) { \ 87 switch (aret) { \ 88 case AMSG_NYI : \ 89 return(NSRV_NYI); \ 90 case AMSG_NORESOURCES : \ 91 return(NSRV_NORESOURCES); \ 92 case AMSG_NOMEMORY : \ 93 return(NSRV_NOMEMORY); \ 94 case AMSG_OK : \ 95 break; \ 96 default : \ 97 return(NSRV_ERROR); \ 98 break; \ 99 } \ 100} 101 102 103#define NsrvVariables \ 104 aport_id_t reply_port_id; \ 105 amsg_type_t msg_type; \ 106 amsg_t request_msg; \ 107 amsg_t reply_msg; \ 108 amsg_ret_t aret 109 110 111#define NsrvPrepareRequest(type) { \ 112 msg_type = type; \ 113 AmsgCheck(aport_allocate(&reply_port_id, \ 114 (void (*)()) 0)); \ 115 AmsgCheck(amsg_alloc((amsg_size_t) sizeof(*request), \ 116 (amsg_data_t * *) &request, \ 117 &request_msg)); \ 118} 119 120 121#define NsrvRPC(number) { \ 122 /* send request */ \ 123 AmsgCheck(amsg_send(aport_id(NSRV_BPORT_ID,number), \ 124 request_msg, \ 125 msg_type, \ 126 (amsg_count_t) 1, \ 127 (amsg_option_t) 0)); \ 128 /* wait for reply */ \ 129 do { \ 130 aret = amsg_receive(reply_port_id, \ 131 &reply_msg, \ 132 (amsg_data_t * *) &reply, \ 133 &msg_type, \ 134 (amsg_count_t *) 0, \ 135 (amsg_option_t) 0); \ 136 } while (aret == AMSG_NOMESSAGE); \ 137 AmsgCheck(aret); \ 138} 139 140 141#define NsrvFinishRequest() { \ 142 aret = amsg_free(reply_msg); \ 143 nsrv_assert(aret == AMSG_OK); \ 144 AmsgCheck(aport_deallocate(reply_port_id)); \ 145} 146 147 148#define NsrvSockVariables \ 149 nsrv_number_t nsrv_request_number; \ 150 pds_uint32 buf[NSRV_BUF_SIZE]; \ 151 char * buffer; \ 152 pds_uint32 bufsize; \ 153 int nsrv_msg_sock; \ 154 XDR xdrs 155 156 157#define NsrvSockPrepareRequest(InetAddress,PortNumber) { \ 158 buffer = (char *) buf; \ 159 \ 160 nret = nsrv_connect(&nsrv_msg_sock,InetAddress,PortNumber); \ 161 if (nret == NSRV_OK) \ 162 xdrmem_create(&xdrs,(const caddr_t) buffer, \ 163 (const u_int) 4*NSRV_BUF_SIZE, \ 164 XDR_ENCODE); \ 165} 166 167 168#define NsrvSockUnpackSimpleReply() { \ 169 if (!xdr_nsrv_ret(&xdrs,&nret)) \ 170 nret = NSRV_ERROR; \ 171 xdr_destroy(&xdrs); \ 172} 173 174 175 176#define NsrvSockRPC() { \ 177 /* derive size of request */ \ 178 bufsize = (pds_uint32) xdr_getpos(&xdrs); \ 179 \ 180 /* send request */ \ 181 if (nret == NSRV_OK) \ 182 nret = nsrv_send_sock(nsrv_msg_sock,buffer,bufsize); \ 183 xdr_destroy(&xdrs); \ 184 \ 185 /* receive reply */ \ 186 if (nret == NSRV_OK) \ 187 nret = nsrv_receive_sock(nsrv_msg_sock,buffer,&bufsize); \ 188 \ 189 nsrv_close_sock(nsrv_msg_sock); \ 190 \ 191 if (nret == NSRV_OK) \ 192 xdrmem_create(&xdrs,(const caddr_t) buffer, \ 193 (const u_int) 4*NSRV_BUF_SIZE, \ 194 XDR_DECODE); \ 195 else \ 196 nret = NSRV_ERROR; \ 197} 198 199 200static nsrv_ret_t 201nsrv_init_stubs() 202{ 203 bmsg_ret_t bret; 204 nsrv_ret_t nret; 205 206 if (!nsrv_ready()) 207 return(NSRV_NOT_READY); 208 209 if (!amsg_ready()) { 210 stubs_ready = 0; 211 return(NSRV_OK); 212 } 213 214 if (!types_ready) { 215 if ((nret = nsrv_types_init_i()) != NSRV_OK) { 216 nsrv_assert(nret != AMSG_INVAL); 217 return(nret); 218 } 219 else 220 types_ready = 1; 221 } 222 223 if ((!pds_enabled) || (stubs_ready)) 224 return(NSRV_OK); 225 226 do { 227 bret = bport_open(&nsrv_port); 228 switch (bret) { 229 case BMSG_POPENING : 230 break; 231 case BMSG_NOPORT : 232 case BMSG_PUNREACH : 233 return(NSRV_NOSERVER); 234 case BMSG_POPENED : 235 break; 236 case BMSG_PBLOCKED : 237 nsrv_assert_always(); 238 break; 239 case BMSG_PNOTAVAILABLE : 240 break; 241 case BMSG_NORESOURCES : 242 return(NSRV_NORESOURCES); 243 case BMSG_NOMEMORY : 244 return(NSRV_NOMEMORY); 245 default : 246 nsrv_assert_always(); 247 break; 248 } 249 } while (bret != BMSG_POPENED); 250 251 stubs_ready = 1; 252 253 return(NSRV_OK); 254} 255 256 257#define NSRV_RETRIES_MAX 64 258 259static nsrv_ret_t 260nsrv_connect(sock,inet_address,port_number) 261 int * sock; 262 char * inet_address; 263 unsigned port_number; 264{ 265 int ret; 266 int nsrv_msg_sock; 267 unsigned long address; 268 struct sockaddr_in nsrv_ctrl_sock_name; 269 int on = 1; 270 int retries = 0; 271 272 do { 273 /* create message socket */ 274 do { 275 nsrv_msg_sock = socket(PF_INET,SOCK_STREAM,0); 276 } while ((nsrv_msg_sock == -1) && (errno == EINTR)); 277 if (nsrv_msg_sock == -1) { 278 switch (errno) { 279 case EMFILE : 280 case ENFILE : 281 case ENOBUFS : 282 return(NSRV_NORESOURCES); 283 default : 284 nsrv_perror_and_assert_always("socket()"); 285 break; 286 } 287 } 288 /* construct name of control socket */ 289 address = inet_addr(inet_address); 290 if (address == -1) { 291 nsrv_close_sock(nsrv_msg_sock); 292 return(NSRV_NOSERVER); 293 } 294 nsrv_ctrl_sock_name.sin_family = AF_INET; 295 nsrv_ctrl_sock_name.sin_addr = * (struct in_addr *) &address; 296 nsrv_ctrl_sock_name.sin_port = htons((u_short) port_number); 297 /* establish connection */ 298 do { 299 ret = connect(nsrv_msg_sock, 300 (struct sockaddr *) &nsrv_ctrl_sock_name, 301 sizeof(nsrv_ctrl_sock_name)); 302 } while ((ret == -1) && (errno == EINTR)); 303 if (ret == -1) { 304 switch (errno) { 305 case ENOSR : 306 nsrv_close_sock(nsrv_msg_sock); 307 return(NSRV_NORESOURCES); 308 case ETIMEDOUT : 309 case EADDRNOTAVAIL : 310 case ENETUNREACH : 311 nsrv_close_sock(nsrv_msg_sock); 312 return(NSRV_NOSERVER); 313 case ECONNREFUSED : 314 case EISCONN : /* spurious error */ 315 case EADDRINUSE : /* spurious error */ 316 case EALREADY : /* spurious error */ 317 nsrv_close_sock(nsrv_msg_sock); 318 if (retries++ < NSRV_RETRIES_MAX) 319 break; /* retry */ 320 return(NSRV_NOT_READY); 321 default : 322 nsrv_perror_and_assert_always("connect()"); 323 nsrv_close_sock(nsrv_msg_sock); 324 break; 325 } 326 } 327 else { 328 nsrv_sock_noinherit(nsrv_msg_sock); 329 nsrv_sock_linger(nsrv_msg_sock); 330 nsrv_sock_nodelay(nsrv_msg_sock); 331 *sock = nsrv_msg_sock; 332 return(NSRV_OK); 333 } 334 } while (1); 335} 336 337 338static nsrv_ret_t 339nsrv_get_inet_address(hostname,inet_address) 340 char * hostname; 341 inet_address_t inet_address; 342{ 343 struct hostent * hostentry; 344 unsigned long address; 345 346 /* get internet address */ 347 hostentry = gethostbyname(hostname); 348 if (!hostentry) { 349 address = inet_addr(hostname); 350 if (address == -1) 351 return(NSRV_NOHOST); 352 hostentry = gethostbyaddr((char *) &address,4,AF_INET); 353 if (!hostentry) 354 return(NSRV_NOHOST); 355 } 356 if (hostentry->h_addrtype != AF_INET) 357 return(NSRV_ERROR); 358 if (hostentry->h_length != 4) 359 return(NSRV_ERROR); 360 strncpy((char *) inet_address, 361 inet_ntoa(* (struct in_addr *) *hostentry->h_addr_list), 362 INET_ADDRESSLEN_MAX); 363 inet_address[INET_ADDRESSLEN_MAX] = '\0'; 364 return(NSRV_OK); 365} 366 367 368static nsrv_ret_t 369nsrv_get_mode(inet_address,port_number,mode) 370 inet_address_t inet_address; 371 unsigned port_number; 372 nsrv_mode_t * mode; 373{ 374 NsrvSockVariables; 375 nsrv_ret_t nret; 376 377 NsrvSockPrepareRequest(inet_address,port_number); 378 379 if (nret != NSRV_OK) 380 return(nret); 381 382 /* pack request */ 383 nsrv_request_number = NSRV_GET_MODE; 384 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number))) 385 nret = NSRV_ERROR; 386 387 NsrvSockRPC(); 388 389 if (nret != NSRV_OK) 390 return(nret); 391 392 /* unpack reply */ 393 394 if (!xdr_nsrv_ret(&xdrs,&nret)) 395 nret = NSRV_ERROR; 396 397 if ((nret == NSRV_OK) && (!(xdr_nsrv_mode(&xdrs,mode)))) 398 nret = NSRV_ERROR; 399 400 xdr_destroy(&xdrs); 401 402 return(nret); 403} 404 405 406static nsrv_ret_t 407nsrv_get_path(inet_address,port_number,path) 408 inet_address_t inet_address; 409 unsigned port_number; 410 char * path; 411{ 412 NsrvSockVariables; 413 nsrv_ret_t nret; 414 415 NsrvSockPrepareRequest(inet_address,port_number); 416 417 if (nret != NSRV_OK) 418 return(nret); 419 420 /* pack request */ 421 nsrv_request_number = NSRV_GET_PATH; 422 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number))) 423 nret = NSRV_ERROR; 424 425 NsrvSockRPC(); 426 427 if (nret != NSRV_OK) 428 return(nret); 429 430 /* unpack reply */ 431 432 if (!xdr_nsrv_ret(&xdrs,&nret)) 433 nret = NSRV_ERROR; 434 435 if ((nret == NSRV_OK) && (!(xdr_string(&xdrs,&path,NSRV_FILENAMELEN_MAX)))) 436 nret = NSRV_ERROR; 437 438 xdr_destroy(&xdrs); 439 440 return(nret); 441} 442 443 444 445 446/********************************************************************** 447************************ Exported Primitives ************************ 448***********************************************************************/ 449 450nsrv_ret_t 451nsrv_ping(hostname,port_number) 452 char * hostname; 453 unsigned * port_number; 454{ 455 NsrvSockVariables; 456 inet_address_t inet_address; 457 unsigned property; 458 nsrv_ret_t nret; 459 unsigned number; 460 461 if (!hostname || !port_number) 462 return(NSRV_INVAL); 463 464 /* get internet address */ 465 if ((nret = nsrv_get_inet_address(hostname,inet_address)) != NSRV_OK) 466 return(nret); 467 468 /* get port number */ 469 number = *port_number; 470 471 /* initialise port_number */ 472 nsrv_init_port_number(&number,&property); 473 474 do { 475 nret = NSRV_OK; 476 477 NsrvSockPrepareRequest(inet_address,(u_short) number); 478 479 /* pack request */ 480 nsrv_request_number = NSRV_PING; 481 if ((nret == NSRV_OK) && 482 (!xdr_nsrv_number(&xdrs,&nsrv_request_number))) 483 nret = NSRV_ERROR; 484 485 if (nret == NSRV_OK) 486 NsrvSockRPC(); 487 488 if (nret == NSRV_OK) 489 NsrvSockUnpackSimpleReply(); 490 491 if ((nret != NSRV_OK) && 492 (property == NSRV_DEFAULT) && 493 (number >= NSRV_PORT_DEFAULT) && 494 (number < (NSRV_PORT_DEFAULT + NSRV_DEFAULT_PORTS - 1))) 495 number++; 496 else 497 break; 498 499 } while (1); 500 501 if (nret == NSRV_OK) 502 *port_number = number; /* update port number */ 503 504 return(nret); 505} 506 507 508nsrv_ret_t 509nsrv_init(hostname,port_number) 510 char * hostname; 511 unsigned * port_number; 512{ 513 char nsrv_path[NSRV_FILENAMELEN_MAX+1]; 514 char datafile[NSRV_FILENAMELEN_MAX+1]; 515 char localhostname[MAXHOSTNAMELEN+1]; 516 nsrv_version_t version; 517 nsrv_ret_t nret; 518 nsrv_mode_t nsrv_mode; 519 bdomain_t nsrv_domain; 520 521 if (nsrv_initialised || nsrv_initialising) 522 return(NSRV_ERROR); 523 524 nsrv_initialising = 1; 525 526 /* initialise hostname */ 527 if (!hostname) { /* use environment variable NSRV_HOST */ 528 hostname = getenv(NSRV_HOST); 529 if (!hostname) { /* use default host_name, i.e. the local host */ 530 if (gethostname(localhostname,MAXHOSTNAMELEN) != 0) { 531 nsrv_initialising = 0; 532 return(NSRV_ERROR); 533 } 534 else 535 hostname = localhostname; 536 } 537 } 538 539 /* derive nsrv_port_number */ 540 if (!port_number) 541 nsrv_port_number = 0; 542 else 543 nsrv_port_number = *port_number; 544 nret = nsrv_ping(hostname,&nsrv_port_number); 545 if (nret != NSRV_OK) { 546 nsrv_initialising = 0; 547 return(NSRV_NOSERVER); 548 } 549 550 /* derive internet address */ 551 nret = nsrv_get_inet_address(hostname,nsrv_inet_address); 552 if (nret != NSRV_OK) { 553 nsrv_initialising = 0; 554 return(nret); 555 } 556 557 /* get nsrv_mode */ 558 if (nsrv_get_mode(nsrv_inet_address,nsrv_port_number,&nsrv_mode) != NSRV_OK) { 559 nsrv_initialising = 0; 560 return(NSRV_NOSERVER); 561 } 562 563 /* get nsrv_path */ 564 if (nsrv_get_path(nsrv_inet_address,nsrv_port_number,nsrv_path) != NSRV_OK) { 565 nsrv_initialising = 0; 566 return(NSRV_NOSERVER); 567 } 568 569 nsrv_initialised = 1; 570 571 /* check version */ 572 nret = nsrv_version(&version); 573 nsrv_assert(nret != NSRV_NOT_READY); 574 nsrv_assert(nret != NSRV_INVAL); 575 if (nret != NSRV_OK) { 576 (void) nsrv_exit(); 577 nsrv_exited = 0; 578 return(nret); 579 } 580 if (version.v_major != NSRV_VERSION_MAJOR) { 581 (void) nsrv_exit(); 582 nsrv_exited = 0; 583 return(NSRV_EVERSION); 584 } 585 586 /* derive nsrv_msg_start */ 587 if (nsrv_bdomain_look_up(NSRV_KEY,NSRV_DOMAIN_NAME,&nsrv_domain) != NSRV_OK) { 588 (void) nsrv_exit(); 589 nsrv_exited = 0; 590 return(NSRV_NOSERVER); 591 } 592 nsrv_msg_start = (char *) nsrv_domain.bdomain_start; 593 594 /* get name server bport */ 595 if (nsrv_mode & NSRV_PDS) { 596 if (nsrv_bport_look_up(NSRV_KEY,NSRV_PORT_NAME,&nsrv_port) != NSRV_OK) { 597 (void) nsrv_exit(); 598 nsrv_exited = 0; 599 return(NSRV_NOSERVER); 600 } 601 pds_enabled = 1; 602 } 603 604 /* if possible, enable shared memory interaction */ 605 if ((nsrv_mode & NSRV_SHM) && 606 !strcmp(localhostname,hostname) && 607 (pathconf(nsrv_path,_PC_LINK_MAX) == -1) && (errno)) { 608 sprintf(datafile,"%s/%s.%s.%d", 609 nsrv_path,NSRV_DATAFILE,hostname,nsrv_port_number); 610 if (nsrv_init_client_i(datafile) == NSRV_OK) 611 shm_enabled = 1; 612 } 613 614 /* update port number */ 615 if (port_number) 616 *port_number = nsrv_port_number; 617 618 nsrv_initialising = 0; 619 620 return(NSRV_OK); 621} 622 623 624nsrv_ret_t 625nsrv_types_init() 626{ 627 nsrv_ret_t nret; 628 629 if (!amsg_ready()) 630 return(NSRV_NOT_READY); 631 632 if (!types_ready) { 633 if ((nret = nsrv_types_init_i()) != NSRV_OK) 634 return(nret); 635 else 636 types_ready = 1; 637 } 638 return(NSRV_OK); 639} 640 641 642void 643nsrv_exit() 644{ 645 bmsg_ret_t bret; 646 bport_t port; 647 648 if (nsrv_init_stubs() != NSRV_OK) 649 return; 650 651 if (!nsrv_initialised || nsrv_exiting || nsrv_exited) 652 return; 653 654 nsrv_exiting = 1; 655 656 if (stubs_ready) { 657 stubs_ready = 0; 658 /* close name server port */ 659 do { 660 bret = bport_close(nsrv_port.bport_id); 661 } while (bret == BMSG_PNOTAVAILABLE); 662 /* wait till name server port has actually been closed */ 663 do { 664 bret = bport_port(nsrv_port.bport_id,&port); 665 } while (bret != BMSG_NOPORT); 666 } 667 shm_enabled = 0; 668 pds_enabled = 0; 669 nsrv_exited = 1; 670 nsrv_exiting = 0; 671 nsrv_initialising = 0; 672} 673 674 675char * 676nsrv_data_base() 677{ 678 return(nsrv_data_start); 679} 680 681 682char * 683nsrv_msg_base() 684{ 685 return(nsrv_msg_start); 686} 687 688 689nsrv_ret_t 690nsrv_aport_register(key,name,signature,port) 691 nsrv_name_t key; 692 nsrv_name_t name; 693 nsrv_name_t signature; 694 aport_t * port; 695{ 696 nsrv_ret_t nret; 697 698 if (!nsrv_ready()) 699 return(NSRV_NOT_READY); 700 701 if (!key || !name || !signature || !port) 702 return(NSRV_INVAL); 703 704 if ((nret = nsrv_init_stubs()) != NSRV_OK) 705 return(nret); 706 707 if (shm_enabled) 708 return(nsrv_aport_register_i(key,name,signature,port)); 709 710 else if (!stubs_ready) { 711 NsrvSockVariables; 712 713 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 714 715 if (nret != NSRV_OK) 716 return(nret); 717 718 /* pack request */ 719 nsrv_request_number = NSRV_APORT_REGISTER; 720 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 721 xdr_nsrv_name(&xdrs,&key) && 722 xdr_nsrv_name(&xdrs,&name) && 723 xdr_nsrv_name(&xdrs,&signature) && 724 xdr_aport(&xdrs,port))) 725 nret = NSRV_ERROR; 726 727 NsrvSockRPC(); 728 729 if (nret != NSRV_OK) 730 return(nret); 731 732 NsrvSockUnpackSimpleReply(); 733 734 return(nret); 735 } 736 737 else { 738 NsrvVariables; 739 aport_register_request_t * request; 740 simple_reply_t * reply; 741 742 NsrvPrepareRequest(MDT_APORT_REGISTER_REQUEST); 743 744 /* pack request message */ 745 request->reply_port_id = reply_port_id; 746 strcpy(request->key,key); 747 strcpy(request->name,name); 748 strcpy(request->signature,signature); 749 request->port = *port; 750 751 NsrvRPC(NSRV_APORT_REGISTER); 752 753 nsrv_assert(msg_type == MDT_SIMPLE_REPLY); 754 755 /* unpack reply message */ 756 nret = reply->ret; 757 758 NsrvFinishRequest(); 759 760 return(nret); 761 } 762} 763 764 765nsrv_ret_t 766nsrv_aport_deregister(key,name,signature) 767 nsrv_name_t key; 768 nsrv_name_t name; 769 nsrv_name_t signature; 770{ 771 nsrv_ret_t nret; 772 773 if (!nsrv_ready()) 774 return(NSRV_NOT_READY); 775 776 if (!key || !name || !signature) 777 return(NSRV_INVAL); 778 779 if ((nret = nsrv_init_stubs()) != NSRV_OK) 780 return(nret); 781 782 if (shm_enabled) 783 return(nsrv_aport_deregister_i(key,name,signature)); 784 785 else if (!stubs_ready) { 786 NsrvSockVariables; 787 788 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 789 790 if (nret != NSRV_OK) 791 return(nret); 792 793 /* pack request */ 794 nsrv_request_number = NSRV_APORT_DEREGISTER; 795 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 796 xdr_nsrv_name(&xdrs,&key) && 797 xdr_nsrv_name(&xdrs,&name) && 798 xdr_nsrv_name(&xdrs,&signature))) 799 nret = NSRV_ERROR; 800 801 NsrvSockRPC(); 802 803 if (nret != NSRV_OK) 804 return(nret); 805 806 NsrvSockUnpackSimpleReply(); 807 808 return(nret); 809 } 810 811 else { 812 NsrvVariables; 813 deregister_request_t * request; 814 simple_reply_t * reply; 815 816 NsrvPrepareRequest(MDT_DEREGISTER_REQUEST); 817 818 /* pack request message */ 819 request->reply_port_id = reply_port_id; 820 strcpy(request->key,key); 821 strcpy(request->name,name); 822 strcpy(request->signature,signature); 823 824 NsrvRPC(NSRV_APORT_DEREGISTER); 825 826 nsrv_assert(msg_type == MDT_SIMPLE_REPLY); 827 828 /* unpack reply message */ 829 nret = reply->ret; 830 831 NsrvFinishRequest(); 832 833 return(nret); 834 } 835} 836 837 838nsrv_ret_t 839nsrv_aport_look_up(key,name,port) 840 nsrv_name_t key; 841 nsrv_name_t name; 842 aport_t * port; 843{ 844 nsrv_ret_t nret; 845 846 if (!nsrv_ready()) 847 return(NSRV_NOT_READY); 848 849 if (!key || !name || !port) 850 return(NSRV_INVAL); 851 852 if ((nret = nsrv_init_stubs()) != NSRV_OK) 853 return(nret); 854 855 if (shm_enabled) 856 return(nsrv_aport_look_up_i(key,name,port)); 857 858 else if (!stubs_ready) { 859 NsrvSockVariables; 860 861 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 862 863 if (nret != NSRV_OK) 864 return(nret); 865 866 /* pack request */ 867 nsrv_request_number = NSRV_APORT_LOOK_UP; 868 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 869 xdr_nsrv_name(&xdrs,&key) && 870 xdr_nsrv_name(&xdrs,&name))) 871 nret = NSRV_ERROR; 872 873 NsrvSockRPC(); 874 875 if (nret != NSRV_OK) 876 return(nret); 877 878 /* unpack reply */ 879 880 if (!xdr_nsrv_ret(&xdrs,&nret)) 881 nret = NSRV_ERROR; 882 883 if ((nret == NSRV_OK) && (!(xdr_aport(&xdrs,port)))) 884 nret = NSRV_ERROR; 885 886 xdr_destroy(&xdrs); 887 888 return(nret); 889 } 890 891 else { 892 NsrvVariables; 893 look_up_request_t * request; 894 aport_reply_t * reply; 895 896 NsrvPrepareRequest(MDT_LOOK_UP_REQUEST); 897 898 /* pack request message */ 899 request->reply_port_id = reply_port_id; 900 strcpy(request->key,key); 901 strcpy(request->name,name); 902 903 NsrvRPC(NSRV_APORT_LOOK_UP); 904 905 nsrv_assert(msg_type == MDT_APORT_REPLY); 906 907 /* unpack reply message */ 908 nret = reply->ret; 909 *port = reply->port; 910 911 NsrvFinishRequest(); 912 913 return(nret); 914 } 915} 916 917 918nsrv_ret_t 919nsrv_bport_register(key,name,signature,port) 920 nsrv_name_t key; 921 nsrv_name_t name; 922 nsrv_name_t signature; 923 bport_t * port; 924{ 925 nsrv_ret_t nret; 926 927 if (!nsrv_ready()) 928 return(NSRV_NOT_READY); 929 930 if (!key || !name || !signature || !port) 931 return(NSRV_INVAL); 932 933 if ((nret = nsrv_init_stubs()) != NSRV_OK) 934 return(nret); 935 936 if (shm_enabled) 937 return(nsrv_bport_register_i(key,name,signature,port)); 938 939 else if (!stubs_ready) { 940 NsrvSockVariables; 941 942 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 943 944 if (nret != NSRV_OK) 945 return(nret); 946 947 /* pack request */ 948 nsrv_request_number = NSRV_BPORT_REGISTER; 949 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 950 xdr_nsrv_name(&xdrs,&key) && 951 xdr_nsrv_name(&xdrs,&name) && 952 xdr_nsrv_name(&xdrs,&signature) && 953 xdr_bport(&xdrs,port))) 954 nret = NSRV_ERROR; 955 956 NsrvSockRPC(); 957 958 if (nret != NSRV_OK) 959 return(nret); 960 961 NsrvSockUnpackSimpleReply(); 962 963 return(nret); 964 } 965 966 else { 967 NsrvVariables; 968 bport_register_request_t * request; 969 simple_reply_t * reply; 970 971 NsrvPrepareRequest(MDT_BPORT_REGISTER_REQUEST); 972 973 /* pack request message */ 974 request->reply_port_id = reply_port_id; 975 strcpy(request->key,key); 976 strcpy(request->name,name); 977 strcpy(request->signature,signature); 978 request->port = *port; 979 980 NsrvRPC(NSRV_BPORT_REGISTER); 981 982 nsrv_assert(msg_type == MDT_SIMPLE_REPLY); 983 984 /* unpack reply message */ 985 nret = reply->ret; 986 987 NsrvFinishRequest(); 988 989 return(nret); 990 } 991} 992 993 994nsrv_ret_t 995nsrv_bport_deregister(key,name,signature) 996 nsrv_name_t key; 997 nsrv_name_t name; 998 nsrv_name_t signature; 999{ 1000 nsrv_ret_t nret; 1001 1002 if (!nsrv_ready()) 1003 return(NSRV_NOT_READY); 1004 1005 if (!key || !name || !signature) 1006 return(NSRV_INVAL); 1007 1008 if ((nret = nsrv_init_stubs()) != NSRV_OK) 1009 return(nret); 1010 1011 if (shm_enabled) 1012 return(nsrv_bport_deregister_i(key,name,signature)); 1013 1014 else if (!stubs_ready) { 1015 NsrvSockVariables; 1016 1017 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 1018 1019 if (nret != NSRV_OK) 1020 return(nret); 1021 1022 /* pack request */ 1023 nsrv_request_number = NSRV_BPORT_DEREGISTER; 1024 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 1025 xdr_nsrv_name(&xdrs,&key) && 1026 xdr_nsrv_name(&xdrs,&name) && 1027 xdr_nsrv_name(&xdrs,&signature))) 1028 nret = NSRV_ERROR; 1029 1030 NsrvSockRPC(); 1031 1032 if (nret != NSRV_OK) 1033 return(nret); 1034 1035 NsrvSockUnpackSimpleReply(); 1036 1037 return(nret); 1038 } 1039 1040 else { 1041 NsrvVariables; 1042 deregister_request_t * request; 1043 simple_reply_t * reply; 1044 1045 NsrvPrepareRequest(MDT_DEREGISTER_REQUEST); 1046 1047 /* pack request message */ 1048 request->reply_port_id = reply_port_id; 1049 strcpy(request->key,key); 1050 strcpy(request->name,name); 1051 strcpy(request->signature,signature); 1052 1053 NsrvRPC(NSRV_BPORT_DEREGISTER); 1054 1055 nsrv_assert(msg_type == MDT_SIMPLE_REPLY); 1056 1057 /* unpack reply message */ 1058 nret = reply->ret; 1059 1060 NsrvFinishRequest(); 1061 1062 return(nret); 1063 } 1064} 1065 1066 1067nsrv_ret_t 1068nsrv_bport_look_up(key,name,port) 1069 nsrv_name_t key; 1070 nsrv_name_t name; 1071 bport_t * port; 1072{ 1073 nsrv_ret_t nret; 1074 1075 if (!nsrv_ready()) 1076 return(NSRV_NOT_READY); 1077 1078 if (!key || !name || !port) 1079 return(NSRV_INVAL); 1080 1081 if ((nret = nsrv_init_stubs()) != NSRV_OK) 1082 return(nret); 1083 1084 if (shm_enabled) 1085 return(nsrv_bport_look_up_i(key,name,port)); 1086 1087 else if (!stubs_ready) { 1088 NsrvSockVariables; 1089 1090 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 1091 1092 if (nret != NSRV_OK) 1093 return(nret); 1094 1095 /* pack request */ 1096 nsrv_request_number = NSRV_BPORT_LOOK_UP; 1097 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 1098 xdr_nsrv_name(&xdrs,&key) && 1099 xdr_nsrv_name(&xdrs,&name))) 1100 nret = NSRV_ERROR; 1101 1102 NsrvSockRPC(); 1103 1104 if (nret != NSRV_OK) 1105 return(nret); 1106 1107 if (!xdr_nsrv_ret(&xdrs,&nret)) 1108 nret = NSRV_ERROR; 1109 1110 if ((nret == NSRV_OK) && (!(xdr_bport(&xdrs,port)))) 1111 nret = NSRV_ERROR; 1112 1113 xdr_destroy(&xdrs); 1114 1115 return(nret); 1116 } 1117 1118 else { 1119 NsrvVariables; 1120 look_up_request_t * request; 1121 bport_reply_t * reply; 1122 1123 NsrvPrepareRequest(MDT_LOOK_UP_REQUEST); 1124 1125 /* pack request message */ 1126 request->reply_port_id = reply_port_id; 1127 strcpy(request->key,key); 1128 strcpy(request->name,name); 1129 1130 NsrvRPC(NSRV_BPORT_LOOK_UP); 1131 1132 nsrv_assert(msg_type == MDT_BPORT_REPLY); 1133 1134 /* unpack reply message */ 1135 nret = reply->ret; 1136 *port = reply->port; 1137 1138 NsrvFinishRequest(); 1139 1140 return(nret); 1141 } 1142} 1143 1144 1145nsrv_ret_t 1146nsrv_bdomain_register(key,name,signature,domain) 1147 nsrv_name_t key; 1148 nsrv_name_t name; 1149 nsrv_name_t signature; 1150 bdomain_t * domain; 1151{ 1152 nsrv_ret_t nret; 1153 1154 if (!nsrv_ready()) 1155 return(NSRV_NOT_READY); 1156 1157 if (!key || !name || !signature || !domain) 1158 return(NSRV_INVAL); 1159 1160 /* ensure validity of filename string */ 1161 domain->bdomain_file[BMSG_FILENAMELEN_MAX] = '\0'; 1162 1163 if ((nret = nsrv_init_stubs()) != NSRV_OK) 1164 return(nret); 1165 1166 if (shm_enabled) 1167 return(nsrv_bdomain_register_i(key,name,signature,domain)); 1168 1169 else if (!stubs_ready) { 1170 NsrvSockVariables; 1171 1172 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 1173 1174 if (nret != NSRV_OK) 1175 return(nret); 1176 1177 /* pack request */ 1178 nsrv_request_number = NSRV_BDOMAIN_REGISTER; 1179 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 1180 xdr_nsrv_name(&xdrs,&key) && 1181 xdr_nsrv_name(&xdrs,&name) && 1182 xdr_nsrv_name(&xdrs,&signature) && 1183 xdr_bdomain(&xdrs,domain))) 1184 nret = NSRV_ERROR; 1185 1186 NsrvSockRPC(); 1187 1188 if (nret != NSRV_OK) 1189 return(nret); 1190 1191 NsrvSockUnpackSimpleReply(); 1192 1193 return(nret); 1194 } 1195 1196 else { 1197 NsrvVariables; 1198 bdomain_register_request_t * request; 1199 simple_reply_t * reply; 1200 1201 NsrvPrepareRequest(MDT_BDOMAIN_REGISTER_REQUEST); 1202 1203 /* pack request message */ 1204 request->reply_port_id = reply_port_id; 1205 strcpy(request->key,key); 1206 strcpy(request->name,name); 1207 strcpy(request->signature,signature); 1208 request->domain = *domain; 1209 1210 NsrvRPC(NSRV_BDOMAIN_REGISTER); 1211 1212 nsrv_assert(msg_type == MDT_SIMPLE_REPLY); 1213 1214 /* unpack reply message */ 1215 nret = reply->ret; 1216 1217 NsrvFinishRequest(); 1218 1219 return(nret); 1220 } 1221} 1222 1223 1224nsrv_ret_t 1225nsrv_bdomain_deregister(key,name,signature) 1226 nsrv_name_t key; 1227 nsrv_name_t name; 1228 nsrv_name_t signature; 1229{ 1230 nsrv_ret_t nret; 1231 1232 if (!nsrv_ready()) 1233 return(NSRV_NOT_READY); 1234 1235 if (!key || !name || !signature) 1236 return(NSRV_INVAL); 1237 1238 if ((nret = nsrv_init_stubs()) != NSRV_OK) 1239 return(nret); 1240 1241 if (shm_enabled) 1242 return(nsrv_bdomain_deregister_i(key,name,signature)); 1243 1244 else if (!stubs_ready) { 1245 NsrvSockVariables; 1246 1247 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 1248 1249 if (nret != NSRV_OK) 1250 return(nret); 1251 1252 /* pack request */ 1253 nsrv_request_number = NSRV_BDOMAIN_DEREGISTER; 1254 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 1255 xdr_nsrv_name(&xdrs,&key) && 1256 xdr_nsrv_name(&xdrs,&name) && 1257 xdr_nsrv_name(&xdrs,&signature))) 1258 nret = NSRV_ERROR; 1259 1260 NsrvSockRPC(); 1261 1262 if (nret != NSRV_OK) 1263 return(nret); 1264 1265 NsrvSockUnpackSimpleReply(); 1266 1267 return(nret); 1268 } 1269 1270 else { 1271 NsrvVariables; 1272 bdomain_register_request_t * request; 1273 simple_reply_t * reply; 1274 1275 NsrvPrepareRequest(MDT_DEREGISTER_REQUEST); 1276 1277 /* pack request message */ 1278 request->reply_port_id = reply_port_id; 1279 strcpy(request->key,key); 1280 strcpy(request->name,name); 1281 strcpy(request->signature,signature); 1282 1283 NsrvRPC(NSRV_BDOMAIN_DEREGISTER); 1284 1285 nsrv_assert(msg_type == MDT_SIMPLE_REPLY); 1286 1287 /* unpack reply message */ 1288 nret = reply->ret; 1289 1290 NsrvFinishRequest(); 1291 1292 return(nret); 1293 } 1294} 1295 1296 1297nsrv_ret_t 1298nsrv_bdomain_look_up(key,name,domain) 1299 nsrv_name_t key; 1300 nsrv_name_t name; 1301 bdomain_t * domain; 1302{ 1303 nsrv_ret_t nret; 1304 1305 if (!nsrv_ready()) 1306 return(NSRV_NOT_READY); 1307 1308 if (!key || !name || !domain || !domain->bdomain_file) 1309 return(NSRV_INVAL); 1310 1311 if ((nret = nsrv_init_stubs()) != NSRV_OK) 1312 return(nret); 1313 1314 if (shm_enabled) 1315 return(nsrv_bdomain_look_up_i(key,name,domain)); 1316 1317 else if (!stubs_ready) { 1318 NsrvSockVariables; 1319 1320 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 1321 1322 if (nret != NSRV_OK) 1323 return(nret); 1324 1325 /* pack request */ 1326 nsrv_request_number = NSRV_BDOMAIN_LOOK_UP; 1327 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 1328 xdr_nsrv_name(&xdrs,&key) && 1329 xdr_nsrv_name(&xdrs,&name))) 1330 nret = NSRV_ERROR; 1331 1332 NsrvSockRPC(); 1333 1334 if (nret != NSRV_OK) 1335 return(nret); 1336 1337 /* unpack reply */ 1338 1339 if (!xdr_nsrv_ret(&xdrs,&nret)) 1340 nret = NSRV_ERROR; 1341 1342 if ((nret == NSRV_OK) && (!(xdr_bdomain(&xdrs,domain)))) 1343 nret = NSRV_ERROR; 1344 1345 xdr_destroy(&xdrs); 1346 1347 return(nret); 1348 } 1349 1350 else { 1351 NsrvVariables; 1352 look_up_request_t * request; 1353 bdomain_reply_t * reply; 1354 1355 NsrvPrepareRequest(MDT_LOOK_UP_REQUEST); 1356 1357 /* pack request message */ 1358 request->reply_port_id = reply_port_id; 1359 strcpy(request->key,key); 1360 strcpy(request->name,name); 1361 1362 NsrvRPC(NSRV_BDOMAIN_LOOK_UP); 1363 1364 nsrv_assert(msg_type == MDT_BDOMAIN_REPLY); 1365 1366 /* unpack reply message */ 1367 nret = reply->ret; 1368 *domain = reply->domain; 1369 1370 NsrvFinishRequest(); 1371 1372 return(nret); 1373 } 1374} 1375 1376 1377nsrv_ret_t 1378nsrv_new_bport_id(signature,port_id) 1379 nsrv_name_t signature; 1380 bport_id_t * port_id; 1381{ 1382 nsrv_ret_t nret; 1383 1384 if (!nsrv_ready()) 1385 return(NSRV_NOT_READY); 1386 1387 if (!signature || !port_id) 1388 return(NSRV_INVAL); 1389 1390 if ((nret = nsrv_init_stubs()) != NSRV_OK) 1391 return(nret); 1392 1393 if (shm_enabled) 1394 return(nsrv_new_bport_id_i(signature,port_id)); 1395 1396 else if (!stubs_ready) { 1397 NsrvSockVariables; 1398 1399 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 1400 1401 if (nret != NSRV_OK) 1402 return(nret); 1403 1404 /* pack request */ 1405 nsrv_request_number = NSRV_NEW_BPORT_ID; 1406 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 1407 xdr_nsrv_name(&xdrs,&signature) && 1408 xdr_bport_id(&xdrs,port_id))) 1409 nret = NSRV_ERROR; 1410 1411 NsrvSockRPC(); 1412 1413 if (nret != NSRV_OK) 1414 return(nret); 1415 1416 /* unpack reply */ 1417 1418 if (!xdr_nsrv_ret(&xdrs,&nret)) 1419 nret = NSRV_ERROR; 1420 1421 if ((nret == NSRV_OK) && (!(xdr_bport_id(&xdrs,port_id)))) 1422 nret = NSRV_ERROR; 1423 1424 xdr_destroy(&xdrs); 1425 1426 return(nret); 1427 } 1428 1429 else { 1430 NsrvVariables; 1431 bport_id_request_t * request; 1432 bport_id_reply_t * reply; 1433 1434 NsrvPrepareRequest(MDT_BPORTID_REQUEST); 1435 1436 /* pack request message */ 1437 request->request_number = NSRV_NEW_BPORT_ID; 1438 request->reply_port_id = reply_port_id; 1439 strcpy(request->signature,signature); 1440 request->port_id = *port_id; 1441 1442 NsrvRPC(NSRV_NEW_BPORT_ID); 1443 1444 nsrv_assert(msg_type == MDT_BPORTID_REPLY); 1445 1446 /* unpack reply message */ 1447 nret = reply->ret; 1448 *port_id = reply->port_id; 1449 1450 NsrvFinishRequest(); 1451 1452 return(nret); 1453 } 1454} 1455 1456 1457nsrv_ret_t 1458nsrv_free_bport_id(signature,port_id) 1459 nsrv_name_t signature; 1460 bport_id_t port_id; 1461{ 1462 nsrv_ret_t nret; 1463 1464 if (!nsrv_ready()) 1465 return(NSRV_NOT_READY); 1466 1467 if (!signature) 1468 return(NSRV_INVAL); 1469 1470 if ((nret = nsrv_init_stubs()) != NSRV_OK) 1471 return(nret); 1472 1473 if (shm_enabled) 1474 return(nsrv_free_bport_id_i(signature,port_id)); 1475 1476 else if (!stubs_ready) { 1477 NsrvSockVariables; 1478 1479 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 1480 1481 if (nret != NSRV_OK) 1482 return(nret); 1483 1484 /* pack request */ 1485 nsrv_request_number = NSRV_FREE_BPORT_ID; 1486 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 1487 xdr_nsrv_name(&xdrs,&signature) && 1488 xdr_bport_id(&xdrs,&port_id))) 1489 nret = NSRV_ERROR; 1490 1491 NsrvSockRPC(); 1492 1493 if (nret != NSRV_OK) 1494 return(nret); 1495 1496 NsrvSockUnpackSimpleReply(); 1497 1498 return(nret); 1499 } 1500 1501 else { 1502 NsrvVariables; 1503 bport_id_request_t * request; 1504 simple_reply_t * reply; 1505 1506 NsrvPrepareRequest(MDT_BPORTID_REQUEST); 1507 1508 /* pack request message */ 1509 request->request_number = NSRV_FREE_BPORT_ID; 1510 request->reply_port_id = reply_port_id; 1511 strcpy(request->signature,signature); 1512 request->port_id = port_id; 1513 1514 NsrvRPC(NSRV_FREE_BPORT_ID); 1515 1516 nsrv_assert(msg_type == MDT_SIMPLE_REPLY); 1517 1518 /* unpack reply message */ 1519 nret = reply->ret; 1520 1521 NsrvFinishRequest(); 1522 1523 return(nret); 1524 } 1525} 1526 1527 1528nsrv_ret_t 1529nsrv_new_bdomain_id(signature,domain_id) 1530 nsrv_name_t signature; 1531 bdomain_id_t * domain_id; 1532{ 1533 nsrv_ret_t nret; 1534 1535 if (!nsrv_ready()) 1536 return(NSRV_NOT_READY); 1537 1538 if (!signature || !domain_id) 1539 return(NSRV_INVAL); 1540 1541 if ((nret = nsrv_init_stubs()) != NSRV_OK) 1542 return(nret); 1543 1544 if (shm_enabled) 1545 return(nsrv_new_bdomain_id_i(signature,domain_id)); 1546 1547 else if (!stubs_ready) { 1548 NsrvSockVariables; 1549 1550 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 1551 1552 if (nret != NSRV_OK) 1553 return(nret); 1554 1555 /* pack request */ 1556 nsrv_request_number = NSRV_NEW_BDOMAIN_ID; 1557 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 1558 xdr_nsrv_name(&xdrs,&signature) && 1559 xdr_bdomain_id(&xdrs,domain_id))) 1560 nret = NSRV_ERROR; 1561 1562 NsrvSockRPC(); 1563 1564 if (nret != NSRV_OK) 1565 return(nret); 1566 1567 /* unpack reply */ 1568 1569 if (!xdr_nsrv_ret(&xdrs,&nret)) 1570 nret = NSRV_ERROR; 1571 1572 if ((nret == NSRV_OK) && (!(xdr_bdomain_id(&xdrs,domain_id)))) 1573 nret = NSRV_ERROR; 1574 1575 xdr_destroy(&xdrs); 1576 1577 return(nret); 1578 } 1579 1580 else { 1581 NsrvVariables; 1582 bdomain_id_request_t * request; 1583 bdomain_id_reply_t * reply; 1584 1585 NsrvPrepareRequest(MDT_BDOMAINID_REQUEST); 1586 1587 /* pack request message */ 1588 request->request_number = NSRV_NEW_BDOMAIN_ID; 1589 request->reply_port_id = reply_port_id; 1590 strcpy(request->signature,signature); 1591 request->domain_id = *domain_id; 1592 1593 NsrvRPC(NSRV_NEW_BDOMAIN_ID); 1594 1595 nsrv_assert(msg_type == MDT_BDOMAINID_REPLY); 1596 1597 /* unpack reply message */ 1598 nret = reply->ret; 1599 *domain_id = reply->domain_id; 1600 1601 NsrvFinishRequest(); 1602 1603 return(nret); 1604 } 1605} 1606 1607 1608nsrv_ret_t 1609nsrv_free_bdomain_id(signature,domain_id) 1610 nsrv_name_t signature; 1611 bdomain_id_t domain_id; 1612{ 1613 nsrv_ret_t nret; 1614 1615 if (!nsrv_ready()) 1616 return(NSRV_NOT_READY); 1617 1618 if (!signature) 1619 return(NSRV_INVAL); 1620 1621 if ((nret = nsrv_init_stubs()) != NSRV_OK) 1622 return(nret); 1623 1624 if (shm_enabled) 1625 return(nsrv_free_bdomain_id_i(signature,domain_id)); 1626 1627 else if (!stubs_ready) { 1628 NsrvSockVariables; 1629 1630 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 1631 1632 if (nret != NSRV_OK) 1633 return(nret); 1634 1635 /* pack request */ 1636 nsrv_request_number = NSRV_FREE_BDOMAIN_ID; 1637 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 1638 xdr_nsrv_name(&xdrs,&signature) && 1639 xdr_bdomain_id(&xdrs,&domain_id))) 1640 nret = NSRV_ERROR; 1641 1642 NsrvSockRPC(); 1643 1644 if (nret != NSRV_OK) 1645 return(nret); 1646 1647 NsrvSockUnpackSimpleReply(); 1648 1649 return(nret); 1650 } 1651 1652 else { 1653 NsrvVariables; 1654 bdomain_id_request_t * request; 1655 simple_reply_t * reply; 1656 1657 NsrvPrepareRequest(MDT_BDOMAINID_REQUEST); 1658 1659 /* pack request message */ 1660 request->request_number = NSRV_FREE_BDOMAIN_ID; 1661 request->reply_port_id = reply_port_id; 1662 strcpy(request->signature,signature); 1663 request->domain_id = domain_id; 1664 1665 NsrvRPC(NSRV_FREE_BDOMAIN_ID); 1666 1667 nsrv_assert(msg_type == MDT_SIMPLE_REPLY); 1668 1669 /* unpack reply message */ 1670 nret = reply->ret; 1671 1672 NsrvFinishRequest(); 1673 1674 return(nret); 1675 } 1676} 1677 1678 1679nsrv_ret_t 1680nsrv_version(version) 1681 nsrv_version_t * version; 1682{ 1683 nsrv_ret_t nret; 1684 1685 if (!nsrv_ready()) 1686 return(NSRV_NOT_READY); 1687 1688 if (!version) 1689 return(NSRV_INVAL); 1690 1691 if ((nret = nsrv_init_stubs()) != NSRV_OK) 1692 return(nret); 1693 1694 if (shm_enabled) { 1695 version->v_major = NSRV_VERSION_MAJOR; 1696 version->v_minor = NSRV_VERSION_MINOR; 1697 return(nsrv_version_i(version)); 1698 } 1699 1700 else if (!stubs_ready) { 1701 NsrvSockVariables; 1702 1703 NsrvSockPrepareRequest(nsrv_inet_address,nsrv_port_number); 1704 1705 if (nret != NSRV_OK) 1706 return(nret); 1707 1708 /* pack request */ 1709 nsrv_request_number = NSRV_VERSION; 1710 if (!(xdr_nsrv_number(&xdrs,&nsrv_request_number) && 1711 xdr_nsrv_version(&xdrs,version))) 1712 nret = NSRV_ERROR; 1713 1714 NsrvSockRPC(); 1715 1716 if (nret != NSRV_OK) 1717 return(nret); 1718 1719 /* unpack reply */ 1720 1721 if (!xdr_nsrv_ret(&xdrs,&nret)) 1722 nret = NSRV_ERROR; 1723 1724 if ((nret == NSRV_OK) && (!(xdr_nsrv_version(&xdrs,version)))) 1725 nret = NSRV_ERROR; 1726 1727 xdr_destroy(&xdrs); 1728 1729 return(nret); 1730 } 1731 1732 else { 1733 NsrvVariables; 1734 version_request_t * request; 1735 version_reply_t * reply; 1736 1737 NsrvPrepareRequest(MDT_VERSION_REQUEST); 1738 1739 /* pack request message */ 1740 request->request_number = NSRV_VERSION; 1741 request->reply_port_id = reply_port_id; 1742 1743 NsrvRPC(NSRV_VERSION); 1744 1745 nsrv_assert(msg_type == MDT_VERSION_REPLY); 1746 1747 /* unpack reply message */ 1748 nret = reply->ret; 1749 version->v_major = reply->version.v_major; 1750 version->v_minor = reply->version.v_minor; 1751 1752 NsrvFinishRequest(); 1753 1754 return(nret); 1755 } 1756} 1757 1758 1759static char * nsrv_errlist[NSRV_EVERSION-PDS_RET_MAX] = { 1760 "No such port !", 1761 "Name server not ready !", 1762 "Not yours !", 1763 "Not registered !", 1764 "No such domain !", 1765 "No name server !", 1766 "No such host !", 1767 "Incompatible version !"}; 1768 1769 1770char * 1771nsrv_error_string(nret) 1772 nsrv_ret_t nret; 1773{ 1774 return nsrv_errlist[nret-PDS_RET_MAX]; 1775} 1776 1777 1778void 1779nsrv_perror(nret, s) 1780 nsrv_ret_t nret; 1781 char * s; 1782{ 1783 if (nret > PDS_RET_MAX) { 1784 if (s && s[0] != '\0') 1785 fprintf(stderr,"%s: ",s); 1786 fprintf(stderr, "%s\n", nsrv_error_string(nret)); 1787 } 1788 else 1789 pds_perror((pds_ret_t) nret, s); 1790} 1791 1792 1793