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

/* Copyright (C) 1997-2022 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   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, see
   <https://www.gnu.org/licenses/>.  */

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <libintl.h>
#include <rpc/rpc.h>
#include <rpc/pmap_clnt.h>
#include <string.h>
#include <memory.h>
#include <syslog.h>
#include <sys/poll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <rpc/key_prot.h>
#include <rpcsvc/nis.h>
#include <rpcsvc/nis_callback.h>
#include <libc-lock.h>

#include "nis_xdr.h"
#include "nis_intern.h"

/* Sorry, we are not able to make this threadsafe. Stupid. But some
   functions doesn't send us a nis_result obj, so we don't have a
   cookie. Maybe we could use keys for threads ? Have to learn more
   about pthreads -- kukuk@vt.uni-paderborn.de */

static nis_cb *data;

__libc_lock_define_initialized (static, callback)


#if 0
static char *
__nis_getpkey(const char *sname)
{
  char buf[(strlen (sname) + 1) * 2 + 40];
  char pkey[HEXKEYBYTES + 1];
  char *cp, *domain;
  nis_result *res;
  unsigned int len = 0;

  domain = strchr (sname, '.');
  if (domain == NULL)
    return NULL;

  /* Remove prefixing dot */
  ++domain;

  cp = stpcpy (buf, "[cname=");
  cp = stpcpy (cp, sname);
  cp = stpcpy (cp, ",auth_type=DES],cred.org_dir.");
  cp = stpcpy (cp, domain);

  res = nis_list (buf, USE_DGRAM|NO_AUTHINFO|FOLLOW_LINKS|FOLLOW_PATH,
		  NULL, NULL);

  if (res == NULL)
    return NULL;

  if (NIS_RES_STATUS (res) != NIS_SUCCESS)
    {
      nis_freeresult (res);
      return NULL;
    }

  len = ENTRY_LEN(NIS_RES_OBJECT(res), 3);
  strncpy (pkey, ENTRY_VAL(NIS_RES_OBJECT(res), 3), len);
  pkey[len] = '\0';
  cp = strchr (pkey, ':');
  if (cp != NULL)
    *cp = '\0';

  nis_freeresult (res);

  return strdup (pkey);
}
#endif

static void
cb_prog_1 (struct svc_req *rqstp, SVCXPRT *transp)
{
  union
    {
      cback_data cbproc_receive_1_arg;
      nis_error cbproc_error_1_arg;
    }
  argument;
  char *result;
  xdrproc_t xdr_argument, xdr_result;
  bool_t bool_result;

  switch (rqstp->rq_proc)
    {
    case NULLPROC:
      svc_sendreply (transp, (xdrproc_t) xdr_void, (char *) NULL);
      return;

    case CBPROC_RECEIVE:
      {
	unsigned int i;

	xdr_argument = (xdrproc_t) xdr_cback_data;
	xdr_result = (xdrproc_t) xdr_bool;
	memset (&argument, 0, sizeof (argument));
	if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
	  {
	    svcerr_decode (transp);
	    return;
	  }
	bool_result = FALSE;
	for (i = 0; i < argument.cbproc_receive_1_arg.entries.entries_len; ++i)
	  {
#define cbproc_entry(a) argument.cbproc_receive_1_arg.entries.entries_val[a]
	    char name[strlen (cbproc_entry(i)->zo_name)
		      + strlen (cbproc_entry(i)->zo_domain) + 3];
	    char *cp;

	    cp = stpcpy (name, cbproc_entry(i)->zo_name);
	    *cp++ = '.';
	    cp = stpcpy (cp, cbproc_entry(i)->zo_domain);

	    if ((data->callback) (name, cbproc_entry(i), data->userdata))
	      {
		bool_result = TRUE;
		data->nomore = 1;
		data->result = NIS_SUCCESS;
		break;
	      }
	  }
	result = (char *) &bool_result;
      }
      break;
    case CBPROC_FINISH:
      xdr_argument = (xdrproc_t) xdr_void;
      xdr_result = (xdrproc_t) xdr_void;
      memset (&argument, 0, sizeof (argument));
      if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
	{
	  svcerr_decode (transp);
	  return;
	}
      data->nomore = 1;
      data->result = NIS_SUCCESS;
      bool_result = TRUE;	/* to make gcc happy, not necessary */
      result = (char *) &bool_result;
      break;
    case CBPROC_ERROR:
      xdr_argument = (xdrproc_t) _xdr_nis_error;
      xdr_result = (xdrproc_t) xdr_void;
      memset (&argument, 0, sizeof (argument));
      if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
	{
	  svcerr_decode (transp);
	  return;
	}
      data->nomore = 1;
      data->result = argument.cbproc_error_1_arg;
      bool_result = TRUE;	/* to make gcc happy, not necessary */
      result = (char *) &bool_result;
      break;
    default:
      svcerr_noproc (transp);
      return;
    }
  if (result != NULL && !svc_sendreply (transp, xdr_result, result))
    svcerr_systemerr (transp);
  if (!svc_freeargs (transp, xdr_argument, (caddr_t) & argument))
    {
      fputs (_ ("unable to free arguments"), stderr);
      exit (1);
    }
  return;
}

