AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-22 19:00:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update.

Browse Source 
* login/utmp_daemon.c: Removed.
	* login/getutent_r.c: Remove references to daemon functions.
	* login/utmp-private.h (__libc_utmp_daemon_functions): Remove
	declaration.
This commit is contained in:
Ulrich Drepper 2000-04-18 18:48:05 +00:00
parent 74f998221d
commit 33c50f1061
4 changed files with 8 additions and 479 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ChangeLog
View File

@ -8,6 +8,10 @@
* login/programs/xtmp.h: Removed.
* login/Makefile: Remove rules for utmpd.
* login/README.utmpd: Removed.
* login/utmp_daemon.c: Removed.
* login/getutent_r.c: Remove references to daemon functions.
* login/utmp-private.h (__libc_utmp_daemon_functions): Remove
declaration.
2000-04-18 Andreas Jaeger <aj@suse.de>

13
login/getutent_r.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
/* Copyright (C) 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>
and Paul Janzen <pcj@primenet.com>, 1996.
@ -58,16 +58,9 @@ setutent_unknown (void)
{
int result;
/* See whether utmpd is running. */
result = (*__libc_utmp_daemon_functions.setutent) ();
result = (*__libc_utmp_file_functions.setutent) ();
if (result)
__libc_utmp_jump_table = &__libc_utmp_daemon_functions;
else
{
result = (*__libc_utmp_file_functions.setutent) ();
if (result)
__libc_utmp_jump_table = &__libc_utmp_file_functions;
}
__libc_utmp_jump_table = &__libc_utmp_file_functions;
return result;
}

3
login/utmp-private.h
View File

@ -1,5 +1,5 @@
/* Internal definitions and declarations for UTMP functions.
Copyright (C) 1996 Free Software Foundation, Inc.
Copyright (C) 1996, 2000 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>
and Paul Janzen <pcj@primenet.com>, 1996.
@ -38,7 +38,6 @@ struct utfuncs
/* The tables from the services. */
extern struct utfuncs __libc_utmp_file_functions;
extern struct utfuncs __libc_utmp_daemon_functions;
extern struct utfuncs __libc_utmp_unknown_functions;
/* Currently selected backend. */

467
login/utmp_daemon.c
View File

