Include unistd.h.
[kopensolaris-gnu/glibc.git] / nscd / connections.c
1 /* Copyright (c) 1998 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1998.
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 <error.h>
22 #include <fcntl.h>
23 #include <libintl.h>
24 #include <locale.h>
25 #include <pthread.h>
26 #include <pwd.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <unistd.h>
30 #include <sys/poll.h>
31 #include <sys/socket.h>
32 #include <sys/stat.h>
33 #include <sys/types.h>
34 #include <sys/uio.h>
35 #include <sys/un.h>
36
37 #include "nscd.h"
38 #include "dbg_log.h"
39
40 /* Socket 0 in the array is named and exported into the file namespace
41    as a connection point for clients.  There's a one to one
42    correspondence between sock[i] and read_polls[i].  */
43 static int sock[MAX_NUM_CONNECTIONS];
44 static int socks_active;
45 static struct pollfd read_polls[MAX_NUM_CONNECTIONS];
46 static pthread_mutex_t sock_lock = PTHREAD_MUTEX_INITIALIZER;
47
48
49 /* Cleanup.  */
50 void
51 close_sockets (void)
52 {
53   int i;
54
55   if (debug_flag)
56     dbg_log (_("close_sockets called"));
57
58   pthread_mutex_lock (&sock_lock);
59
60   /* Close sockets.  */
61   for (i = 0; i < MAX_NUM_CONNECTIONS; ++i)
62     if (sock[i] != 0)
63       {
64         if (close (sock[i]))
65           dbg_log (_("socket [%d|%d] close: %s"), i, sock[i], strerror (errno));
66
67         sock[i] = 0;
68         read_polls[i].fd = -1;
69         --socks_active;
70       }
71
72   pthread_mutex_unlock (&sock_lock);
73 }
74
75 void
76 close_socket (int conn)
77 {
78   if (debug_flag > 2)
79     dbg_log (_("close socket (%d|%d)"), conn, sock[conn]);
80
81   pthread_mutex_lock (&sock_lock);
82
83   close (sock[conn]);
84   sock[conn] = 0;
85   read_polls[conn].fd = -1;
86   --socks_active;
87
88   pthread_mutex_unlock (&sock_lock);
89 }
90
91 /* Local routine, assigns a socket to a new connection request.  */
92 static void
93 handle_new_connection (void)
94 {
95   int i;
96
97   if (debug_flag > 2)
98     dbg_log (_("handle_new_connection"));
99
100   pthread_mutex_lock (&sock_lock);
101
102   if (socks_active < MAX_NUM_CONNECTIONS)
103     /* Find a free socket entry to use.  */
104     for (i = 1; i < MAX_NUM_CONNECTIONS; ++i)
105       {
106         if (sock[i] == 0)
107           {
108             if ((sock[i] = accept (sock[0], NULL, NULL)) < 0)
109               {
110                 dbg_log (_("socket accept: %s"), strerror (errno));
111                 return;
112               }
113             ++socks_active;
114             read_polls[i].fd = sock[i];
115             read_polls[i].events = POLLRDNORM;
116             if (debug_flag > 2)
117               dbg_log (_("handle_new_connection used socket %d|%d"), i,
118                        sock[i]);
119             break;
120           }
121       }
122   else
123     {
124       int black_widow_sock;
125       dbg_log (_("Supported number of simultaneous connections exceeded"));
126       dbg_log (_("Ignoring client connect request"));
127       /* There has to be a better way to ignore a connection request,..
128          when I get my hands on a sockets wiz I'll modify this.  */
129       black_widow_sock  = accept (sock[0], NULL, NULL);
130       close (black_widow_sock);
131     }
132   pthread_mutex_unlock (&sock_lock);
133 }
134
135 /* Local routine, reads a request off a socket indicated by read_polls.  */
136 static int
137 handle_new_request (int **connp, request_header **reqp, char **key)
138 {
139   ssize_t nbytes;
140   int i, found = 0;
141
142   if (debug_flag)
143     dbg_log ("handle_new_request");
144
145   /* Find the descriptor.  */
146   for (i = 1; i < MAX_NUM_CONNECTIONS; ++i) {
147     if (read_polls[i].fd >= 0
148         && read_polls[i].revents & (POLLRDNORM|POLLERR|POLLNVAL))
149       {
150         found = i;
151         break;
152       }
153     if (read_polls[i].fd >= 0 && (read_polls[i].revents & POLLHUP))
154       {
155         /* Don't close the socket, we still need to send data.  Just
156            stop polling for more data now.  */
157         read_polls[i].fd = -1;
158       }
159   }
160   
161   if (found == 0)
162     {
163       dbg_log (_("No sockets with data found !"));
164       return -1;
165     }
166
167   if (debug_flag > 2)
168     dbg_log (_("handle_new_request uses socket %d"), i);
169
170   /* Read from it.  */
171   nbytes = read (sock[i], *reqp, sizeof (request_header));
172   if (nbytes != sizeof (request_header))
173     {
174       /* Handle non-data read cases.  */
175       if (nbytes == 0)
176         {
177           /* Close socket down.  */
178           if (debug_flag > 2)
179             dbg_log (_("Real close socket %d|%d"), i, sock[i]);
180
181           pthread_mutex_lock (&sock_lock);
182           read_polls[i].fd = -1;
183           close (sock[i]);
184           sock[i] = 0;
185           --socks_active;
186           pthread_mutex_unlock (&sock_lock);
187         }
188       else
189         if (nbytes < 0)
190           {
191             dbg_log (_("Read(%d|%d) error on get request: %s"),
192                      i, sock[i], strerror (errno));
193             exit (1);
194           }
195         else
196           dbg_log (_("Read, data < request buf size, ignoring data"));
197
198       return -1;
199     }
200   else
201     {
202       *key = malloc ((*reqp)->key_len + 1);
203       /* Read the key from it */
204       nbytes = read (sock[i], *key, (*reqp)->key_len);
205       if (nbytes != (*reqp)->key_len)
206         {
207           /* Handle non-data read cases.  */
208           if (nbytes == 0)
209             {
210               /* Close socket down.  */
211               if (debug_flag > 2)
212                 dbg_log (_("Real close socket %d|%d"), i, sock[i]);
213
214               pthread_mutex_lock (&sock_lock);
215               read_polls[i].fd = -1;
216               close (sock[i]);
217               sock[i] = 0;
218               --socks_active;
219               pthread_mutex_unlock (&sock_lock);
220             }
221           else
222             if (nbytes < 0)
223               {
224                 perror (_("Read() error on get request"));
225                 return 0;
226               }
227             else
228               fputs (_("Read, data < request buf size, ignoring data"),
229                      stderr);
230
231           free (*key);
232           return -1;
233         }
234       else
235         {
236           /* Ok, have a live one, A real data req buf has been obtained.  */
237           (*key)[(*reqp)->key_len] = '\0';
238           **connp = i;
239           return 0;
240         }
241     }
242 }
243
244 void
245 get_request (int *conn, request_header *req, char **key)
246 {
247   int done = 0;
248   int nr;
249
250   if (debug_flag)
251     dbg_log ("get_request");
252
253   /* loop, processing new connection requests until a client buffer
254      is read in on an existing connection.  */
255   while (!done)
256     {
257       /* Poll active connections.  */
258       nr = poll (read_polls, MAX_NUM_CONNECTIONS, -1);
259       if (nr <= 0)
260         {
261           perror (_("Poll new reads"));
262           exit (1);
263         }
264       if (read_polls[0].revents & (POLLRDNORM|POLLERR|POLLHUP|POLLNVAL))
265         /* Handle the case of a new connection request on the named socket.  */
266         handle_new_connection ();
267       else
268         {
269           /* Read data from client specific descriptor.  */
270           if (handle_new_request (&conn, &req, key) == 0)
271             done = 1;
272         }
273     } /* While not_done.  */
274 }
275
276 void
277 init_sockets (void)
278 {
279   struct sockaddr_un sock_addr;
280   int i;
281
282   /* Initialize the connections db.  */
283   socks_active = 0;
284
285   /* Initialize the poll array. */
286   for (i = 0; i < MAX_NUM_CONNECTIONS; i++)
287     read_polls[i].fd = -1;
288
289   /* Create the socket.  */
290   sock[0] = socket (AF_UNIX, SOCK_STREAM, 0);
291   if (sock[0] < 0)
292     {
293       perror (_("cannot create socket"));
294       exit (1);
295     }
296   /* Bind a name to the socket.  */
297   sock_addr.sun_family = AF_UNIX;
298   strcpy (sock_addr.sun_path, _PATH_NSCDSOCKET);
299   if (bind (sock[0], (struct sockaddr *) &sock_addr, sizeof (sock_addr)) < 0)
300     {
301       dbg_log ("%s: %s", _PATH_NSCDSOCKET, strerror (errno));
302       exit (1);
303     }
304   /* Set permissions for the socket.  */
305   chmod (_PATH_NSCDSOCKET, 0666);
306
307   /* Set the socket up to accept connections.  */
308   if (listen (sock[0], MAX_NUM_CONNECTIONS) < 0)
309     {
310       perror (_("cannot enable socket to accept connections"));
311       exit (1);
312     }
313
314   /* Add the socket to the server's set of active sockets.  */
315   read_polls[0].fd = sock[0];
316   read_polls[0].events = POLLRDNORM;
317   ++socks_active;
318 }
319
320 void
321 pw_send_answer (int conn, struct passwd *pwd)
322 {
323   pw_response_header resp;
324
325   resp.version = NSCD_VERSION;
326   if (pwd != NULL)
327     {
328       resp.found = 1;
329       resp.pw_name_len = strlen (pwd->pw_name);
330       resp.pw_passwd_len = strlen (pwd->pw_passwd);
331       resp.pw_uid = pwd->pw_uid;
332       resp.pw_gid = pwd->pw_gid;
333       resp.pw_gecos_len = strlen (pwd->pw_gecos);
334       resp.pw_dir_len = strlen (pwd->pw_dir);
335       resp.pw_shell_len = strlen (pwd->pw_shell);
336     }
337   else
338     {
339       resp.found = 0;
340       resp.pw_name_len = 0;
341       resp.pw_passwd_len = 0;
342       resp.pw_uid = -1;
343       resp.pw_gid = -1;
344       resp.pw_gecos_len = 0;
345       resp.pw_dir_len = 0;
346       resp.pw_shell_len = 0;
347     }
348   if (sock[conn] == 0)
349     {
350       dbg_log (_("bad connection id on send response [%d|%d]"),
351                conn, sock[conn]);
352       return;
353     }
354
355   /* Send response header.  */
356   if (write (sock[conn], &resp, sizeof (pw_response_header)) !=
357       sizeof (pw_response_header))
358     {
359       dbg_log (_("write incomplete on send response: %s"), strerror (errno));
360       return;
361     }
362
363   if (resp.found)
364     {
365       struct iovec vec[5];
366
367       /* Send pw_name.  */
368       vec[0].iov_base = pwd->pw_name;
369       vec[0].iov_len = resp.pw_name_len;
370       /* Send pw_passwd.  */
371       vec[1].iov_base = pwd->pw_passwd;
372       vec[1].iov_len = resp.pw_passwd_len;
373       /* Send pw_gecos.  */
374       vec[2].iov_base = pwd->pw_gecos;
375       vec[2].iov_len = resp.pw_gecos_len;
376       /* Send pw_dir.  */
377       vec[3].iov_base = pwd->pw_dir;
378       vec[3].iov_len = resp.pw_dir_len;
379       /* Send pw_shell.  */
380       vec[4].iov_base = pwd->pw_shell;
381       vec[4].iov_len = resp.pw_shell_len;
382
383       if (writev (sock[conn], vec, 5) != (resp.pw_name_len + resp.pw_passwd_len
384                                           + resp.pw_gecos_len + resp.pw_dir_len
385                                           + resp.pw_shell_len))
386         dbg_log (_("write incomplete on send passwd answer: %s"),
387                  strerror (errno));
388     }
389 }
390
391 void
392 pw_send_disabled (int conn)
393 {
394   pw_response_header resp;
395
396   resp.version = NSCD_VERSION;
397   resp.found = -1;
398   resp.pw_name_len = 0;
399   resp.pw_passwd_len = 0;
400   resp.pw_uid = -1;
401   resp.pw_gid = -1;
402   resp.pw_gecos_len = 0;
403   resp.pw_dir_len = 0;
404   resp.pw_shell_len = 0;
405
406   if (sock[conn] == 0)
407     {
408       dbg_log (_("bad connection id on send response [%d|%d]"),
409                conn, sock[conn]);
410       return;
411     }
412
413   /* Send response header.  */
414   if (write (sock[conn], &resp, sizeof (pw_response_header))
415       != sizeof (pw_response_header))
416     dbg_log (_("write incomplete on send response: %s"), strerror (errno));
417 }
418
419 void
420 gr_send_answer (int conn, struct group *grp)
421 {
422   gr_response_header resp;
423
424   resp.version = NSCD_VERSION;
425   if (grp != NULL)
426     {
427       resp.found = 1;
428       resp.gr_name_len = strlen (grp->gr_name);
429       resp.gr_passwd_len = strlen (grp->gr_passwd);
430       resp.gr_gid = grp->gr_gid;
431       resp.gr_mem_len = 0;
432       while (grp->gr_mem[resp.gr_mem_len])
433         ++resp.gr_mem_len;
434     }
435   else
436     {
437       resp.found = 0;
438       resp.gr_name_len = 0;
439       resp.gr_passwd_len = 0;
440       resp.gr_gid = -1;
441       resp.gr_mem_len = 0;
442     }
443   if (sock[conn] == 0)
444     {
445       dbg_log (_("bad connection id on send response [%d|%d]"),
446                conn, sock[conn]);
447       return;
448     }
449
450   /* Send response header.  */
451   if (write (sock[conn], &resp, sizeof (gr_response_header))
452       != sizeof (gr_response_header))
453     {
454       dbg_log (_("write incomplete on send response: %s"), strerror (errno));
455       return;
456     }
457
458   if (resp.found)
459     {
460       unsigned int l = 0;
461
462       /* Send gr_name.  */
463       if (write (sock[conn], grp->gr_name, resp.gr_name_len)
464           != resp.gr_name_len)
465         {
466           dbg_log (_("write incomplete on send response: %s"),
467                    strerror (errno));
468           return;
469         }
470       /* Send gr_passwd.  */
471       if (write (sock[conn], grp->gr_passwd, resp.gr_passwd_len)
472           != resp.gr_passwd_len)
473         {
474           dbg_log (_("write incomplete on send response: %s"),
475                    strerror (errno));
476           return;
477         }
478
479       while (grp->gr_mem[l])
480         {
481           size_t len = strlen (grp->gr_mem[l]);
482
483           if (write (sock[conn], &len, sizeof (len)) != sizeof (len))
484             {
485               dbg_log (_("write incomplete on send response: %s"),
486                        strerror (errno));
487               return;
488             }
489           if (write (sock[conn], grp->gr_mem[l], len) != len)
490             {
491               dbg_log (_("write incomplete on send response: %s"),
492                        strerror (errno));
493               return;
494             }
495           ++l;
496         }
497     }
498 }
499
500 void
501 gr_send_disabled (int conn)
502 {
503   gr_response_header resp;
504
505   resp.version = NSCD_VERSION;
506   resp.found = -1;
507   resp.gr_name_len = 0;
508   resp.gr_passwd_len = 0;
509   resp.gr_gid = -1;
510   resp.gr_mem_len = 0;
511
512   if (sock[conn] == 0)
513     {
514       dbg_log (_("bad connection id on send gr_disabled response [%d|%d]"),
515                conn, sock[conn]);
516       return;
517     }
518
519   /* Send response header.  */
520   if (write (sock[conn], &resp, sizeof (gr_response_header))
521       != sizeof (gr_response_header))
522     dbg_log (_("write incomplete on send gr_disabled response: %s"),
523              strerror (errno));
524 }
525
526 void
527 stat_send (int conn, stat_response_header *resp)
528 {
529   if (sock[conn] == 0)
530     {
531       dbg_log (_("bad connection id on send stat response [%d|%d]"),
532                conn, sock[conn]);
533       return;
534     }
535
536   /* send response header.  */
537   if (write (sock[conn], resp, sizeof (stat_response_header))
538       != sizeof (stat_response_header))
539     dbg_log (_("write incomplete on send stat response: %s"),
540              strerror (errno));
541 }