Update.
[kopensolaris-gnu/glibc.git] / login / utmp_daemon.c
1 /* Copyright (C) 1997 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Mark Kettenis <kettenis@phys.uva.nl>, 1997.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
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
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 #include <errno.h>
21 #include <limits.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <sys/socket.h>
25 #include <sys/un.h>
26 #include <unistd.h>
27 #include <utmp.h>
28
29 #include "utmp-private.h"
30 #include "programs/utmpd.h"
31
32
33 /* Descriptor for the socket.  */
34 static int daemon_sock = INT_MIN;
35
36
37 /* Functions defined here.  */
38 static int setutent_daemon (int reset);
39 static int getutent_r_daemon (struct utmp *buffer, struct utmp **result);
40 static int getutid_r_daemon (const struct utmp *line, struct utmp *buffer,
41                              struct utmp **result);
42 static int getutline_r_daemon (const struct utmp *id, struct utmp *buffer,
43                                struct utmp **result);
44 static struct utmp *pututline_daemon (const struct utmp *utmp);
45 static void endutent_daemon (void);
46 static int updwtmp_daemon (const char *file, const struct utmp *utmp);
47
48 /* Jump table for daemon functions.  */
49 struct utfuncs __libc_utmp_daemon_functions =
50 {
51   setutent_daemon,
52   getutent_r_daemon,
53   getutid_r_daemon,
54   getutline_r_daemon,
55   pututline_daemon,
56   endutent_daemon,
57   updwtmp_daemon
58 };
59
60 static int do_setutent (int sock);
61 static int do_getutent (int sock, struct utmp *buffer);
62 static int do_endutent (int sock);
63 static int do_getutline (int sock, const struct utmp *line,
64                          struct utmp *buffer);
65 static int do_getutid (int sock, const struct utmp *id,
66                             struct utmp *buffer);
67 static int do_pututline (int sock, const struct utmp *utmp);
68 static int do_updwtmp (int sock, const char *file,
69                        const struct utmp *utmp);
70
71 static int open_socket (const char *name);
72 static int send_request (int sock, const request_header *request,
73                          reply_header *reply);
74
75
76 static int
77 setutent_daemon (int reset)
78 {
79   if (daemon_sock == INT_MIN)
80     {
81       daemon_sock = open_socket (_PATH_UTMPD_RW);
82       if (daemon_sock < 0)
83         {
84           /* Hhm, read-write access did not work.  Try read-only.  */
85           daemon_sock = open_socket (_PATH_UTMPD_RO);
86           if (daemon_sock < 0)
87             return 0;
88         }
89
90       /* Send request to the daemon.  */
91       if (do_setutent (daemon_sock) < 0)
92         return 0;
93     }
94   else if (reset)
95     {
96       /* Send request to the daemon.  */
97       if (do_setutent (daemon_sock) < 0)
98         return 0;
99     }
100
101   return 1;
102 }
103
104
105 static void
106 endutent_daemon (void)
107 {
108   if (daemon_sock >= 0)
109     {
110       /* Send request to the daemon.  */
111       do_endutent (daemon_sock);
112       close (daemon_sock);
113     }
114
115   daemon_sock = INT_MIN;
116 }
117
118
119 static int
120 getutent_r_daemon (struct utmp *buffer, struct utmp **result)
121 {
122   /* Open connection if not already done.  */
123   if (daemon_sock == INT_MIN)
124     setutent_daemon (1);
125
126   if (daemon_sock < 0)
127     {
128       /* Not available.  */
129       *result = NULL;
130       return -1;
131     }
132
133   /* Send request to the daemon.  */
134   if (do_getutent (daemon_sock, buffer) < 0)
135     {
136       *result = NULL;
137       return -1;;
138     }
139
140   *result = buffer;
141   return 0;
142 }
143
144
145 static int
146 getutline_r_daemon (const struct utmp *line, struct utmp *buffer,
147                     struct utmp **result)
148 {
149   if (daemon_sock < 0)
150     {
151       *result = NULL;
152       return -1;
153     }
154
155   /* Send request to the daemon.  */
156   if (do_getutline (daemon_sock, line, buffer) < 0)
157     {
158       *result = NULL;
159       return -1;;
160     }
161
162   *result = buffer;
163   return 0;
164 }
165
166
167 static int
168 getutid_r_daemon (const struct utmp *id, struct utmp *buffer,
169                   struct utmp **result)
170 {
171   if (daemon_sock < 0)
172     {
173       *result = NULL;
174       return -1;
175     }
176
177   /* Send request to the daemon.  */
178   if (do_getutid (daemon_sock, id, buffer) < 0)
179     {
180       *result = NULL;
181       return -1;
182     }
183
184   *result = buffer;
185   return 0;
186 }
187
188
189 static struct utmp *
190 pututline_daemon (const struct utmp *utmp)
191 {
192   if (daemon_sock == INT_MIN)
193     /* The connection is closed.  Open it again.  */
194     setutent_daemon (0);
195
196   if (daemon_sock < 0)
197     /* Something went wrong.  */
198     return NULL;
199
200   /* Send request to the daemon.  */
201   if (do_pututline (daemon_sock, utmp) < 0)
202     return NULL;
203
204   return (struct utmp *)utmp;
205 }
206
207
208 static int
209 updwtmp_daemon (const char *file, const struct utmp *utmp)
210 {
211   int sock;
212
213   /* Only try to open for both reading and writing.  */
214   sock = open_socket (_PATH_UTMPD_RW);
215   if (sock < 0)
216     return -1;
217
218   /* Send request to the daemon.  */
219   if (do_updwtmp (sock, file, utmp) < 0)
220     return -1;
221
222   close (sock);
223   return 0;
224 }
225
226
227 static int
228 do_setutent (int sock)
229 {
230   setutent_request *request;
231   setutent_reply reply;
232   size_t size;
233
234   size = sizeof (setutent_request) + strlen (__libc_utmp_file_name) + 1;
235   
236   request = malloc (size);
237   if (request == NULL)
238     return -1;
239   
240   request->header.version = UTMPD_VERSION;
241   request->header.size = size;
242   request->header.type = UTMPD_REQ_SETUTENT;
243   strcpy (request->file, __libc_utmp_file_name);
244
245   reply.header.version = UTMPD_VERSION;
246   reply.header.size = sizeof (setutent_reply);
247   reply.header.type = UTMPD_REQ_SETUTENT;
248
249   if (send_request (sock, &request->header, &reply.header) < 0)
250     {
251       free (request);
252       return -1;
253     }
254
255   if (reply.result < 0)
256     __set_errno (reply.errnum);
257
258   free (request);
259   return reply.result;
260 }
261
262 static int
263 do_getutent (int sock, struct utmp *buffer)
264 {
265   getutent_request request;
266   getutent_reply reply;
267
268   request.header.version = UTMPD_VERSION;
269   request.header.size = sizeof (getutent_request);
270   request.header.type = UTMPD_REQ_GETUTENT;
271
272   reply.header.version = UTMPD_VERSION;
273   reply.header.size = sizeof (getutent_reply);
274   reply.header.type = UTMPD_REQ_GETUTENT;
275
276   if (send_request (sock, &request.header, &reply.header) < 0)
277     return -1;
278
279   if (reply.result < 0)
280     __set_errno (reply.errnum);
281   else
282     memcpy (buffer, &reply.entry, sizeof (struct utmp));
283
284   return reply.result;
285 }
286
287 static int
288 do_endutent (int sock)
289 {
290   endutent_request request;
291   endutent_reply reply;
292
293   request.header.version = UTMPD_VERSION;
294   request.header.size = sizeof (endutent_request);
295   request.header.type = UTMPD_REQ_ENDUTENT;
296
297   reply.header.version = UTMPD_VERSION;
298   reply.header.size = sizeof (endutent_reply);
299   reply.header.type = UTMPD_REQ_ENDUTENT;
300
301   if (send_request (sock, &request.header, &reply.header) < 0)
302     return -1;
303
304   if (reply.result < 0)
305     __set_errno (reply.errnum);
306
307   return reply.result;
308 }
309
310 static int
311 do_getutline (int sock, const struct utmp *line, struct utmp *buffer)
312 {
313   getutline_request request;
314   getutline_reply reply;
315
316   request.header.version = UTMPD_VERSION;
317   request.header.size = sizeof (getutline_request);
318   request.header.type = UTMPD_REQ_GETUTLINE;
319   memcpy (&request.line, line, sizeof (struct utmp));
320
321   reply.header.version = UTMPD_VERSION;
322   reply.header.size = sizeof (getutline_reply);
323   reply.header.type = UTMPD_REQ_GETUTLINE;
324
325   if (send_request (sock, &request.header, &reply.header) < 0)
326     return -1;
327
328   if (reply.result < 0)
329     __set_errno (reply.errnum);
330   else
331     memcpy (buffer, &reply.entry, sizeof (struct utmp));
332
333   return reply.result;
334 }
335
336 static int
337 do_getutid (int sock, const struct utmp *id, struct utmp *buffer)
338 {
339   getutid_request request;
340   getutid_reply reply;
341
342   request.header.version = UTMPD_VERSION;
343   request.header.size = sizeof (getutid_request);
344   request.header.type = UTMPD_REQ_GETUTID;
345   memcpy (&request.id, id, sizeof (struct utmp));
346
347   reply.header.version = UTMPD_VERSION;
348   reply.header.size = sizeof (getutid_reply);
349   reply.header.type = UTMPD_REQ_GETUTID;
350
351   if (send_request (sock, &request.header, &reply.header) < 0)
352     return -1;
353
354   if (reply.result < 0)
355     __set_errno (reply.errnum);
356   else
357     memcpy (buffer, &reply.entry, sizeof (struct utmp));
358
359   return reply.result;
360 }
361
362 static int
363 do_pututline (int sock, const struct utmp *utmp)
364 {
365   pututline_request request;
366   pututline_reply reply;
367
368   request.header.version = UTMPD_VERSION;
369   request.header.size = sizeof (pututline_request);
370   request.header.type = UTMPD_REQ_PUTUTLINE;
371   memcpy (&request.utmp, utmp, sizeof (struct utmp));
372
373   reply.header.version = UTMPD_VERSION;
374   reply.header.size = sizeof (pututline_reply);
375   reply.header.type = UTMPD_REQ_PUTUTLINE;
376
377   if (send_request (sock, &request.header, &reply.header) < 0)
378     return -1;
379
380   if (reply.result < 0)
381     __set_errno (reply.errnum);
382
383   return reply.result;
384 }
385
386 static int
387 do_updwtmp (int sock, const char *file, const struct utmp *utmp)
388 {
389   updwtmp_request *request;
390   updwtmp_reply reply;
391   size_t size;
392
393   size = sizeof (updwtmp_request) + strlen (file) + 1;
394   
395   request = malloc (size);
396   if (request == NULL)
397     return -1;
398   
399   request->header.version = UTMPD_VERSION;
400   request->header.size = size;
401   request->header.type = UTMPD_REQ_UPDWTMP;
402   memcpy (&request->utmp, utmp, sizeof (struct utmp));
403   strcpy (request->file, file);
404
405   reply.header.version = UTMPD_VERSION;
406   reply.header.size = sizeof (updwtmp_reply);
407   reply.header.type = UTMPD_REQ_UPDWTMP;
408
409   if (send_request (sock, &request->header, &reply.header) < 0)
410     {
411       free (request);
412       return -1;
413     }
414
415   if (reply.result < 0)
416     __set_errno (reply.errnum);
417
418   free (request);
419   return reply.result;
420 }
421
422
423 /* Create a socket connected to NAME.  */
424 static int
425 open_socket (const char *name)
426 {
427   struct sockaddr_un addr;
428   int sock;
429
430   sock = socket (PF_UNIX, SOCK_STREAM, 0);
431   if (sock < 0)
432     return -1;
433
434   addr.sun_family = AF_UNIX;
435   strcpy (addr.sun_path, name);
436   if (connect (sock, (struct sockaddr *) &addr, sizeof (addr)) < 0)
437     {
438       close (sock);
439       return -1;
440     }
441
442   return sock;
443 }
444
445 /* Send REQUEST to SOCK, and wait for reply.  Returns 0 if successful,
446    storing the reply in REPLY, and -1 if not.  */
447 static int
448 send_request (int sock, const request_header *request,
449               reply_header *reply)
450 {
451   reply_header header;
452   ssize_t nbytes;
453
454   nbytes = write (sock, request, request->size);
455   if (nbytes != (ssize_t) request->size)
456     return -1;
457
458   nbytes = read (sock, &header, sizeof (reply_header));
459   if (nbytes != sizeof (reply_header))
460     return -1;
461
462   if (reply->version != header.version
463       || reply->size != header.size
464       || reply->type != header.type)
465     return -1;
466
467   nbytes = read (sock, reply + 1, reply->size - sizeof (reply_header));
468   if (nbytes != (ssize_t) (reply->size - sizeof (reply_header)))
469     return -1;
470
471   return 0;
472 }