[thirdparty/glibc.git] / nis / nis_findserv.c

/* Copyright (C) 1997, 1998, 2000, 2001 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <rpc/pmap_prot.h>
#include <rpc/pmap_clnt.h>
#include <rpcsvc/nis.h>

#include "nis_intern.h"

/* Private data kept per client handle, from sunrpc/clnt_udp.c */
struct cu_data
  {
    int cu_sock;
    bool_t cu_closeit;
    struct sockaddr_in cu_raddr;
    int cu_rlen;
    struct timeval cu_wait;
    struct timeval cu_total;
    struct rpc_err cu_error;
    XDR cu_outxdrs;
    u_int cu_xdrpos;
    u_int cu_sendsz;
    char *cu_outbuf;
    u_int cu_recvsz;
    char cu_inbuf[1];
  };


/* The following is the original routine from sunrpc/pm_getport.c.
   The only change is the much shorter timeout. */
/*
 * pmap_getport.c
 * Client interface to pmap rpc service.
 *
 * Copyright (C) 1984, Sun Microsystems, Inc.
 */

/*
 * Find the mapped port for program,version.
 * Calls the pmap service remotely to do the lookup.
 * Returns 0 if no map exists.
 */
u_short
__pmap_getnisport (struct sockaddr_in *address, u_long program,
		   u_long version, u_int protocol)
{
  const struct timeval timeout = {1, 0};
  const struct timeval tottimeout = {1, 0};
  u_short port = 0;
  int socket = -1;
  CLIENT *client;
  struct pmap parms;

  address->sin_port = htons (PMAPPORT);
  client = clntudp_bufcreate (address, PMAPPROG, PMAPVERS, timeout, &socket,
			      RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
  if (client != (CLIENT *) NULL)
    {
      parms.pm_prog = program;
      parms.pm_vers = version;
      parms.pm_prot = protocol;
      parms.pm_port = 0;	/* not needed or used */
      if (CLNT_CALL (client, PMAPPROC_GETPORT, (xdrproc_t) xdr_pmap,
		     (caddr_t) & parms, (xdrproc_t) xdr_u_short,
		     (caddr_t) & port, tottimeout) != RPC_SUCCESS)
	{
	  rpc_createerr.cf_stat = RPC_PMAPFAILURE;
	  clnt_geterr (client, &rpc_createerr.cf_error);
	}
      else
	{
	  if (port == 0)
	    rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
	}
      CLNT_DESTROY (client);
    }
  /* (void)close(socket); CLNT_DESTROY already closed it */
  address->sin_port = 0;
  return port;
}

/* This is now the public function, which should find the fastest server */

struct findserv_req
{
  struct sockaddr_in sin;
  u_int32_t xid;
  u_int server_nr;
  u_int server_ep;
};

long
__nis_findfastest (dir_binding *bind)
{
#if 0
  unsigned long i, j;

  for (i = 0; i < bind->server_len; i++)
    for (j = 0; j < bind->server_val[i].ep.ep_len; ++j)
      if (strcmp (bind->server_val[i].ep.ep_val[j].family, "inet") == 0)
	if ((bind->server_val[i].ep.ep_val[j].proto == NULL) ||
	    (bind->server_val[i].ep.ep_val[j].proto[0] ==  '-') ||
	    (bind->server_val[i].ep.ep_val[j].proto[0] == '\0'))
	  {
	    bind->server_used = i;
	    bind->current_ep = j;
	    return 1;
	  }

  return 0;
#else
  const struct timeval TIMEOUT50 = {5, 0};
  const struct timeval TIMEOUT00 = {0, 0};
  struct findserv_req *pings;
  struct sockaddr_in sin, saved_sin;
  int found = -1;
  u_int32_t xid_seed, xid_lookup;
  int sock, dontblock = 1;
  CLIENT *clnt;
  char clnt_res;
  void *foo = NULL;
  u_long i, j, pings_count, pings_max;
  struct cu_data *cu;

  pings_max = bind->server_len * 2;	/* Reserve a little bit more memory
					   for multihomed hosts */
  pings_count = 0;
  pings = malloc (sizeof (struct findserv_req) * pings_max);
  xid_seed = (u_int32_t) (time (NULL) ^ getpid ());

  if (__builtin_expect (pings == NULL, 0))
    return -1;

  memset (&sin, '\0', sizeof (sin));
  sin.sin_family = AF_INET;
  for (i = 0; i < bind->server_len; i++)
    for (j = 0; j < bind->server_val[i].ep.ep_len; ++j)
      if (strcmp (bind->server_val[i].ep.ep_val[j].family, "inet") == 0)
	if ((bind->server_val[i].ep.ep_val[j].proto == NULL) ||
	    (bind->server_val[i].ep.ep_val[j].proto[0] == '-') ||
	    (bind->server_val[i].ep.ep_val[j].proto[0] == '\0'))
	  {
	    sin.sin_addr.s_addr =
	      inetstr2int (bind->server_val[i].ep.ep_val[j].uaddr);
	    if (sin.sin_addr.s_addr == 0)
	      continue;
	    sin.sin_port = htons (__pmap_getnisport (&sin, NIS_PROG,
						     NIS_VERSION,
						     IPPROTO_UDP));
	    if (sin.sin_port == 0)
	      continue;

	    if (pings_count >= pings_max)
	      {
		struct findserv_req *new_pings;

		pings_max += 10;
		new_pings = realloc (pings, sizeof (struct findserv_req) *
				     pings_max);
		if (__builtin_expect (new_pings == NULL, 0))
		  {
		    free (pings);
		    return -1;
		  }
		pings = new_pings;
	      }
	    memcpy ((char *) &pings[pings_count].sin, (char *) &sin,
		    sizeof (sin));
	    memcpy ((char *)&saved_sin, (char *)&sin, sizeof(sin));
	    pings[pings_count].xid = xid_seed;
	    pings[pings_count].server_nr = i;
	    pings[pings_count].server_ep = j;
	    ++xid_seed;
	    ++pings_count;
	  }

  /* Make sure at least one server was assigned */
  if (pings_count == 0)
    {
      free (pings);
      return -1;
    }

  /* Create RPC handle */
  sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  clnt = clntudp_create (&saved_sin, NIS_PROG, NIS_VERSION, TIMEOUT50, &sock);
  if (clnt == NULL)
    {
      close (sock);
      free (pings);
      return -1;
    }
  auth_destroy (clnt->cl_auth);
  clnt->cl_auth = authunix_create_default ();
  cu = (struct cu_data *) clnt->cl_private;
  clnt_control (clnt, CLSET_TIMEOUT, (char *) &TIMEOUT00);
  ioctl (sock, FIONBIO, &dontblock);

  /* Send to all servers the NULLPROC */
  for (i = 0; i < pings_count; ++i)
    {
      /* clntudp_call() will increment, subtract one */
      *((u_int32_t *) (cu->cu_outbuf)) = pings[i].xid - 1;
      memcpy ((char *) &cu->cu_raddr, (char *) &pings[i].sin,
	      sizeof (struct sockaddr_in));
      /* Transmit to NULLPROC, return immediately. */
      clnt_call (clnt, NULLPROC, (xdrproc_t) xdr_void, (caddr_t) foo,
		 (xdrproc_t) xdr_void, (caddr_t) & clnt_res, TIMEOUT00);
    }

  /* Receive reply from NULLPROC asynchronously */
  memset ((char *) &clnt_res, 0, sizeof (clnt_res));
  clnt_call (clnt, NULLPROC, (xdrproc_t) NULL, (caddr_t) foo,
	     (xdrproc_t) xdr_void, (caddr_t) &clnt_res, TIMEOUT00);

  xid_lookup = *((u_int32_t *) (cu->cu_inbuf));
  for (i = 0; i < pings_count; i++)
    {
      if (pings[i].xid == xid_lookup)
	{
	  bind->server_used = pings[i].server_nr;
	  bind->current_ep = pings[i].server_ep;
	  found = 1;
	}
    }

  auth_destroy (clnt->cl_auth);
  clnt_destroy (clnt);
  close (sock);

  free (pings);

  return found;
#endif
}
Commit	Line	Data
306eeae5	1	/* Copyright (C) 1997, 1998, 2000, 2001 Free Software Foundation, Inc.
3996f34b UD	2	This file is part of the GNU C Library.
	3	Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
	4
	5	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
3996f34b UD	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	13	Lesser General Public License for more details.
3996f34b	14
41bdb6e2 AJ	15	You should have received a copy of the GNU Lesser General Public
	16	License along with the GNU C Library; if not, write to the Free
	17	Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	18	02111-1307 USA. */
3996f34b UD	19
3996f34b UD	20	#include <string.h>
306eeae5	21	#include <time.h>
3996f34b UD	22	#include <unistd.h>
3996f34b UD	23	#include <sys/ioctl.h>
18de8c73	24	#include <sys/socket.h>
3996f34b UD	25	#include <rpc/pmap_prot.h>
	26	#include <rpc/pmap_clnt.h>
	27	#include <rpcsvc/nis.h>
	28
	29	#include "nis_intern.h"
	30
	31	/* Private data kept per client handle, from sunrpc/clnt_udp.c */
	32	struct cu_data
	33	{
	34	int cu_sock;
	35	bool_t cu_closeit;
	36	struct sockaddr_in cu_raddr;
	37	int cu_rlen;
	38	struct timeval cu_wait;
	39	struct timeval cu_total;
	40	struct rpc_err cu_error;
	41	XDR cu_outxdrs;
	42	u_int cu_xdrpos;
	43	u_int cu_sendsz;
	44	char *cu_outbuf;
	45	u_int cu_recvsz;
	46	char cu_inbuf[1];
	47	};
	48
	49
	50	/* The following is the original routine from sunrpc/pm_getport.c.
	51	The only change is the much shorter timeout. */
	52	/*
	53	* pmap_getport.c
	54	* Client interface to pmap rpc service.
	55	*
	56	* Copyright (C) 1984, Sun Microsystems, Inc.
	57	*/
	58
	59	/*
	60	* Find the mapped port for program,version.
	61	* Calls the pmap service remotely to do the lookup.
	62	* Returns 0 if no map exists.
	63	*/
26a60f90 UD	64	u_short
	65	__pmap_getnisport (struct sockaddr_in *address, u_long program,
	66	u_long version, u_int protocol)
3996f34b UD	67	{
	68	const struct timeval timeout = {1, 0};
	69	const struct timeval tottimeout = {1, 0};
	70	u_short port = 0;
	71	int socket = -1;
	72	CLIENT *client;
	73	struct pmap parms;
	74
	75	address->sin_port = htons (PMAPPORT);
	76	client = clntudp_bufcreate (address, PMAPPROG, PMAPVERS, timeout, &socket,
	77	RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
	78	if (client != (CLIENT *) NULL)
	79	{
	80	parms.pm_prog = program;
	81	parms.pm_vers = version;
	82	parms.pm_prot = protocol;
	83	parms.pm_port = 0; /* not needed or used */
	84	if (CLNT_CALL (client, PMAPPROC_GETPORT, (xdrproc_t) xdr_pmap,
	85	(caddr_t) & parms, (xdrproc_t) xdr_u_short,
	86	(caddr_t) & port, tottimeout) != RPC_SUCCESS)
	87	{
	88	rpc_createerr.cf_stat = RPC_PMAPFAILURE;
	89	clnt_geterr (client, &rpc_createerr.cf_error);
	90	}
650425ce	91	else
3996f34b	92	{
650425ce UD	93	if (port == 0)
650425ce UD	94	rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
3996f34b UD	95	}
	96	CLNT_DESTROY (client);
	97	}
	98	/* (void)close(socket); CLNT_DESTROY already closed it */
	99	address->sin_port = 0;
	100	return port;
	101	}
	102
650425ce	103	/* This is now the public function, which should find the fastest server */
3996f34b UD	104
	105	struct findserv_req
	106	{
	107	struct sockaddr_in sin;
55c14926	108	u_int32_t xid;
3996f34b UD	109	u_int server_nr;
	110	u_int server_ep;
	111	};
	112
	113	long
e852e889	114	__nis_findfastest (dir_binding *bind)
3996f34b	115	{
e852e889 UD	116	#if 0
	117	unsigned long i, j;
	118
	119	for (i = 0; i < bind->server_len; i++)
	120	for (j = 0; j < bind->server_val[i].ep.ep_len; ++j)
	121	if (strcmp (bind->server_val[i].ep.ep_val[j].family, "inet") == 0)
	122	if ((bind->server_val[i].ep.ep_val[j].proto == NULL) \|\|
	123	(bind->server_val[i].ep.ep_val[j].proto[0] == '-') \|\|
	124	(bind->server_val[i].ep.ep_val[j].proto[0] == '\0'))
	125	{
	126	bind->server_used = i;
	127	bind->current_ep = j;
	128	return 1;
	129	}
	130
	131	return 0;
	132	#else
650425ce UD	133	const struct timeval TIMEOUT50 = {5, 0};
650425ce UD	134	const struct timeval TIMEOUT00 = {0, 0};
54eb84d0	135	struct findserv_req *pings;
650425ce	136	struct sockaddr_in sin, saved_sin;
3996f34b	137	int found = -1;
650425ce	138	u_int32_t xid_seed, xid_lookup;
3996f34b UD	139	int sock, dontblock = 1;
3996f34b UD	140	CLIENT *clnt;
650425ce	141	char clnt_res;
3996f34b UD	142	void *foo = NULL;
	143	u_long i, j, pings_count, pings_max;
	144	struct cu_data *cu;
	145
	146	pings_max = bind->server_len * 2; /* Reserve a little bit more memory
	147	for multihomed hosts */
	148	pings_count = 0;
54eb84d0	149	pings = malloc (sizeof (struct findserv_req) * pings_max);
650425ce	150	xid_seed = (u_int32_t) (time (NULL) ^ getpid ());
3996f34b	151
54eb84d0 UD	152	if (__builtin_expect (pings == NULL, 0))
	153	return -1;
	154
3996f34b UD	155	memset (&sin, '\0', sizeof (sin));
	156	sin.sin_family = AF_INET;
	157	for (i = 0; i < bind->server_len; i++)
	158	for (j = 0; j < bind->server_val[i].ep.ep_len; ++j)
	159	if (strcmp (bind->server_val[i].ep.ep_val[j].family, "inet") == 0)
650425ce	160	if ((bind->server_val[i].ep.ep_val[j].proto == NULL) \|\|
e852e889	161	(bind->server_val[i].ep.ep_val[j].proto[0] == '-') \|\|
a53bad16	162	(bind->server_val[i].ep.ep_val[j].proto[0] == '\0'))
3996f34b UD	163	{
	164	sin.sin_addr.s_addr =
	165	inetstr2int (bind->server_val[i].ep.ep_val[j].uaddr);
	166	if (sin.sin_addr.s_addr == 0)
	167	continue;
26a60f90 UD	168	sin.sin_port = htons (__pmap_getnisport (&sin, NIS_PROG,
	169	NIS_VERSION,
	170	IPPROTO_UDP));
3996f34b UD	171	if (sin.sin_port == 0)
	172	continue;
	173
	174	if (pings_count >= pings_max)
	175	{
54eb84d0 UD	176	struct findserv_req *new_pings;
54eb84d0 UD	177
3996f34b	178	pings_max += 10;
54eb84d0 UD	179	new_pings = realloc (pings, sizeof (struct findserv_req) *
	180	pings_max);
	181	if (__builtin_expect (new_pings == NULL, 0))
	182	{
	183	free (pings);
	184	return -1;
	185	}
	186	pings = new_pings;
3996f34b	187	}
54eb84d0	188	memcpy ((char ) &pings[pings_count].sin, (char ) &sin,
3996f34b	189	sizeof (sin));
650425ce	190	memcpy ((char )&saved_sin, (char )&sin, sizeof(sin));
54eb84d0 UD	191	pings[pings_count].xid = xid_seed;
	192	pings[pings_count].server_nr = i;
	193	pings[pings_count].server_ep = j;
3996f34b UD	194	++xid_seed;
	195	++pings_count;
	196	}
	197
	198	/* Make sure at least one server was assigned */
	199	if (pings_count == 0)
	200	{
	201	free (pings);
	202	return -1;
	203	}
	204
	205	/* Create RPC handle */
	206	sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
650425ce	207	clnt = clntudp_create (&saved_sin, NIS_PROG, NIS_VERSION, TIMEOUT50, &sock);
3996f34b UD	208	if (clnt == NULL)
	209	{
	210	close (sock);
3996f34b UD	211	free (pings);
	212	return -1;
	213	}
26a60f90	214	auth_destroy (clnt->cl_auth);
3996f34b UD	215	clnt->cl_auth = authunix_create_default ();
3996f34b UD	216	cu = (struct cu_data *) clnt->cl_private;
650425ce	217	clnt_control (clnt, CLSET_TIMEOUT, (char *) &TIMEOUT00);
3996f34b UD	218	ioctl (sock, FIONBIO, &dontblock);
	219
	220	/* Send to all servers the NULLPROC */
	221	for (i = 0; i < pings_count; ++i)
	222	{
	223	/* clntudp_call() will increment, subtract one */
54eb84d0 UD	224	((u_int32_t ) (cu->cu_outbuf)) = pings[i].xid - 1;
54eb84d0 UD	225	memcpy ((char ) &cu->cu_raddr, (char ) &pings[i].sin,
650425ce UD	226	sizeof (struct sockaddr_in));
	227	/* Transmit to NULLPROC, return immediately. */
	228	clnt_call (clnt, NULLPROC, (xdrproc_t) xdr_void, (caddr_t) foo,
	229	(xdrproc_t) xdr_void, (caddr_t) & clnt_res, TIMEOUT00);
3996f34b UD	230	}
3996f34b UD	231
650425ce UD	232	/* Receive reply from NULLPROC asynchronously */
	233	memset ((char *) &clnt_res, 0, sizeof (clnt_res));
	234	clnt_call (clnt, NULLPROC, (xdrproc_t) NULL, (caddr_t) foo,
	235	(xdrproc_t) xdr_void, (caddr_t) &clnt_res, TIMEOUT00);
3996f34b UD	236
	237	xid_lookup = ((u_int32_t ) (cu->cu_inbuf));
	238	for (i = 0; i < pings_count; i++)
	239	{
54eb84d0	240	if (pings[i].xid == xid_lookup)
3996f34b	241	{
54eb84d0 UD	242	bind->server_used = pings[i].server_nr;
54eb84d0 UD	243	bind->current_ep = pings[i].server_ep;
3996f34b UD	244	found = 1;
	245	}
	246	}
	247
	248	auth_destroy (clnt->cl_auth);
	249	clnt_destroy (clnt);
	250	close (sock);
	251
3996f34b UD	252	free (pings);
	253
	254	return found;
e852e889	255	#endif
3996f34b	256	}