Cleanup `#if _LIBC' and `#ifndef _LIBC' fragments.
[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
233   request.header.version = UTMPD_VERSION;
234   request.header.size = sizeof (setutent_request);
235   request.header.type = UTMPD_REQ_SETUTENT;
236   strncpy (request.file, __libc_utmp_file_name, sizeof request.file);
237
238   reply.header.version = UTMPD_VERSION;
239   reply.header.size = sizeof (setutent_reply);
240   reply.header.type = UTMPD_REQ_SETUTENT;
241
242   if (send_request (sock, &request.header, &reply.header) < 0)
243     return -1;
244
245   if (reply.result < 0)
246     __set_errno (reply.errnum);
247
248   return reply.result;
249 }
250
251 static int
252 do_getutent (int sock, struct utmp *buffer)
253 {
254   getutent_request request;
255   getutent_reply reply;
256
257   request.header.version = UTMPD_VERSION;
258   request.header.size = sizeof (getutent_request);
259   request.header.type = UTMPD_REQ_GETUTENT;
260
261   reply.header.version = UTMPD_VERSION;
262   reply.header.size = sizeof (getutent_reply);
263   reply.header.type = UTMPD_REQ_GETUTENT;
264
265   if (send_request (sock, &request.header, &reply.header) < 0)
266     return -1;
267
268   if (reply.result < 0)
269     __set_errno (reply.errnum);
270   else
271     memcpy (buffer, &reply.entry, sizeof (struct utmp));
272
273   return reply.result;
274 }
275
276 static int
277 do_endutent (int sock)
278 {
279   endutent_request request;
280   endutent_reply reply;
281
282   request.header.version = UTMPD_VERSION;
283   request.header.size = sizeof (endutent_request);
284   request.header.type = UTMPD_REQ_ENDUTENT;
285
286   reply.header.version = UTMPD_VERSION;
287   reply.header.size = sizeof (endutent_reply);
288   reply.header.type = UTMPD_REQ_ENDUTENT;
289
290   if (send_request (sock, &request.header, &reply.header) < 0)
291     return -1;
292
293   if (reply.result < 0)
294     __set_errno (reply.errnum);
295
296   return reply.result;
297 }
298
299 static int
300 do_getutline (int sock, const struct utmp *line, struct utmp *buffer)
301 {
302   getutline_request request;
303   getutline_reply reply;
304
305   request.header.version = UTMPD_VERSION;
306   request.header.size = sizeof (getutline_request);
307   request.header.type = UTMPD_REQ_GETUTLINE;
308   memcpy (&request.line, line, sizeof (struct utmp));
309
310   reply.header.version = UTMPD_VERSION;
311   reply.header.size = sizeof (getutline_reply);
312   reply.header.type = UTMPD_REQ_GETUTLINE;
313
314   if (send_request (sock, &request.header, &reply.header) < 0)
315     return -1;
316
317   if (reply.result < 0)
318     __set_errno (reply.errnum);
319   else
320     memcpy (buffer, &reply.entry, sizeof (struct utmp));
321
322   return reply.result;
323 }
324
325 static int
326 do_getutid (int sock, const struct utmp *id, struct utmp *buffer)
327 {
328   getutid_request request;
329   getutid_reply reply;
330
331   request.header.version = UTMPD_VERSION;
332   request.header.size = sizeof (getutid_request);
333   request.header.type = UTMPD_REQ_GETUTID;
334   memcpy (&request.id, id, sizeof (struct utmp));
335
336   reply.header.version = UTMPD_VERSION;
337   reply.header.size = sizeof (getutid_reply);
338   reply.header.type = UTMPD_REQ_GETUTID;
339
340   if (send_request (sock, &request.header, &reply.header) < 0)
341     return -1;
342
343   if (reply.result < 0)
344     __set_errno (reply.errnum);
345   else
346     memcpy (buffer, &reply.entry, sizeof (struct utmp));
347
348   return reply.result;
349 }
350
351 static int
352 do_pututline (int sock, const struct utmp *utmp)
353 {
354   pututline_request request;
355   pututline_reply reply;
356
357   request.header.version = UTMPD_VERSION;
358   request.header.size = sizeof (pututline_request);
359   request.header.type = UTMPD_REQ_PUTUTLINE;
360   memcpy (&request.utmp, utmp, sizeof (struct utmp));
361
362   reply.header.version = UTMPD_VERSION;
363   reply.header.size = sizeof (pututline_reply);
364   reply.header.type = UTMPD_REQ_PUTUTLINE;
365
366   if (send_request (sock, &request.header, &reply.header) < 0)
367     return -1;
368
369   if (reply.result < 0)
370     __set_errno (reply.errnum);
371
372   return reply.result;
373 }
374
375 static int
376 do_updwtmp (int sock, const char *file, const struct utmp *utmp)
377 {
378   updwtmp_request request;
379   updwtmp_reply reply;
380
381   request.header.version = UTMPD_VERSION;
382   request.header.size = sizeof (updwtmp_request);
383   request.header.type = UTMPD_REQ_UPDWTMP;
384   strncpy (request.file, file, sizeof request.file);
385   memcpy (&request.utmp, utmp, sizeof (struct utmp));
386
387   reply.header.version = UTMPD_VERSION;
388   reply.header.size = sizeof (updwtmp_reply);
389   reply.header.type = UTMPD_REQ_UPDWTMP;
390
391   if (send_request (sock, &request.header, &reply.header) < 0)
392     return -1;
393
394   if (reply.result < 0)
395     __set_errno (reply.errnum);
396
397   return reply.result;
398 }
399
400
401 /* Create a socket connected to NAME.  */
402 static int
403 open_socket (const char *name)
404 {
405   struct sockaddr_un addr;
406   int sock;
407
408   sock = socket (PF_UNIX, SOCK_STREAM, 0);
409   if (sock < 0)
410     return -1;
411
412   addr.sun_family = AF_UNIX;
413   strcpy (addr.sun_path, name);
414   if (connect (sock, (struct sockaddr *) &addr, sizeof (addr)) < 0)
415     {
416       close (sock);
417       return -1;
418     }
419
420   return sock;
421 }
422
423 /* Send REQUEST to SOCK, and wait for reply.  Returns 0 if successful,
424    storing the reply in REPLY, and -1 if not.  */
425 static int
426 send_request (int sock, const request_header *request,
427               reply_header *reply)
428 {
429   reply_header header;
430   ssize_t nbytes;
431
432   nbytes = write (sock, request, request->size);
433   if (nbytes != (ssize_t) request->size)
434     return -1;
435
436   nbytes = read (sock, &header, sizeof (reply_header));
437   if (nbytes != sizeof (reply_header))
438     return -1;
439
440   if (reply->version != header.version
441       || reply->size != header.size
442       || reply->type != header.type)
443     return -1;
444
445   nbytes = read (sock, reply + 1, reply->size - sizeof (reply_header));
446   if (nbytes != (ssize_t) (reply->size - sizeof (reply_header)))
447     return -1;
448
449   return 0;
450 }