static nis_error
internal_nis_do_callback (struct dir_binding *bptr, netobj *cookie,
			  struct nis_cb *cb)
{
  struct timeval TIMEOUT = {25, 0};
  bool_t cb_is_running;

  data = cb;

  for (;;)
    {
      struct pollfd my_pollfd[svc_max_pollfd];
      int i;

      if (svc_max_pollfd == 0 && svc_pollfd == NULL)
        return NIS_CBERROR;

      for (i = 0; i < svc_max_pollfd; ++i)
        {
          my_pollfd[i].fd = svc_pollfd[i].fd;
          my_pollfd[i].events = svc_pollfd[i].events;
          my_pollfd[i].revents = 0;
        }

      switch (i = TEMP_FAILURE_RETRY (__poll (my_pollfd, svc_max_pollfd,
					      25*1000)))
        {
	case -1:
	  return NIS_CBERROR;
	case 0:
	  /* See if callback 'thread' in the server is still alive. */
	  cb_is_running = FALSE;
	  if (clnt_call (bptr->clnt, NIS_CALLBACK, (xdrproc_t) xdr_netobj,
			 (caddr_t) cookie, (xdrproc_t) xdr_bool,
			 (caddr_t) &cb_is_running, TIMEOUT) != RPC_SUCCESS)
	    cb_is_running = FALSE;

	  if (cb_is_running == FALSE)
	    {
	      syslog (LOG_ERR, "NIS+: callback timed out");
	      return NIS_CBERROR;
	    }
	  break;
	default:
	  svc_getreq_poll (my_pollfd, i);
	  if (data->nomore)
	    return data->result;
	}
    }
}

nis_error
__nis_do_callback (struct dir_binding *bptr, netobj *cookie,
		   struct nis_cb *cb)
{
  nis_error result;

  __libc_lock_lock (callback);

  result = internal_nis_do_callback (bptr, cookie, cb);

  __libc_lock_unlock (callback);

  return result;
}

