nameserver.c

早期freebsd实现

			break;
		}
	}
	if(type < 0)
	{
		Network._net[Network._nnets] = malloc(netlen+1);
		if(Network._net[Network._nnets] == NULL)
		{
		        errno = ENOMEM;
               		perror("Client can't connect to remote server");
			close(fd);
               		return (-1);
               }
	       memcpy(Network._net[Network._nnets], netbuffer, netlen+1);
	       type = Network._nnets++;
	}
	_XsTypeOfStream[fd] = type;
	PRMSG("A Connection has been established to %s ... \n", host,0);
	PRMSG("CallTliServer() returns success\n",0,0);

	return(fd);
}

static int
OpenAndBind(name, port, maxcon, nettype, type)
    char *name;
    int	port, maxcon, type;
    char *nettype;
{
	char	bind_buf[MAX_AUTO_BUF_LEN];
	int	i, fd;
	char	*retptr;
	
	if(!svr4plus)
		sprintf(clonedev, "/dev/%s", nettype);
	if(name != NULL)
		PRMSG("OpenAndBind name %s, clonedev is %s \n",
				 name, clonedev);

	/* point to the virtual circuit */

	if ((fd = t_open(clonedev,  O_RDWR, NULL)) < 0)
	{
		fprintf(stderr, "Cannot open %s\n", clonedev);
#ifdef DEBUG
		t_error("t_open 1 failed");
#endif
		return(-1);
	}

	_XsTypeOfStream[fd] = type;
	/* fill in the request call structure with necessary infomation */

	if(name != NULL)
	{
	   if(GetNetworkInfo (-1, nettype, ConvertNameToTliBind, 
		addheader(name, strlen(name)), &retptr, NULL)<0)
	   {
		PRMSG("Cannot create address for system %s \n", name, 0);
		return(-1);
	   }
	   bind_req.addr.buf = bind_buf;
	   bind_req.addr.len = ((xHostEntry *) retptr)->length;
	   bcopy (retptr+sizeof(xHostEntry), bind_buf, bind_req.addr.len);
	   free(retptr);
	   bind_buf[bind_req.addr.len] = '\0';
#ifdef DEBUG
	   fprintf(stderr, "ADDRESS LENGTH IS %d\n", bind_req.addr.len);
	   fprintf(stderr, "Address returned is <%s>\n", bind_buf);
#endif
	   bind_req.qlen = maxcon;

	/* bind the name to the transport endpoint.  This operation will */
	/* take some time if the name is not already in the local name  */
	/* table or if the name is not a group name   */
#ifdef SHARELIB
#define t_bind (*_libX_t_bind)
#endif
		i = t_bind (fd, &bind_req, NULL) ;
	}
	else 	i = t_bind (fd, NULL, NULL);

	if(i < 0)
	{
		t_error("t_bind failed");
		close(fd);
		return(-1);
	}

#ifdef SHARELIB
#undef t_bind
#endif
	if(name != NULL)
		PRMSG("OpenAndBind(%s, %d) (success)\n", name, maxcon);
	return(fd);
}

static char *erazeComment(line)
    char *line;
{
 	char	*ptr = line;

        while(*ptr <= ' ' && *ptr != '\0')
                        ptr++;
/*
 *	If you want to check the version do it here
 *if( strncmp(ptr, "#VERSION", 8) == 0)
 *			return(NULL);
 */
   	if(*ptr == '\0' || *ptr == '#'){
                        return(NULL);
                        }
	line = ptr;
	while(*ptr != '\0' && *ptr != '#')
                        ptr++;
	*ptr = '\0';
	return(line);
}


#define XNETDB "lib/Xconnections"

int _XMakeStreamsConnection (name, idisplay, retries,
			     familyp, serveraddrlenp, serveraddrp)
    char	*name;
    int	idisplay;
    int	retries;
    int	*familyp;		/* return */
    int	*serveraddrlenp;	/* return */
    char **serveraddrp;		/* return */
{
	struct	utsname	 machine;
	register	i;
	FILE	*file;
	char	*line, *ptr,buf[160];
	int	fd, nfound = 0, n;
	static  char	netype[MAX_AUTO_BUF_LEN], nodname[MAX_AUTO_BUF_LEN];
	char *home;
	char	sysname[128] ;
	char	*procname = "Xlib/_XMakeStreamsConnection";



	PRMSG("GetConnectionType(%s)\n", name, 0);

        if(uname(&machine) < 0){
		t_error("Cannot get nodename");
		return(-1);
		}

	if(
		name == NULL || 
		strcmp(name, "") == 0 ||
		strcmp(name, "unix") == 0 ||
		strcmp(name, "local") == 0 ||
		strcmp(name, machine.nodename) == 0 
	  )	{
		
	    /*
	     * auth information for local connection set above
	     */

	    fd = ((*_XsStream[X_LOCAL_STREAM].CallTheListener)
		  ("unix", idisplay, "local"));
	    if (fd >= 0) {
		*familyp = FamilyLocal;
		*serveraddrlenp = strlen (machine.nodename);
		*serveraddrp = (char *) Xmalloc ((*serveraddrlenp) + 1);
		if (!*serveraddrp) {
		    *serveraddrlenp = 0;
		} else {
		    strcpy (*serveraddrp, machine.nodename);
		}
	    }
	    return fd;
	}

        if(machine.release[0] !=  '3')
	{
		char	*netpath;

		svr4plus = 1;
#ifdef DEBUG
		fprintf(stderr,
"sysname <%s>, nodename <%s>, release <%s>, version <%s>, machine <%s>\n",
			machine.sysname ,
			machine.nodename,
			machine.release,
			machine.version,
			machine.machine);
#endif

		if((netpath = (char *) getenv("NETPATH")) == NULL)
				netpath = "";
		return (*_XsStream[X_TLI_STREAM].CallTheListener)
				(name, idisplay, netpath);
	}

	file = fopen(home = GetXWINHome(XNETDB), "r");
	if(file == NULL){
		fprintf(stderr, "Cannot open %s\n", home);
		return(-1);
		}
	while((line = fgets(buf, 160, file)) != NULL)
	{
               	if((n = strlen(line)) > 1)
                              line[n-1] = '\0';
		if((ptr = erazeComment(line)) == NULL)
			continue;

		n = sscanf(ptr, "%s%s%s", sysname, nodname, netype);
		if(
			n >= 3 &&
			strcmp(name, sysname) == 0
		  ){
			nfound++;
		        fd = (*_XsStream[X_TLI_STREAM].CallTheListener)
						(nodname, idisplay, netype);
			if(fd >= 0)
			{
				fclose(file);
				return(fd);
			}
		   }
		else if(strcmp(sysname, "*") == 0 || strcmp(nodname, "*") == 0) 
		   {
			sprintf(nodname, name);
			fd = (*_XsStream[X_TLI_STREAM].CallTheListener)     
                                                (nodname, idisplay, netype);
			fclose(file);
                        return(fd);
		   }
	}
	fclose(file);
	if(!nfound)
	{
		fprintf(stderr, "There is no entry for %s in %s\n",
					name, home);
	}
	return(-1);
}


