glibc/nis/nis_callback.c
Ulrich Drepper a53bad166c Update.
1998-06-22 17:02  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/generic/enbl-secure.c: Don't use __libc_uid.
	* sysdeps/unix/sysv/linux/aio_sigqueue.c: Likewise.
	* sysdeps/unix/sysv/linux/sigqueue.c: Likewise.
	* sysdeps/unix/sysv/linux/init-first.c: Don't initialize __libc_uid.

1998-06-02  Gordon Matzigkeit  <gord@profitpress.com>

	* mach/Makefile: Change `mv' invocations to `mv -f'.
	* mach/Machrules: Likewise.

1998-06-22  Andreas Jaeger  <aj@arthur.rhein-neckar.de>

	* config.make.in (old-glibc-headers): Add it.

	* configure.in: Add test for glibc 2.0.x headers.

	* Makefile (headers2_0): New variable - contains so far only
	Linux/Intel glibc 2.0.x headers.
	(remove-old-headers): New rule to remove headers from glibc 2.0.x.
	(install): Depend on remove-old-headers.

1998-06-19  Mark Kettenis  <kettenis@phys.uva.nl>

	* sysdeps/generic/ftruncate.c: Define function as __ftruncate and
	make ftruncate a weak alias.
	* sysdeps/mach/hurd/ftruncate.c: Really define function as
	__ftruncate.
	* sysdeps/mach/hurd/truncate.c: Include <unistd.h>.
	(truncate): Fix function defenition to match prototype.

1998-06-20  Mark Kettenis  <kettenis@phys.uva.nl>

	* manual/terminal.texi: Document ttyname_r, getpt, grantpt,
	unlockpt, ptsname, ptsname_r, openpty and forkpty.

1998-06-22  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/generic/glob.c: Make it possible to include glob.h
	before loading glob.c.
	Reported by Felix von Leitner <leitner@math.fu-berlin.de>.

1998-06-22  Andreas Jaeger  <aj@arthur.rhein-neckar.de>

	* nscd/connections.c: Use poll() instead of select().

1998-06-22 14:08  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/generic/Dist: Fix typo.

1998-06-20  Thorsten Kukuk  <kukuk@vt.uni-paderborn.de>

	* nis/nis_add.c: Avoid unnecessary strlen () calls.
	* nis/nis_addmember.c: Likewise.
	* nis/nis_call.c: Likewise.
	* nis/nis_creategroup.c: Likewise.
	* nis/nis_destroygroup.c: Likewise.
	* nis/nis_findserv.c: Likewise.
	* nis/nis_ismember.c: Likewise.
	* nis/nis_print.c: Likewise.
	* nis/nis_print_group_entry.c: Likewise.
	* nis/nis_removemember.c: Likewise.
	* nis/nis_verifygroup.c: Likewise.
	* nis/ypclnt.c: Likewise.

	* nis/nis_file.c: Close file handles.

	* nis/nis_callback.c: Fix typo.
1998-06-22 17:08:51 +00:00

373 lines
9.4 KiB
C

/* Copyright (C) 1997, 1998 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 Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <rpc/rpc.h>
#include <rpc/pmap_clnt.h>
#include <string.h>
#include <memory.h>
#include <syslog.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 <bits/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;
u_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:
{
u_long 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)
{
/* Default timeout can be changed using clnt_control() */
static struct timeval TIMEOUT = {25, 0};
#ifdef FD_SETSIZE
fd_set readfds;
#else
int readfds;
#endif /* def FD_SETSIZE */
struct timeval tv;
bool_t cb_is_running = FALSE;
data = cb;
for (;;)
{
#ifdef FD_SETSIZE
readfds = svc_fdset;
#else
readfds = svc_fds;
#endif /* def FD_SETSIZE */
tv.tv_sec = 25;
tv.tv_usec = 0;
switch (select (_rpc_dtablesize (), &readfds, NULL, NULL, &tv))
{
case -1:
if (errno == EINTR)
continue;
return NIS_CBERROR;
case 0:
/* See if callback 'thread' in the server is still alive. */
memset ((char *) &cb_is_running, 0, sizeof (cb_is_running));
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_getreqset (&readfds);
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, u_long flags)
{
struct nis_cb *cb;
int sock = RPC_ANYSOCK;
struct sockaddr_in sin;
int len = sizeof (struct sockaddr_in);
char addr[NIS_MAXNAMELEN + 1];
unsigned short port;
cb = (struct nis_cb *) calloc (1, sizeof (struct nis_cb));
if (cb == NULL)
{
syslog (LOG_ERR, "NIS+: out of memory allocating callback");
return NULL;
}
cb->serv = (nis_server *) calloc (1, sizeof (nis_server));
if (cb->serv == NULL)
{
free (cb);
syslog (LOG_ERR, "NIS+: out of memory allocating callback");
return NULL;
}
cb->serv->name = strdup (nis_local_principal ());
cb->serv->ep.ep_val = (endpoint *) calloc (2, sizeof (endpoint));
cb->serv->ep.ep_len = 1;
cb->serv->ep.ep_val[0].family = strdup ("inet");
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
}
if (flags & USE_DGRAM)
{
cb->serv->ep.ep_val[0].proto = strdup ("udp");
cb->xprt = svcudp_bufcreate (sock, 100, 8192);
}
else
{
cb->serv->ep.ep_val[0].proto = strdup ("tcp");
cb->xprt = svctcp_create (sock, 100, 8192);
}
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->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->serv);
free (cb);
syslog (LOG_ERR, "NIS+: failed to read local socket info");
return NULL;
}
port = sin.sin_port;
get_myaddress (&sin);
snprintf (addr, sizeof (addr), "%s.%d.%d", inet_ntoa (sin.sin_addr),
port & 0x00FF, (port & 0xFF00) >> 8);
cb->serv->ep.ep_val[0].uaddr = strdup (addr);
return cb;
}
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->serv);
free (cb);
return NIS_SUCCESS;
}