struct nis_cb *
__nis_create_callback (int (*callback) (const_nis_name, const nis_object *,
					const void *),
		       const void *userdata, unsigned int flags)
{
  struct nis_cb *cb;
  int sock = RPC_ANYSOCK;
  struct sockaddr_in sin;
  socklen_t len = sizeof (struct sockaddr_in);
  unsigned short port;
  int nomsg = 0;

  cb = (struct nis_cb *) calloc (1,
				 sizeof (struct nis_cb) + sizeof (nis_server));
  if (__glibc_unlikely (cb == NULL))
    goto failed;
  cb->serv = (nis_server *) (cb + 1);
  cb->serv->name = strdup (nis_local_principal ());
  if (__glibc_unlikely (cb->serv->name == NULL))
    goto failed;
  cb->serv->ep.ep_val = (endpoint *) calloc (2, sizeof (endpoint));
  if (__glibc_unlikely (cb->serv->ep.ep_val == NULL))
    goto failed;
  cb->serv->ep.ep_len = 1;
  cb->serv->ep.ep_val[0].family = strdup ("inet");
  if (__glibc_unlikely (cb->serv->ep.ep_val[0].family == NULL))
    goto failed;
  cb->callback = callback;
  cb->userdata = userdata;

  if ((flags & NO_AUTHINFO) || !key_secretkey_is_set ())
    {
      cb->serv->key_type = NIS_PK_NONE;
      cb->serv->pkey.n_bytes = NULL;
      cb->serv->pkey.n_len = 0;
    }
  else
    {
#if 0
      if ((cb->serv->pkey.n_bytes = __nis_getpkey (cb->serv->name)) == NULL)
	{
	  cb->serv->pkey.n_len = 0;
	  cb->serv->key_type = NIS_PK_NONE;
	}
      else
	{
	  cb->serv->key_type = NIS_PK_DH;
	  cb->serv->pkey.n_len = strlen(cb->serv->pkey.n_bytes);
	}
#else
      cb->serv->pkey.n_len =0;
      cb->serv->pkey.n_bytes = NULL;
      cb->serv->key_type = NIS_PK_NONE;
#endif
    }

  cb->serv->ep.ep_val[0].proto = strdup ((flags & USE_DGRAM) ? "udp" : "tcp");
  if (__glibc_unlikely (cb->serv->ep.ep_val[0].proto == NULL))
    goto failed;
  cb->xprt = ((flags & USE_DGRAM)
	      ? svcudp_bufcreate (sock, 100, 8192)
	      : svctcp_create (sock, 100, 8192));
  if (cb->xprt == NULL)
    {
      nomsg = 1;
      goto failed;
    }
  cb->sock = cb->xprt->xp_sock;
  if (!svc_register (cb->xprt, CB_PROG, CB_VERS, cb_prog_1, 0))
    {
      xprt_unregister (cb->xprt);
      svc_destroy (cb->xprt);
      xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
      free (cb);
      syslog (LOG_ERR, "NIS+: failed to register callback dispatcher");
      return NULL;
    }

  if (getsockname (cb->sock, (struct sockaddr *) &sin, &len) == -1)
    {
      xprt_unregister (cb->xprt);
      svc_destroy (cb->xprt);
      xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
      free (cb);
      syslog (LOG_ERR, "NIS+: failed to read local socket info");
      return NULL;
    }
  port = ntohs (sin.sin_port);
  get_myaddress (&sin);

  if (asprintf (&cb->serv->ep.ep_val[0].uaddr, "%s.%d.%d",
		inet_ntoa (sin.sin_addr), (port & 0xFF00) >> 8, port & 0x00FF)
      < 0)
    goto failed;

  return cb;

 failed:
  if (cb)
    {
      if (cb->xprt)
	svc_destroy (cb->xprt);
      xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
      free (cb);
    }
  if (!nomsg)
    syslog (LOG_ERR, "NIS+: out of memory allocating callback");
  return NULL;
}

nis_error
__nis_destroy_callback (struct nis_cb *cb)
{
  xprt_unregister (cb->xprt);
  svc_destroy (cb->xprt);
  close (cb->sock);
  xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
  free (cb);

  return NIS_SUCCESS;
}
Commit	Line	Data
581c785b	1	/* Copyright (C) 1997-2022 Free Software Foundation, Inc.
650425ce	2	This file is part of the GNU C Library.
650425ce UD	3
650425ce UD	4	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	5	modify it under the terms of the GNU Lesser General Public
	6	License as published by the Free Software Foundation; either
	7	version 2.1 of the License, or (at your option) any later version.
650425ce UD	8
	9	The GNU C Library is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	12	Lesser General Public License for more details.
650425ce	13
41bdb6e2	14	You should have received a copy of the GNU Lesser General Public
59ba27a6	15	License along with the GNU C Library; if not, see
5a82c748	16	<https://www.gnu.org/licenses/>. */
650425ce UD	17
	18	#include <errno.h>
	19	#include <stdio.h>
	20	#include <stdlib.h>
	21	#include <unistd.h>
