cc84b65dbc81d59d7cb9ea0edc14572427bde242
[dragonfly.git] / usr.sbin / sdpd / server.c
1 /* $NetBSD: server.c,v 1.3 2007/03/18 10:00:42 plunky Exp $ */
2 /* $DragonFly: src/usr.sbin/sdpd/server.c,v 1.1 2008/01/06 21:51:30 hasso Exp $ */
3
4 /*-
5  * Copyright (c) 2006 Itronix Inc.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. The name of Itronix Inc. may not be used to endorse
17  *    or promote products derived from this software without specific
18  *    prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
24  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27  * ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30  * POSSIBILITY OF SUCH DAMAGE.
31  */
32 /*
33  * server.c
34  *
35  * Copyright (c) 2004 Maksim Yevmenkin <m_evmenkin@yahoo.com>
36  * All rights reserved.
37  *
38  * Redistribution and use in source and binary forms, with or without
39  * modification, are permitted provided that the following conditions
40  * are met:
41  * 1. Redistributions of source code must retain the above copyright
42  *    notice, this list of conditions and the following disclaimer.
43  * 2. Redistributions in binary form must reproduce the above copyright
44  *    notice, this list of conditions and the following disclaimer in the
45  *    documentation and/or other materials provided with the distribution.
46  *
47  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
48  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
51  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57  * SUCH DAMAGE.
58  *
59  * $Id: server.c,v 1.1.1.1 2007/11/20 11:56:11 griffin Exp $
60  * $FreeBSD: src/usr.sbin/bluetooth/sdpd/server.c,v 1.2 2005/12/06 17:56:36 emax Exp $
61  */
62
63 #include <sys/param.h>
64 #include <sys/select.h>
65 #include <sys/stat.h>
66 #include <sys/queue.h>
67 #include <sys/ucred.h>
68 #include <sys/un.h>
69 #include <sys/uio.h>
70 #include <netinet/in.h>
71 #include <arpa/inet.h>
72 #include <assert.h>
73 #include <bluetooth.h>
74 #include <errno.h>
75 #include <grp.h>
76 #include <pwd.h>
77 #include <sdp.h>
78 #include <stdio.h>
79 #include <stdlib.h>
80 #include <string.h>
81 #include <unistd.h>
82 #include "log.h"
83 #include "profile.h"
84 #include "provider.h"
85 #include "server.h"
86
87 static void     server_accept_client            (server_p srv, int32_t fd);
88 static int32_t  server_process_request          (server_p srv, int32_t fd);
89 static int32_t  server_send_error_response      (server_p srv, int32_t fd,
90                                                  uint16_t error);
91 static void     server_close_fd                 (server_p srv, int32_t fd);
92 #if 0
93 static int      server_auth_check               (server_p srv, struct sockcred *cred);
94 #endif
95 static int      server_auth_check               (server_p srv, struct cmsgcred *cred);
96
97 /*
98  * Initialize server
99  */
100
101 int32_t
102 server_init(server_p srv, char const *control, char const *sgroup)
103 {
104         struct sockaddr_un      un;
105         struct sockaddr_bt      l2;
106         socklen_t               size;
107         int32_t                 unsock, l2sock;
108         uint16_t                imtu;
109         int                     opt;
110
111         assert(srv != NULL);
112         assert(control != NULL);
113
114         memset(srv, 0, sizeof(srv));
115         srv->sgroup = sgroup;
116
117         /* Open control socket */
118         if (unlink(control) < 0 && errno != ENOENT) {
119                 log_crit("Could not unlink(%s). %s (%d)",
120                         control, strerror(errno), errno);
121                 return (-1);
122         }
123
124         unsock = socket(PF_LOCAL, SOCK_STREAM, 0);
125         if (unsock < 0) {
126                 log_crit("Could not create control socket. %s (%d)",
127                         strerror(errno), errno);
128                 return (-1);
129         }
130
131         opt = 1;
132 #if 0
133         if (setsockopt(unsock, 0, LOCAL_CREDS, &opt, sizeof(opt)) < 0)
134                 log_crit("Warning: No credential checks on control socket");
135 #endif
136         memset(&un, 0, sizeof(un));
137         un.sun_len = sizeof(un);
138         un.sun_family = AF_LOCAL;
139         strlcpy(un.sun_path, control, sizeof(un.sun_path));
140
141         if (bind(unsock, (struct sockaddr *) &un, sizeof(un)) < 0) {
142                 log_crit("Could not bind control socket. %s (%d)",
143                         strerror(errno), errno);
144                 close(unsock);
145                 return (-1);
146         }
147
148         if (chmod(control, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH) < 0) {
149                 log_crit("Could not change permissions on control socket. " \
150                         "%s (%d)", strerror(errno), errno);
151                 close(unsock);
152                 return (-1);
153         }
154
155         if (listen(unsock, 10) < 0) {
156                 log_crit("Could not listen on control socket. %s (%d)",
157                         strerror(errno), errno);
158                 close(unsock);
159                 return (-1);
160         }
161
162         /* Open L2CAP socket */
163         l2sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
164         if (l2sock < 0) {
165                 log_crit("Could not create L2CAP socket. %s (%d)",
166                         strerror(errno), errno);
167                 close(unsock);
168                 return (-1);
169         }
170
171         size = sizeof(imtu);
172         if (getsockopt(l2sock, BTPROTO_L2CAP, SO_L2CAP_IMTU, &imtu, &size) < 0) {
173                 log_crit("Could not get L2CAP IMTU. %s (%d)",
174                         strerror(errno), errno);
175                 close(unsock);
176                 close(l2sock);
177                 return (-1);
178         }
179
180         memset(&l2, 0, sizeof(l2));
181         l2.bt_len = sizeof(l2);
182         l2.bt_family = AF_BLUETOOTH;
183         l2.bt_psm = L2CAP_PSM_SDP;
184         bdaddr_copy(&l2.bt_bdaddr, BDADDR_ANY);
185
186         if (bind(l2sock, (struct sockaddr *) &l2, sizeof(l2)) < 0) {
187                 log_crit("Could not bind L2CAP socket. %s (%d)",
188                         strerror(errno), errno);
189                 close(unsock);
190                 close(l2sock);
191                 return (-1);
192         }
193
194         if (listen(l2sock, 10) < 0) {
195                 log_crit("Could not listen on L2CAP socket. %s (%d)",
196                         strerror(errno), errno);
197                 close(unsock);
198                 close(l2sock);
199                 return (-1);
200         }
201
202         /* Allocate incoming buffer */
203         srv->imtu = (imtu > SDP_LOCAL_MTU)? imtu : SDP_LOCAL_MTU;
204         srv->req = (uint8_t *) calloc(srv->imtu, sizeof(srv->req[0]));
205         if (srv->req == NULL) {
206                 log_crit("Could not allocate request buffer");
207                 close(unsock);
208                 close(l2sock);
209                 return (-1);
210         }
211
212         /* Allocate memory for descriptor index */
213         srv->fdidx = (fd_idx_p) calloc(FD_SETSIZE, sizeof(srv->fdidx[0]));
214         if (srv->fdidx == NULL) {
215                 log_crit("Could not allocate fd index");
216                 free(srv->req);
217                 close(unsock);
218                 close(l2sock);
219                 return (-1);
220         }
221
222         /* Register Service Discovery profile (attach it to control socket) */
223         if (provider_register_sd(unsock) < 0) {
224                 log_crit("Could not register Service Discovery profile");
225                 free(srv->fdidx);
226                 free(srv->req);
227                 close(unsock);
228                 close(l2sock);
229                 return (-1);
230         }
231
232         /*
233          * If we got here then everything is fine. Add both control sockets
234          * to the index.
235          */
236
237         FD_ZERO(&srv->fdset);
238         srv->maxfd = (unsock > l2sock)? unsock : l2sock;
239
240         FD_SET(unsock, &srv->fdset);
241         srv->fdidx[unsock].valid = 1;
242         srv->fdidx[unsock].server = 1;
243         srv->fdidx[unsock].control = 1;
244         srv->fdidx[unsock].priv = 0;
245         srv->fdidx[unsock].rsp_cs = 0;
246         srv->fdidx[unsock].rsp_size = 0;
247         srv->fdidx[unsock].rsp_limit = 0;
248         srv->fdidx[unsock].omtu = SDP_LOCAL_MTU;
249         srv->fdidx[unsock].rsp = NULL;
250
251         FD_SET(l2sock, &srv->fdset);
252         srv->fdidx[l2sock].valid = 1;
253         srv->fdidx[l2sock].server = 1;
254         srv->fdidx[l2sock].control = 0;
255         srv->fdidx[l2sock].priv = 0;
256         srv->fdidx[l2sock].rsp_cs = 0;
257         srv->fdidx[l2sock].rsp_size = 0;
258         srv->fdidx[l2sock].rsp_limit = 0;
259         srv->fdidx[l2sock].omtu = 0; /* unknown */
260         srv->fdidx[l2sock].rsp = NULL;
261
262         return (0);
263 }
264
265 /*
266  * Shutdown server
267  */
268
269 void
270 server_shutdown(server_p srv)
271 {
272         int     fd;
273
274         assert(srv != NULL);
275
276         for (fd = 0; fd < srv->maxfd + 1; fd ++)
277                 if (srv->fdidx[fd].valid)
278                         server_close_fd(srv, fd);
279
280         free(srv->req);
281         free(srv->fdidx);
282
283         memset(srv, 0, sizeof(*srv));
284 }
285
286 /*
287  * Do one server iteration
288  */
289
290 int32_t
291 server_do(server_p srv)
292 {
293         fd_set  fdset;
294         int32_t n, fd;
295
296         assert(srv != NULL);
297
298         /* Copy cached version of the fd set and call select */
299         memcpy(&fdset, &srv->fdset, sizeof(fdset));
300         n = select(srv->maxfd + 1, &fdset, NULL, NULL, NULL);
301         if (n < 0) {
302                 if (errno == EINTR)
303                         return (0);
304
305                 log_err("Could not select(%d, %p). %s (%d)",
306                         srv->maxfd + 1, &fdset, strerror(errno), errno);
307
308                 return (-1);
309         }
310
311         /* Process  descriptors */
312         for (fd = 0; fd < srv->maxfd + 1 && n > 0; fd ++) {
313                 if (!FD_ISSET(fd, &fdset))
314                         continue;
315
316                 assert(srv->fdidx[fd].valid);
317                 n --;
318
319                 if (srv->fdidx[fd].server)
320                         server_accept_client(srv, fd);
321                 else if (server_process_request(srv, fd) != 0)
322                         server_close_fd(srv, fd);
323         }
324
325         return (0);
326
327 }
328
329 /*
330  * Accept new client connection and register it with index
331  */
332
333 static void
334 server_accept_client(server_p srv, int32_t fd)
335 {
336         uint8_t         *rsp = NULL;
337         socklen_t        size;
338         int32_t          cfd;
339         uint16_t         omtu;
340
341         do {
342                 cfd = accept(fd, NULL, NULL);
343         } while (cfd < 0 && errno == EINTR);
344
345         if (cfd < 0) {
346                 log_err("Could not accept connection on %s socket. %s (%d)",
347                         srv->fdidx[fd].control? "control" : "L2CAP",
348                         strerror(errno), errno);
349                 return;
350         }
351
352         assert(!FD_ISSET(cfd, &srv->fdset));
353         assert(!srv->fdidx[cfd].valid);
354
355         if (!srv->fdidx[fd].control) {
356                 /* Get local BD_ADDR */
357                 size = sizeof(srv->req_sa);
358                 if (getsockname(cfd,(struct sockaddr*)&srv->req_sa, &size) < 0) {
359                         log_err("Could not get local BD_ADDR. %s (%d)",
360                                 strerror(errno), errno);
361                         close(cfd);
362                         return;
363                 }
364
365                 /* Get outgoing MTU */
366                 size = sizeof(omtu);
367                 if (getsockopt(cfd, BTPROTO_L2CAP, SO_L2CAP_OMTU, &omtu, &size) < 0) {
368                         log_err("Could not get L2CAP OMTU. %s (%d)",
369                                 strerror(errno), errno);
370                         close(cfd);
371                         return;
372                 }
373
374                 /*
375                  * The maximum size of the L2CAP packet is 65536 bytes.
376                  * The minimum L2CAP MTU is 43 bytes. That means we need
377                  * 65536 / 43 = ~1524 chunks to transfer maximum packet
378                  * size with minimum MTU. The "rsp_cs" field in fd_idx_t
379                  * is 11 bit wide that gives us upto 2048 chunks.
380                  */
381
382                 if (omtu < L2CAP_MTU_MINIMUM) {
383                         log_err("L2CAP OMTU is too small (%d bytes)", omtu);
384                         close(cfd);
385                         return;
386                 }
387         } else {
388                 bdaddr_copy(&srv->req_sa.bt_bdaddr, BDADDR_ANY);
389                 omtu = srv->fdidx[fd].omtu;
390         }
391
392         /*
393          * Allocate buffer. This is an overkill, but we can not know how
394          * big our reply is going to be.
395          */
396
397         rsp = (uint8_t *) calloc(L2CAP_MTU_MAXIMUM, sizeof(rsp[0]));
398         if (rsp == NULL) {
399                 log_crit("Could not allocate response buffer");
400                 close(cfd);
401                 return;
402         }
403
404         /* Add client descriptor to the index */
405         FD_SET(cfd, &srv->fdset);
406         if (srv->maxfd < cfd)
407                 srv->maxfd = cfd;
408         srv->fdidx[cfd].valid = 1;
409         srv->fdidx[cfd].server = 0;
410         srv->fdidx[cfd].control = srv->fdidx[fd].control;
411         srv->fdidx[cfd].priv = 0;
412         srv->fdidx[cfd].rsp_cs = 0;
413         srv->fdidx[cfd].rsp_size = 0;
414         srv->fdidx[cfd].rsp_limit = 0;
415         srv->fdidx[cfd].omtu = omtu;
416         srv->fdidx[cfd].rsp = rsp;
417 }
418
419 /*
420  * Process request from the client
421  */
422
423 static int32_t
424 server_process_request(server_p srv, int32_t fd)
425 {
426         uint8_t         ctl[128];
427         sdp_pdu_p       pdu = (sdp_pdu_p) srv->req;
428         struct msghdr   msg;
429         struct iovec    iov;
430         int32_t         len, error;
431         struct cmsghdr  *cmsg;
432
433         assert(srv->imtu > 0);
434         assert(srv->req != NULL);
435         assert(FD_ISSET(fd, &srv->fdset));
436         assert(srv->fdidx[fd].valid);
437         assert(!srv->fdidx[fd].server);
438         assert(srv->fdidx[fd].rsp != NULL);
439         assert(srv->fdidx[fd].omtu >= L2CAP_MTU_MINIMUM);
440
441         iov.iov_base = srv->req;
442         iov.iov_len = srv->imtu;
443
444         msg.msg_name = NULL;
445         msg.msg_namelen = 0;
446         msg.msg_iov = &iov;
447         msg.msg_iovlen = 1;
448         msg.msg_control = ctl;
449         msg.msg_controllen = sizeof(ctl);
450         msg.msg_flags = 0;
451
452         do {
453                 len = recvmsg(fd, &msg, 0);
454         } while (len < 0 && errno == EINTR);
455
456         if (len < 0) {
457                 log_err("Could not receive SDP request from %s socket. %s (%d)",
458                         srv->fdidx[fd].control? "control" : "L2CAP",
459                         strerror(errno), errno);
460                 return (-1);
461         }
462         if (len == 0) {
463                 log_info("Client on %s socket has disconnected",
464                         srv->fdidx[fd].control? "control" : "L2CAP");
465                 return (-1);
466         }
467
468 #if XXX
469         if ((cmsg = CMSG_FIRSTHDR(&msg)) != NULL
470             && cmsg->cmsg_level == SOL_SOCKET
471             && cmsg->cmsg_type == SCM_CREDS
472 #if 0
473             && cmsg->cmsg_len >= CMSG_LEN(SOCKCREDSIZE(0))
474 #endif
475 )
476                 srv->fdidx[fd].priv = 
477                     server_auth_check(srv, (struct cmsgcred *)CMSG_DATA(cmsg));
478 #if 0
479                     server_auth_check(srv, (struct sockcred *)CMSG_DATA(cmsg));
480 #endif
481 #else
482 srv->fdidx[fd].priv = 1;
483 #endif
484
485         if (len >= sizeof(*pdu)
486             && (sizeof(*pdu) + (pdu->len = ntohs(pdu->len))) == len) {
487                 switch (pdu->pid) {
488                 case SDP_PDU_SERVICE_SEARCH_REQUEST:
489                         error = server_prepare_service_search_response(srv, fd);
490                         break;
491
492                 case SDP_PDU_SERVICE_ATTRIBUTE_REQUEST:
493                         error = server_prepare_service_attribute_response(srv, fd);
494                         break;
495
496                 case SDP_PDU_SERVICE_SEARCH_ATTRIBUTE_REQUEST:
497                         error = server_prepare_service_search_attribute_response(srv, fd);
498                         break;
499
500                 case SDP_PDU_SERVICE_REGISTER_REQUEST:
501                         error = server_prepare_service_register_response(srv, fd);
502                         break;
503
504                 case SDP_PDU_SERVICE_UNREGISTER_REQUEST:
505                         error = server_prepare_service_unregister_response(srv, fd);
506                         break;
507
508                 case SDP_PDU_SERVICE_CHANGE_REQUEST:
509                         error = server_prepare_service_change_response(srv, fd);
510                         break;
511
512                 default:
513                         error = SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX;
514                         break;
515                 }
516         } else
517                 error = SDP_ERROR_CODE_INVALID_PDU_SIZE;
518
519         if (error == 0) {
520                 switch (pdu->pid) {
521                 case SDP_PDU_SERVICE_SEARCH_REQUEST:
522                         error = server_send_service_search_response(srv, fd);
523                         break;
524
525                 case SDP_PDU_SERVICE_ATTRIBUTE_REQUEST:
526                         error = server_send_service_attribute_response(srv, fd);
527                         break;
528
529                 case SDP_PDU_SERVICE_SEARCH_ATTRIBUTE_REQUEST:
530                         error = server_send_service_search_attribute_response(srv, fd);
531                         break;
532
533                 case SDP_PDU_SERVICE_REGISTER_REQUEST:
534                         error = server_send_service_register_response(srv, fd);
535                         break;
536
537                 case SDP_PDU_SERVICE_UNREGISTER_REQUEST:
538                         error = server_send_service_unregister_response(srv, fd);
539                         break;
540
541                 case SDP_PDU_SERVICE_CHANGE_REQUEST:
542                         error = server_send_service_change_response(srv, fd);
543                         break;
544
545                 default:
546                         error = SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX;
547                         break;
548                 }
549
550                 if (error != 0)
551                         log_err("Could not send SDP response to %s socket, " \
552                                 "pdu->pid=%d, pdu->tid=%d, error=%d",
553                                 srv->fdidx[fd].control? "control" : "L2CAP",
554                                 pdu->pid, ntohs(pdu->tid), error);
555         } else {
556                 log_err("Could not process SDP request from %s socket, " \
557                         "pdu->pid=%d, pdu->tid=%d, pdu->len=%d, len=%d, " \
558                         "error=%d",
559                         srv->fdidx[fd].control? "control" : "L2CAP",
560                         pdu->pid, ntohs(pdu->tid), pdu->len, len, error);
561
562                 error = server_send_error_response(srv, fd, error);
563                 if (error != 0)
564                         log_err("Could not send SDP error response to %s " \
565                                 "socket, pdu->pid=%d, pdu->tid=%d, error=%d",
566                                 srv->fdidx[fd].control? "control" : "L2CAP",
567                                 pdu->pid, ntohs(pdu->tid), error);
568         }
569
570         /* On error forget response (if any) */
571         if (error != 0) {
572                 srv->fdidx[fd].rsp_cs = 0;
573                 srv->fdidx[fd].rsp_size = 0;
574                 srv->fdidx[fd].rsp_limit = 0;
575         }
576
577         return (error);
578 }
579
580 /*
581  * Send SDP_Error_Response PDU
582  */
583
584 static int32_t
585 server_send_error_response(server_p srv, int32_t fd, uint16_t error)
586 {
587         int32_t size;
588
589         struct {
590                 sdp_pdu_t               pdu;
591                 uint16_t                error;
592         } __attribute__ ((packed))      rsp;
593
594         /* Prepare and send SDP error response */
595         rsp.pdu.pid = SDP_PDU_ERROR_RESPONSE;
596         rsp.pdu.tid = ((sdp_pdu_p)(srv->req))->tid;
597         rsp.pdu.len = htons(sizeof(rsp.error));
598         rsp.error   = htons(error);
599
600         do {
601                 size = write(fd, &rsp, sizeof(rsp));
602         } while (size < 0 && errno == EINTR);
603
604         return ((size < 0)? errno : 0);
605 }
606
607 /*
608  * Close descriptor and remove it from index
609  */
610
611 static void
612 server_close_fd(server_p srv, int32_t fd)
613 {
614         provider_p      provider = NULL, provider_next = NULL;
615
616         assert(FD_ISSET(fd, &srv->fdset));
617         assert(srv->fdidx[fd].valid);
618
619         close(fd);
620
621         FD_CLR(fd, &srv->fdset);
622         if (fd == srv->maxfd)
623                 srv->maxfd --;
624
625         if (srv->fdidx[fd].rsp != NULL)
626                 free(srv->fdidx[fd].rsp);
627
628         memset(&srv->fdidx[fd], 0, sizeof(srv->fdidx[fd]));
629
630         for (provider = provider_get_first();
631              provider != NULL;
632              provider = provider_next) {
633                 provider_next = provider_get_next(provider);
634
635                 if (provider->fd == fd)
636                         provider_unregister(provider);
637         }
638 }
639
640 static int
641 /*server_auth_check(server_p srv, struct sockcred *cred)*/
642 server_auth_check(server_p srv, struct cmsgcred *cred)
643 {
644         struct group *grp;
645         int n;
646
647         if (cred == NULL)
648                 return 0;
649
650         if (cred->cmcred_uid == 0 || cred->cmcred_euid == 0)
651                 return 1;
652
653         if (srv->sgroup == NULL)
654                 return 0;
655
656         grp = getgrnam(srv->sgroup);
657         if (grp == NULL) {
658                 log_err("No gid for group '%s'", srv->sgroup);
659                 srv->sgroup = NULL;
660                 return 0;
661         }
662
663
664         if (cred->cmcred_gid == grp->gr_gid)
665                 return 1;
666
667         for (n = 0 ; n < cred->cmcred_ngroups ; n++) {
668                 if (cred->cmcred_groups[n] == grp->gr_gid)
669                         return 1;
670         }
671
672         return 0;
673 }