@ -1,467 +0,0 @@
/* Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Mark Kettenis <kettenis@phys.uva.nl>, 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 <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <utmp.h>
#include "utmp-private.h"
#include "programs/utmpd.h"
/* Descriptor for the socket. */
static int daemon_sock = -1;
/* Functions defined here. */
static int setutent_daemon (void);
static int getutent_r_daemon (struct utmp *buffer, struct utmp **result);
static int getutid_r_daemon (const struct utmp *line, struct utmp *buffer,
struct utmp **result);
static int getutline_r_daemon (const struct utmp *id, struct utmp *buffer,
struct utmp **result);
static struct utmp *pututline_daemon (const struct utmp *utmp);
static void endutent_daemon (void);
static int updwtmp_daemon (const char *file, const struct utmp *utmp);
/* Jump table for daemon functions. */
struct utfuncs __libc_utmp_daemon_functions =
{
setutent_daemon,
getutent_r_daemon,
getutid_r_daemon,
getutline_r_daemon,
pututline_daemon,
endutent_daemon,
updwtmp_daemon
};
static int do_setutent (int sock);
static int do_getutent (int sock, struct utmp *buffer);
static int do_getutid (int sock, const struct utmp *id,
struct utmp *buffer);
static int do_pututline (int sock, const struct utmp *utmp);
static int do_getutline (int sock, const struct utmp *line,
struct utmp *buffer);
static int do_pututline (int sock, const struct utmp *utmp);
static int do_endutent (int sock);
static int do_updwtmp (int sock, const char *file,
const struct utmp *utmp);
static int open_socket (const char *name);
static int send_request (int sock, const request_header *request,
reply_header *reply);
static int
setutent_daemon (void)
{
if (__access (_PATH_UTMPD_RW, F_OK) == -1
&& __access (_PATH_UTMPD_RO, F_OK) == -1)
return 0;
if (daemon_sock < 0)
{
int result;
daemon_sock = open_socket (_PATH_UTMPD_RW);
if (daemon_sock < 0)
{
/* Hhm, read-write access did not work. Try read-only. */
daemon_sock = open_socket (_PATH_UTMPD_RO);
if (daemon_sock < 0)
return 0;
}
/* We have to make sure the socket is `closed on exec'. */
result = __fcntl (daemon_sock, F_GETFD, 0);
if (result >= 0)
result = __fcntl (daemon_sock, F_SETFD, result | FD_CLOEXEC);
if (result == -1)
{
close (daemon_sock);
return 0;
}
}
/* Send request to the daemon. */
if (do_setutent (daemon_sock) < 0)
return 0;
return 1;
}
static int
getutent_r_daemon (struct utmp *buffer, struct utmp **result)
{
assert (daemon_sock >= 0);
/* Send request to the daemon. */
if (do_getutent (daemon_sock, buffer) < 0)
{
*result = NULL;
return -1;;
}
*result = buffer;
return 0;
}
static int
getutid_r_daemon (const struct utmp *id, struct utmp *buffer,
struct utmp **result)
{
assert (daemon_sock >= 0);
/* Send request to the daemon. */
if (do_getutid (daemon_sock, id, buffer) < 0)
{
*result = NULL;
return -1;
}
*result = buffer;
return 0;
}
static int
getutline_r_daemon (const struct utmp *line, struct utmp *buffer,
struct utmp **result)
{
assert (daemon_sock >= 0);
/* Send request to the daemon. */
if (do_getutline (daemon_sock, line, buffer) < 0)
{
*result = NULL;
return -1;
}
*result = buffer;
return 0;
}
static struct utmp *
pututline_daemon (const struct utmp *utmp)
{
assert (daemon_sock >= 0);
/* Send request to the daemon. */
if (do_pututline (daemon_sock, utmp) < 0)
return NULL;
return (struct utmp *)utmp;
}
static void
endutent_daemon (void)
{
assert (daemon_sock >= 0);
/* Send request to the daemon. */
do_endutent (daemon_sock);
__close (daemon_sock);
daemon_sock = -1;
}
static int
updwtmp_daemon (const char *file, const struct utmp *utmp)
{
int sock;
/* Only try to open for both reading and writing. */
sock = open_socket (_PATH_UTMPD_RW);
if (sock < 0)
return -1;
/* Send request to the daemon. */
if (do_updwtmp (sock, file, utmp) < 0)
{
__close (sock);
return -1;
}
__close (sock);
return 0;
}
static int
do_setutent (int sock)
{
setutent_request *request;
setutent_reply reply;
size_t size;
size_t name_len;
name_len = strlen (__libc_utmp_file_name) + 1;
size = sizeof (setutent_request) + name_len;
request = malloc (size);
if (request == NULL)
return -1;
request->header.version = UTMPD_VERSION;
request->header.size = size;
request->header.type = UTMPD_REQ_SETUTENT;
memcpy (request->file, __libc_utmp_file_name, name_len);
reply.header.version = UTMPD_VERSION;
reply.header.size = sizeof (setutent_reply);
reply.header.type = UTMPD_REQ_SETUTENT;
if (send_request (sock, &request->header, &reply.header) < 0)
{
free (request);
return -1;
}
if (reply.result < 0)
__set_errno (reply.errnum);
free (request);
return reply.result;
}
static int
do_getutent (int sock, struct utmp *buffer)
{
getutent_request request;
getutent_reply reply;
request.header.version = UTMPD_VERSION;
request.header.size = sizeof (getutent_request);
request.header.type = UTMPD_REQ_GETUTENT;
reply.header.version = UTMPD_VERSION;
reply.header.size = sizeof (getutent_reply);
reply.header.type = UTMPD_REQ_GETUTENT;
if (send_request (sock, &request.header, &reply.header) < 0)
return -1;
if (reply.result < 0)
__set_errno (reply.errnum);
else
memcpy (buffer, &reply.entry, sizeof (struct utmp));
return reply.result;
}
static int
do_getutid (int sock, const struct utmp *id, struct utmp *buffer)
{
getutid_request request;
getutid_reply reply;
request.header.version = UTMPD_VERSION;
request.header.size = sizeof (getutid_request);
request.header.type = UTMPD_REQ_GETUTID;
memcpy (&request.id, id, sizeof (struct utmp));
reply.header.version = UTMPD_VERSION;
reply.header.size = sizeof (getutid_reply);
reply.header.type = UTMPD_REQ_GETUTID;
if (send_request (sock, &request.header, &reply.header) < 0)
return -1;
if (reply.result < 0)
__set_errno (reply.errnum);
else
memcpy (buffer, &reply.entry, sizeof (struct utmp));
return reply.result;
}
static int
do_getutline (int sock, const struct utmp *line, struct utmp *buffer)
{
getutline_request request;
getutline_reply reply;
request.header.version = UTMPD_VERSION;
request.header.size = sizeof (getutline_request);
request.header.type = UTMPD_REQ_GETUTLINE;
memcpy (&request.line, line, sizeof (struct utmp));
reply.header.version = UTMPD_VERSION;
reply.header.size = sizeof (getutline_reply);
reply.header.type = UTMPD_REQ_GETUTLINE;
if (send_request (sock, &request.header, &reply.header) < 0)
return -1;
if (reply.result < 0)
__set_errno (reply.errnum);
else
memcpy (buffer, &reply.entry, sizeof (struct utmp));
return reply.result;
}
static int
do_pututline (int sock, const struct utmp *utmp)
{
pututline_request request;
pututline_reply reply;
request.header.version = UTMPD_VERSION;
request.header.size = sizeof (pututline_request);
request.header.type = UTMPD_REQ_PUTUTLINE;
memcpy (&request.utmp, utmp, sizeof (struct utmp));
reply.header.version = UTMPD_VERSION;
reply.header.size = sizeof (pututline_reply);
reply.header.type = UTMPD_REQ_PUTUTLINE;
if (send_request (sock, &request.header, &reply.header) < 0)
return -1;
if (reply.result < 0)
__set_errno (reply.errnum);
return reply.result;
}
static int
do_endutent (int sock)
{
endutent_request request;
endutent_reply reply;
request.header.version = UTMPD_VERSION;
request.header.size = sizeof (endutent_request);
request.header.type = UTMPD_REQ_ENDUTENT;
reply.header.version = UTMPD_VERSION;
reply.header.size = sizeof (endutent_reply);
reply.header.type = UTMPD_REQ_ENDUTENT;
if (send_request (sock, &request.header, &reply.header) < 0)
return -1;
if (reply.result < 0)
__set_errno (reply.errnum);
return reply.result;
}
static int
do_updwtmp (int sock, const char *file, const struct utmp *utmp)
{
updwtmp_request *request;
updwtmp_reply reply;
size_t size;
size_t file_len;
file_len = strlen (file) + 1;
size = sizeof (updwtmp_request) + file_len;
request = malloc (size);
if (request == NULL)
return -1;
request->header.version = UTMPD_VERSION;
request->header.size = size;
request->header.type = UTMPD_REQ_UPDWTMP;
memcpy (&request->utmp, utmp, sizeof (struct utmp));
memcpy (request->file, file, file_len);
reply.header.version = UTMPD_VERSION;
reply.header.size = sizeof (updwtmp_reply);
reply.header.type = UTMPD_REQ_UPDWTMP;
if (send_request (sock, &request->header, &reply.header) < 0)
{
free (request);
return -1;
}
if (reply.result < 0)
__set_errno (reply.errnum);
free (request);
return reply.result;
}
/* Create a socket connected to NAME. */
static int
open_socket (const char *name)
{
struct sockaddr_un addr;
int sock;
sock = __socket (PF_UNIX, SOCK_STREAM, 0);
if (sock < 0)
return -1;
addr.sun_family = AF_UNIX;
strcpy (addr.sun_path, name);
if (__connect (sock, (struct sockaddr *) &addr, sizeof (addr)) < 0)
{
__close (sock);
return -1;
}
return sock;
}
/* Send REQUEST to SOCK, and wait for reply. Returns 0 if successful,
storing the reply in REPLY, and -1 if not. */
static int
send_request (int sock, const request_header *request,
reply_header *reply)
{
reply_header header;
ssize_t nbytes;
nbytes = __write (sock, request, request->size);
if (nbytes != (ssize_t) request->size)
return -1;
nbytes = __read (sock, &header, sizeof (reply_header));
if (nbytes != sizeof (reply_header))
return -1;
if (reply->version != header.version
|| reply->size != header.size
|| reply->type != header.type)
return -1;
nbytes = __read (sock, reply + 1, reply->size - sizeof (reply_header));
if (nbytes != (ssize_t) (reply->size - sizeof (reply_header)))
return -1;
return 0;
}