4360eafd	22	#include <libintl.h>
cc3fa755	23	#include <rpc/rpc.h>
650425ce UD	24	#include <rpc/pmap_clnt.h>
	25	#include <string.h>
	26	#include <memory.h>
	27	#include <syslog.h>
249fd241	28	#include <sys/poll.h>
650425ce UD	29	#include <sys/socket.h>
	30	#include <netinet/in.h>
	31	#include <arpa/inet.h>
26a60f90	32	#include <rpc/key_prot.h>
650425ce	33	#include <rpcsvc/nis.h>
91eee4dd	34	#include <rpcsvc/nis_callback.h>
ec999b8e	35	#include <libc-lock.h>
650425ce	36
91eee4dd	37	#include "nis_xdr.h"
650425ce UD	38	#include "nis_intern.h"
650425ce UD	39
650425ce UD	40	/* Sorry, we are not able to make this threadsafe. Stupid. But some
	41	functions doesn't send us a nis_result obj, so we don't have a
	42	cookie. Maybe we could use keys for threads ? Have to learn more
	43	about pthreads -- kukuk@vt.uni-paderborn.de */
	44
650425ce UD	45	static nis_cb *data;
	46
	47	__libc_lock_define_initialized (static, callback)
	48
26a60f90	49
91eee4dd	50	#if 0
26a60f90 UD	51	static char *
	52	__nis_getpkey(const char *sname)
	53	{
	54	char buf[(strlen (sname) + 1) * 2 + 40];
	55	char pkey[HEXKEYBYTES + 1];
	56	char cp, domain;
	57	nis_result *res;
a1129917	58	unsigned int len = 0;
26a60f90 UD	59
	60	domain = strchr (sname, '.');
	61	if (domain == NULL)
	62	return NULL;
	63
	64	/* Remove prefixing dot */
	65	++domain;
	66
	67	cp = stpcpy (buf, "[cname=");
	68	cp = stpcpy (cp, sname);
	69	cp = stpcpy (cp, ",auth_type=DES],cred.org_dir.");
	70	cp = stpcpy (cp, domain);
	71
	72	res = nis_list (buf, USE_DGRAM\|NO_AUTHINFO\|FOLLOW_LINKS\|FOLLOW_PATH,
	73	NULL, NULL);
	74
	75	if (res == NULL)
	76	return NULL;
	77
91eee4dd	78	if (NIS_RES_STATUS (res) != NIS_SUCCESS)
26a60f90 UD	79	{
	80	nis_freeresult (res);
	81	return NULL;
	82	}
	83
	84	len = ENTRY_LEN(NIS_RES_OBJECT(res), 3);
	85	strncpy (pkey, ENTRY_VAL(NIS_RES_OBJECT(res), 3), len);
	86	pkey[len] = '\0';
	87	cp = strchr (pkey, ':');
	88	if (cp != NULL)
	89	*cp = '\0';
	90
	91	nis_freeresult (res);
	92
	93	return strdup (pkey);
	94	}
