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