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