91eee4dd	95	#endif
650425ce UD	96
	97	static void
	98	cb_prog_1 (struct svc_req rqstp, SVCXPRT transp)
	99	{
	100	union
	101	{
	102	cback_data cbproc_receive_1_arg;
	103	nis_error cbproc_error_1_arg;
	104	}
	105	argument;
	106	char *result;
	107	xdrproc_t xdr_argument, xdr_result;
	108	bool_t bool_result;
	109
	110	switch (rqstp->rq_proc)
	111	{
	112	case NULLPROC:
26a60f90	113	svc_sendreply (transp, (xdrproc_t) xdr_void, (char *) NULL);
650425ce UD	114	return;
	115
	116	case CBPROC_RECEIVE:
	117	{
a1129917	118	unsigned int i;
650425ce UD	119
	120	xdr_argument = (xdrproc_t) xdr_cback_data;
	121	xdr_result = (xdrproc_t) xdr_bool;
	122	memset (&argument, 0, sizeof (argument));
	123	if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
	124	{
	125	svcerr_decode (transp);
	126	return;
	127	}
	128	bool_result = FALSE;
	129	for (i = 0; i < argument.cbproc_receive_1_arg.entries.entries_len; ++i)
	130	{
26a60f90	131	#define cbproc_entry(a) argument.cbproc_receive_1_arg.entries.entries_val[a]
34a5a146 JM	132	char name[strlen (cbproc_entry(i)->zo_name)
34a5a146 JM	133	+ strlen (cbproc_entry(i)->zo_domain) + 3];
26a60f90 UD	134	char *cp;
	135
	136	cp = stpcpy (name, cbproc_entry(i)->zo_name);
	137	*cp++ = '.';
	138	cp = stpcpy (cp, cbproc_entry(i)->zo_domain);
650425ce	139
26a60f90	140	if ((data->callback) (name, cbproc_entry(i), data->userdata))
650425ce UD	141	{
	142	bool_result = TRUE;
	143	data->nomore = 1;
	144	data->result = NIS_SUCCESS;
	145	break;
	146	}
	147	}
	148	result = (char *) &bool_result;
	149	}
	150	break;
	151	case CBPROC_FINISH:
	152	xdr_argument = (xdrproc_t) xdr_void;
	153	xdr_result = (xdrproc_t) xdr_void;
	154	memset (&argument, 0, sizeof (argument));
	155	if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
	156	{
	157	svcerr_decode (transp);
	158	return;
	159	}
	160	data->nomore = 1;
	161	data->result = NIS_SUCCESS;
	162	bool_result = TRUE; /* to make gcc happy, not necessary */
	163	result = (char *) &bool_result;
	164	break;
	165	case CBPROC_ERROR:
91eee4dd	166	xdr_argument = (xdrproc_t) _xdr_nis_error;
650425ce UD	167	xdr_result = (xdrproc_t) xdr_void;
	168	memset (&argument, 0, sizeof (argument));
	169	if (!svc_getargs (transp, xdr_argument, (caddr_t) & argument))
	170	{
	171	svcerr_decode (transp);
	172	return;
	173	}
	174	data->nomore = 1;
	175	data->result = argument.cbproc_error_1_arg;
	176	bool_result = TRUE; /* to make gcc happy, not necessary */
	177	result = (char *) &bool_result;
	178	break;
	179	default:
	180	svcerr_noproc (transp);
	181	return;
	182	}
	183	if (result != NULL && !svc_sendreply (transp, xdr_result, result))
	184	svcerr_systemerr (transp);
	185	if (!svc_freeargs (transp, xdr_argument, (caddr_t) & argument))
	186	{
	187	fputs (_ ("unable to free arguments"), stderr);
	188	exit (1);
	189	}
	190	return;
	191	}
	192