#ifdef DEBUG
dump(buf, len)
    char *buf;
    int	len;
{
 	int	i;
	if(buf != NULL)
		for(i=0; i< len; i++)
                        fprintf(stderr, "<%o> ", buf[i]);
	fprintf(stderr, "\n");
	fflush(stderr);
}

#endif


#define	NSECONDS	60

static int	_errflag = 0;

/* ARGSUSED */
static SIGNAL_T OnAlarm(i)
    int i;
{
	_errflag = 1;
}

static int
CallTheNameServer(service, nettype, arg1, arg2, arg3)
    char	*nettype, **arg1, **arg2;
    int	service, *arg3;
{
	int	m, n, ret;
	char   *ptr, *p;
	char	buf[MAX_AUTO_BUF_LEN];

PRMSG("In CallTheNameServer, \n", 0, 0);

	if(NameServer < 0)
		return(-1);
	if(_errflag)
	{
		int	flags;

		if((flags = fcntl(NameServer, F_GETFL)) == -1)
			flags = O_RDWR;
		fcntl (NameServer, F_SETFL, O_NDELAY);
		while(read (NameServer, buf, MAX_AUTO_BUF_LEN) > 0);
		if(errno != EAGAIN && errno != EINTR)
		{
			fprintf(stderr, "errno %d while reading the nameserver\n",
					errno);
			close(NameServer);
			NameServer = -1;
			return(-1);
		}
		fcntl (NameServer, F_SETFL, flags);
		_errflag = 0;	
	}
	
	ret = n = (* (int *) (*arg1)) + 2*sizeof(int);

        ptr = buf;
	m = HEADERSIZE + strlen(nettype)+ 1;
	m = (((m +3) >>2)<<2);

	*(int *) ptr = n+m;
	ptr += sizeof(int);
	*(int *) ptr = m;
	ptr += sizeof(int);
	*(int *) ptr = service;
	ptr += sizeof(int);
	*(int *) ptr = atoi(dispno);
	ptr += sizeof(int);
	*(int *) ptr = strlen(nettype);
	ptr += sizeof(int);
	sprintf(ptr, nettype);

  	p = malloc(m + n);
	if(p == NULL)
		return(-1);
	memcpy(p, buf, m);
	memcpy(p+m, *arg1, n);
	
	signal(SIGALRM, OnAlarm);
	alarm(NSECONDS); 

	if(write(NameServer, p, m+n) != m+n){
		fprintf(stderr, "write error\n");
		ret = -1;
		close(NameServer);
		NameServer = -1;
		}
	else if(Read(NameServer, buf, 2*sizeof(int)) == 0)
	{
		ret = -1;
#ifdef DEBUG
		fprintf(stderr, "Server fails to read header from nameserver\n");
#endif
	}
	else {
		ptr = buf;
		ret = *(int *) buf;
		ptr += sizeof(int);
		if(*(int *) ptr <= 0)
		{
#ifdef DEBUG
			fprintf(stderr, "No Of entries returned <= 0\n");
#endif
			ret = -1;
			goto theend;
		}
		if(arg3 != NULL){
			*arg3 = *(int *) ptr;
#ifdef DEBUG
			fprintf(stderr, "No Of Entries returned {%d}\n", *arg3);
#endif
			}
		ptr = *arg2 = (char *) malloc(ret );
#ifdef DEBUG
		if(ptr == NULL)
			fprintf(stderr, "MALLOC returns NULL\n");
#endif
		if(ptr == NULL)
		{
			errno = ENOMEM;
			ret = -1;
		}
		else {
			if(Read(NameServer, ptr, ret) == 0)
			{
				fprintf(stderr, 
					"Server fails to read %d chars\n", ret);
				free(*arg2);
				ret = -1;
			}
		}
	}
theend:
	alarm(0); 
	free(p);
	return(ret);
}


static int
Read(fd, buf, count)
    int	fd, count;
    char	*buf;
{
	int	n;
	while((n = read(fd, buf, count)) > 0)
	{
		if(n == count)
		{
			return(1);
		}
		buf += n;
		count -= n;
	}
	return(0);
}

static int
OpenVirtualCircuit(lfd)
    int	lfd;
{
	return(OpenAndBind(NULL, -1, 0,
		 	Network._net[_XsTypeOfStream[lfd]], _XsTypeOfStream[lfd]));
}

#endif /* XSTREAMS_COMPILE */