650425ce UD	193	static nis_error
	194	internal_nis_do_callback (struct dir_binding bptr, netobj cookie,
	195	struct nis_cb *cb)
	196	{
249fd241	197	struct timeval TIMEOUT = {25, 0};
101cc598	198	bool_t cb_is_running;
650425ce UD	199
	200	data = cb;
	201
	202	for (;;)
	203	{
101cc598	204	struct pollfd my_pollfd[svc_max_pollfd];
249fd241 UD	205	int i;
249fd241 UD	206
6d5728c8	207	if (svc_max_pollfd == 0 && svc_pollfd == NULL)
249fd241 UD	208	return NIS_CBERROR;
249fd241 UD	209
249fd241 UD	210	for (i = 0; i < svc_max_pollfd; ++i)
	211	{
	212	my_pollfd[i].fd = svc_pollfd[i].fd;
	213	my_pollfd[i].events = svc_pollfd[i].events;
	214	my_pollfd[i].revents = 0;
	215	}
	216
101cc598 UD	217	switch (i = TEMP_FAILURE_RETRY (__poll (my_pollfd, svc_max_pollfd,
101cc598 UD	218	25*1000)))
249fd241	219	{
650425ce	220	case -1:
650425ce UD	221	return NIS_CBERROR;
	222	case 0:
	223	/* See if callback 'thread' in the server is still alive. */
101cc598	224	cb_is_running = FALSE;
650425ce UD	225	if (clnt_call (bptr->clnt, NIS_CALLBACK, (xdrproc_t) xdr_netobj,
650425ce UD	226	(caddr_t) cookie, (xdrproc_t) xdr_bool,
101cc598	227	(caddr_t) &cb_is_running, TIMEOUT) != RPC_SUCCESS)
650425ce UD	228	cb_is_running = FALSE;
	229
	230	if (cb_is_running == FALSE)
	231	{
	232	syslog (LOG_ERR, "NIS+: callback timed out");
	233	return NIS_CBERROR;
	234	}
	235	break;
	236	default:
249fd241	237	svc_getreq_poll (my_pollfd, i);
650425ce UD	238	if (data->nomore)
	239	return data->result;
	240	}
	241	}
	242	}
	243
	244	nis_error
	245	__nis_do_callback (struct dir_binding bptr, netobj cookie,
	246	struct nis_cb *cb)
	247	{
	248	nis_error result;
	249
	250	__libc_lock_lock (callback);
	251
	252	result = internal_nis_do_callback (bptr, cookie, cb);
	253
	254	__libc_lock_unlock (callback);
	255
	256	return result;
	257	}
	258
	259	struct nis_cb *
	260	__nis_create_callback (int (callback) (const_nis_name, const nis_object ,
	261	const void *),
a1129917	262	const void *userdata, unsigned int flags)
650425ce UD	263	{
	264	struct nis_cb *cb;
	265	int sock = RPC_ANYSOCK;
	266	struct sockaddr_in sin;
9cfe5381	267	socklen_t len = sizeof (struct sockaddr_in);
650425ce	268	unsigned short port;
882bfe73	269	int nomsg = 0;
650425ce	270
f90de831 UD	271	cb = (struct nis_cb *) calloc (1,
f90de831 UD	272	sizeof (struct nis_cb) + sizeof (nis_server));
a1ffb40e	273	if (__glibc_unlikely (cb == NULL))
316518d6	274	goto failed;
f90de831	275	cb->serv = (nis_server *) (cb + 1);
26a60f90	276	cb->serv->name = strdup (nis_local_principal ());
a1ffb40e	277	if (__glibc_unlikely (cb->serv->name == NULL))
316518d6	278	goto failed;
650425ce	279	cb->serv->ep.ep_val = (endpoint *) calloc (2, sizeof (endpoint));
a1ffb40e	280	if (__glibc_unlikely (cb->serv->ep.ep_val == NULL))
316518d6	281	goto failed;
650425ce UD	282	cb->serv->ep.ep_len = 1;
650425ce UD	283	cb->serv->ep.ep_val[0].family = strdup ("inet");
a1ffb40e	284	if (__glibc_unlikely (cb->serv->ep.ep_val[0].family == NULL))
316518d6	285	goto failed;
650425ce UD	286	cb->callback = callback;
	287	cb->userdata = userdata;
	288
91eee4dd	289	if ((flags & NO_AUTHINFO) \|\| !key_secretkey_is_set ())
26a60f90 UD	290	{
	291	cb->serv->key_type = NIS_PK_NONE;
	292	cb->serv->pkey.n_bytes = NULL;
	293	cb->serv->pkey.n_len = 0;
	294	}
	295	else
	296	{
91eee4dd	297	#if 0
26a60f90 UD	298	if ((cb->serv->pkey.n_bytes = __nis_getpkey (cb->serv->name)) == NULL)
	299	{
	300	cb->serv->pkey.n_len = 0;
	301	cb->serv->key_type = NIS_PK_NONE;
	302	}
	303	else
	304	{
	305	cb->serv->key_type = NIS_PK_DH;
	306	cb->serv->pkey.n_len = strlen(cb->serv->pkey.n_bytes);
	307	}
91eee4dd UD	308	#else
	309	cb->serv->pkey.n_len =0;
	310	cb->serv->pkey.n_bytes = NULL;
a53bad16	311	cb->serv->key_type = NIS_PK_NONE;
91eee4dd	312	#endif
26a60f90	313	}
650425ce	314
316518d6	315	cb->serv->ep.ep_val[0].proto = strdup ((flags & USE_DGRAM) ? "udp" : "tcp");
a1ffb40e	316	if (__glibc_unlikely (cb->serv->ep.ep_val[0].proto == NULL))
316518d6	317	goto failed;
882bfe73 UD	318	cb->xprt = ((flags & USE_DGRAM)
	319	? svcudp_bufcreate (sock, 100, 8192)
	320	: svctcp_create (sock, 100, 8192));
	321	if (cb->xprt == NULL)
	322	{
	323	nomsg = 1;
	324	goto failed;
	325	}
650425ce UD	326	cb->sock = cb->xprt->xp_sock;
	327	if (!svc_register (cb->xprt, CB_PROG, CB_VERS, cb_prog_1, 0))
	328	{
	329	xprt_unregister (cb->xprt);
	330	svc_destroy (cb->xprt);
91eee4dd	331	xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
650425ce UD	332	free (cb);
	333	syslog (LOG_ERR, "NIS+: failed to register callback dispatcher");
	334	return NULL;
	335	}
	336
	337	if (getsockname (cb->sock, (struct sockaddr *) &sin, &len) == -1)
	338	{
	339	xprt_unregister (cb->xprt);
	340	svc_destroy (cb->xprt);
91eee4dd	341	xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
650425ce UD	342	free (cb);
650425ce UD	343	syslog (LOG_ERR, "NIS+: failed to read local socket info");
91eee4dd	344	return NULL;
650425ce	345	}
d6f6ffa1	346	port = ntohs (sin.sin_port);
650425ce	347	get_myaddress (&sin);
f90de831 UD	348
	349	if (asprintf (&cb->serv->ep.ep_val[0].uaddr, "%s.%d.%d",
	350	inet_ntoa (sin.sin_addr), (port & 0xFF00) >> 8, port & 0x00FF)
	351	< 0)
	352	goto failed;
650425ce UD	353
650425ce UD	354	return cb;
316518d6 UD	355
	356	failed:
	357	if (cb)
	358	{
882bfe73 UD	359	if (cb->xprt)
882bfe73 UD	360	svc_destroy (cb->xprt);
6bcb494a	361	xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
316518d6 UD	362	free (cb);
316518d6 UD	363	}
882bfe73 UD	364	if (!nomsg)
882bfe73 UD	365	syslog (LOG_ERR, "NIS+: out of memory allocating callback");
316518d6	366	return NULL;
650425ce UD	367	}
	368
	369	nis_error
	370	__nis_destroy_callback (struct nis_cb *cb)
	371	{
	372	xprt_unregister (cb->xprt);
	373	svc_destroy (cb->xprt);
	374	close (cb->sock);
91eee4dd	375	xdr_free ((xdrproc_t) _xdr_nis_server, (char *) cb->serv);
650425ce UD	376	free (cb);
	377
	378	return NIS_SUCCESS;
	379	}