FreeBSD/Linux Kernel Cross Reference
sys/netncp/ncp_conn.c
1 /*-
2 * Copyright (c) 1999, Boris Popov
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Boris Popov.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 * Connection tables
33 */
34
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD: releng/5.4/sys/netncp/ncp_conn.c 141090 2005-01-31 23:27:04Z imp $");
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/kernel.h>
41 #include <sys/malloc.h>
42 #include <sys/proc.h>
43 #include <sys/lock.h>
44 #include <sys/sysctl.h>
45
46 #include <netncp/ncp.h>
47 #include <netncp/nwerror.h>
48 #include <netncp/ncp_subr.h>
49 #include <netncp/ncp_conn.h>
50 #include <netncp/ncp_sock.h>
51 #include <netncp/ncp_ncp.h>
52
53 SLIST_HEAD(ncp_handle_head,ncp_handle);
54
55 int ncp_burst_enabled = 1;
56
57 struct ncp_conn_head conn_list={NULL};
58 static int ncp_conn_cnt = 0;
59 static int ncp_next_ref = 1;
60 static struct lock listlock;
61
62 struct ncp_handle_head lhlist={NULL};
63 static int ncp_next_handle = 1;
64 static struct lock lhlock;
65
66 static int ncp_sysctl_connstat(SYSCTL_HANDLER_ARGS);
67 static int ncp_conn_lock_any(struct ncp_conn *conn, struct thread *td,
68 struct ucred *cred);
69
70 SYSCTL_DECL(_net_ncp);
71 SYSCTL_INT (_net_ncp, OID_AUTO, burst_enabled, CTLFLAG_RD, &ncp_burst_enabled, 0, "");
72 SYSCTL_INT (_net_ncp, OID_AUTO, conn_cnt, CTLFLAG_RD, &ncp_conn_cnt, 0, "");
73 SYSCTL_PROC(_net_ncp, OID_AUTO, conn_stat, CTLFLAG_RD|CTLTYPE_OPAQUE,
74 NULL, 0, ncp_sysctl_connstat, "S,connstat", "Connections list");
75
76 MALLOC_DEFINE(M_NCPDATA, "NCP data", "NCP private data");
77
78 int
79 ncp_conn_init(void)
80 {
81 lockinit(&listlock, PSOCK, "ncpll", 0, 0);
82 lockinit(&lhlock, PSOCK, "ncplh", 0, 0);
83 return 0;
84 }
85
86 int
87 ncp_conn_destroy(void)
88 {
89 if (ncp_conn_cnt) {
90 NCPERROR("There are %d connections active\n", ncp_conn_cnt);
91 return EBUSY;
92 }
93 lockdestroy(&listlock);
94 lockdestroy(&lhlock);
95 return 0;
96 }
97
98 int
99 ncp_conn_locklist(int flags, struct thread *td)
100 {
101 return lockmgr(&listlock, flags | LK_CANRECURSE, 0, td);
102 }
103
104 void
105 ncp_conn_unlocklist(struct thread *td)
106 {
107 lockmgr(&listlock, LK_RELEASE, 0, td);
108 }
109
110 int
111 ncp_conn_access(struct ncp_conn *conn, struct ucred *cred, mode_t mode)
112 {
113 int error;
114
115 if (cred == NOCRED || ncp_suser(cred) == 0 ||
116 cred->cr_uid == conn->nc_owner->cr_uid)
117 return 0;
118 mode >>= 3;
119 if (!groupmember(conn->nc_group, cred))
120 mode >>= 3;
121 error = (conn->li.access_mode & mode) == mode ? 0 : EACCES;
122 return error;
123 }
124
125 int
126 ncp_conn_lock_any(struct ncp_conn *conn, struct thread *td, struct ucred *cred)
127 {
128 int error;
129
130 if (conn->nc_id == 0) return EACCES;
131 error = lockmgr(&conn->nc_lock, LK_EXCLUSIVE | LK_CANRECURSE, 0, td);
132 if (error == ERESTART)
133 return EINTR;
134 error = ncp_chkintr(conn, td);
135 if (error) {
136 lockmgr(&conn->nc_lock, LK_RELEASE, 0, td);
137 return error;
138 }
139
140 if (conn->nc_id == 0) {
141 lockmgr(&conn->nc_lock, LK_RELEASE, 0, td);
142 return EACCES;
143 }
144 conn->td = td; /* who currently operates */
145 conn->ucred = cred;
146 return 0;
147 }
148
149 int
150 ncp_conn_lock(struct ncp_conn *conn, struct thread *td, struct ucred *cred, int mode)
151 {
152 int error;
153
154 error = ncp_conn_access(conn, cred, mode);
155 if (error) return error;
156 return ncp_conn_lock_any(conn, td, cred);
157 }
158
159 /*
160 * Lock conn but unlock connlist
161 */
162 static int
163 ncp_conn_lock2(struct ncp_conn *conn, struct thread *td, struct ucred *cred, int mode)
164 {
165 int error;
166
167 error = ncp_conn_access(conn, cred, mode);
168 if (error) {
169 ncp_conn_unlocklist(td);
170 return error;
171 }
172 conn->nc_lwant++;
173 ncp_conn_unlocklist(td);
174 error = ncp_conn_lock_any(conn, td, cred);
175 conn->nc_lwant--;
176 if (conn->nc_lwant == 0) {
177 wakeup(&conn->nc_lwant);
178 }
179 return error;
180 }
181
182 void
183 ncp_conn_unlock(struct ncp_conn *conn, struct thread *td)
184 {
185 /*
186 * note, that LK_RELASE will do wakeup() instead of wakeup_one().
187 * this will do a little overhead
188 */
189 lockmgr(&conn->nc_lock, LK_RELEASE, 0, td);
190 }
191
192 int
193 ncp_conn_assert_locked(struct ncp_conn *conn, const char *checker, struct thread *td)
194 {
195 if (conn->nc_lock.lk_flags & LK_HAVE_EXCL) return 0;
196 printf("%s: connection isn't locked!\n", checker);
197 return EIO;
198 }
199
200 void
201 ncp_conn_invalidate(struct ncp_conn *ncp)
202 {
203 ncp->flags &= ~(NCPFL_ATTACHED | NCPFL_LOGGED | NCPFL_INVALID);
204 }
205
206 int
207 ncp_conn_invalid(struct ncp_conn *ncp)
208 {
209 return ncp->flags & NCPFL_INVALID;
210 }
211
212 /*
213 * create, fill with defaults and return in locked state
214 */
215 int
216 ncp_conn_alloc(struct ncp_conn_args *cap, struct thread *td, struct ucred *cred,
217 struct ncp_conn **conn)
218 {
219 struct ncp_conn *ncp;
220 struct ucred *owner;
221 int error, isroot;
222
223 if (cap->saddr.sa_family != AF_INET && cap->saddr.sa_family != AF_IPX)
224 return EPROTONOSUPPORT;
225 isroot = ncp_suser(cred) == 0;
226 /*
227 * Only root can change ownership
228 */
229 if (cap->owner != NCP_DEFAULT_OWNER && !isroot)
230 return EPERM;
231 if (cap->group != NCP_DEFAULT_GROUP &&
232 !groupmember(cap->group, cred) && !isroot)
233 return EPERM;
234 if (cap->owner != NCP_DEFAULT_OWNER) {
235 owner = crget();
236 owner->cr_uid = cap->owner;
237 } else
238 owner = crhold(cred);
239 MALLOC(ncp, struct ncp_conn *, sizeof(struct ncp_conn),
240 M_NCPDATA, M_WAITOK | M_ZERO);
241 error = 0;
242 lockinit(&ncp->nc_lock, PZERO, "ncplck", 0, 0);
243 ncp_conn_cnt++;
244 ncp->nc_id = ncp_next_ref++;
245 ncp->nc_owner = cred;
246 ncp->seq = 0;
247 ncp->connid = 0xFFFF;
248 ncp->li = *cap;
249 ncp->nc_group = (cap->group != NCP_DEFAULT_GROUP) ?
250 cap->group : cred->cr_groups[0];
251
252 if (cap->retry_count == 0)
253 ncp->li.retry_count = NCP_RETRY_COUNT;
254 if (cap->timeout == 0)
255 ncp->li.timeout = NCP_RETRY_TIMEOUT;
256 ncp_conn_lock_any(ncp, td, ncp->nc_owner);
257 *conn = ncp;
258 ncp_conn_locklist(LK_EXCLUSIVE, td);
259 SLIST_INSERT_HEAD(&conn_list,ncp,nc_next);
260 ncp_conn_unlocklist(td);
261 return (error);
262 }
263
264 /*
265 * Remove the connection, on entry it must be locked
266 */
267 int
268 ncp_conn_free(struct ncp_conn *ncp)
269 {
270 struct thread *td;
271 int error;
272
273 if (ncp == NULL) {
274 NCPFATAL("ncp == NULL\n");
275 return 0;
276 }
277 if (ncp->nc_id == 0) {
278 NCPERROR("nc_id == 0\n");
279 return EACCES;
280 }
281 td = ncp->td;
282 error = ncp_conn_assert_locked(ncp, __func__, td);
283 if (error)
284 return error;
285 if (ncp->ref_cnt != 0 || (ncp->flags & NCPFL_PERMANENT))
286 return EBUSY;
287 if (ncp_conn_access(ncp, ncp->ucred, NCPM_WRITE))
288 return EACCES;
289
290 if (ncp->flags & NCPFL_ATTACHED)
291 ncp_ncp_disconnect(ncp);
292 ncp_sock_disconnect(ncp);
293
294 /*
295 * Mark conn as dead and wait for other process
296 */
297 ncp->nc_id = 0;
298 ncp_conn_unlock(ncp, td);
299 /*
300 * if signal is raised - how I do react ?
301 */
302 lockmgr(&ncp->nc_lock, LK_DRAIN, 0, td);
303 lockdestroy(&ncp->nc_lock);
304 while (ncp->nc_lwant) {
305 printf("lwant = %d\n", ncp->nc_lwant);
306 tsleep(&ncp->nc_lwant, PZERO,"ncpdr",2*hz);
307 }
308 ncp_conn_locklist(LK_EXCLUSIVE, td);
309 SLIST_REMOVE(&conn_list, ncp, ncp_conn, nc_next);
310 ncp_conn_cnt--;
311 ncp_conn_unlocklist(td);
312 if (ncp->li.user)
313 free(ncp->li.user, M_NCPDATA);
314 if (ncp->li.password)
315 free(ncp->li.password, M_NCPDATA);
316 crfree(ncp->nc_owner);
317 FREE(ncp, M_NCPDATA);
318 return (0);
319 }
320
321 int
322 ncp_conn_reconnect(struct ncp_conn *ncp)
323 {
324 int error;
325
326 /*
327 * Close opened sockets if any
328 */
329 ncp_sock_disconnect(ncp);
330 error = ncp_sock_connect(ncp);
331 if (error)
332 return error;
333 error = ncp_ncp_connect(ncp);
334 if (error)
335 return error;
336 error = ncp_renegotiate_connparam(ncp, NCP_DEFAULT_BUFSIZE, 0);
337 if (error == NWE_SIGNATURE_LEVEL_CONFLICT) {
338 printf("Unable to negotiate requested security level\n");
339 error = EOPNOTSUPP;
340 }
341 if (error) {
342 ncp_ncp_disconnect(ncp);
343 return error;
344 }
345 #ifdef NCPBURST
346 error = ncp_burst_connect(ncp);
347 if (error) {
348 ncp_ncp_disconnect(ncp);
349 return error;
350 }
351 #endif
352 return 0;
353 }
354
355 int
356 ncp_conn_login(struct ncp_conn *conn, struct thread *td, struct ucred *cred)
357 {
358 struct ncp_bindery_object user;
359 u_char ncp_key[8];
360 int error;
361
362 error = ncp_get_encryption_key(conn, ncp_key);
363 if (error) {
364 printf("%s: Warning: use unencrypted login\n", __func__);
365 error = ncp_login_unencrypted(conn, conn->li.objtype,
366 conn->li.user, conn->li.password, td, cred);
367 } else {
368 error = ncp_get_bindery_object_id(conn, conn->li.objtype,
369 conn->li.user, &user, td, cred);
370 if (error)
371 return error;
372 error = ncp_login_encrypted(conn, &user, ncp_key,
373 conn->li.password, td, cred);
374 }
375 if (!error)
376 conn->flags |= NCPFL_LOGGED | NCPFL_WASLOGGED;
377 return error;
378 }
379
380 /*
381 * Lookup connection by handle, return a locked conn descriptor
382 */
383 int
384 ncp_conn_getbyref(int ref, struct thread *td, struct ucred *cred, int mode,
385 struct ncp_conn **connpp)
386 {
387 struct ncp_conn *ncp;
388 int error = 0;
389
390 ncp_conn_locklist(LK_SHARED, td);
391 SLIST_FOREACH(ncp, &conn_list, nc_next)
392 if (ncp->nc_id == ref) break;
393 if (ncp == NULL) {
394 ncp_conn_unlocklist(td);
395 return(EBADF);
396 }
397 error = ncp_conn_lock2(ncp, td, cred, mode);
398 if (!error)
399 *connpp = ncp;
400 return (error);
401 }
402 /*
403 * find attached, but not logged in connection to specified server
404 */
405 int
406 ncp_conn_getattached(struct ncp_conn_args *li, struct thread *td,
407 struct ucred *cred, int mode, struct ncp_conn **connpp)
408 {
409 struct ncp_conn *ncp, *ncp2 = NULL;
410 int error = 0;
411
412 ncp_conn_locklist(LK_SHARED, td);
413 SLIST_FOREACH(ncp, &conn_list, nc_next) {
414 if ((ncp->flags & NCPFL_LOGGED) != 0 ||
415 strcmp(ncp->li.server,li->server) != 0 ||
416 ncp->li.saddr.sa_len != li->saddr.sa_len ||
417 bcmp(&ncp->li.saddr,&ncp->li.saddr,li->saddr.sa_len) != 0)
418 continue;
419 if (ncp_suser(cred) == 0 ||
420 cred->cr_uid == ncp->nc_owner->cr_uid)
421 break;
422 error = ncp_conn_access(ncp,cred,mode);
423 if (!error && ncp2 == NULL)
424 ncp2 = ncp;
425 }
426 if (ncp == NULL) ncp = ncp2;
427 if (ncp == NULL) {
428 ncp_conn_unlocklist(td);
429 return(EBADF);
430 }
431 error = ncp_conn_lock2(ncp, td, cred, mode);
432 if (!error)
433 *connpp=ncp;
434 return (error);
435 }
436
437 /*
438 * Lookup connection by server/user pair, return a locked conn descriptor.
439 * if li is NULL or server/user pair incomplete, try to select best connection
440 * based on owner.
441 * Connection selected in next order:
442 * 1. Try to search conn with ucred owner, if li is NULL also find a primary
443 * 2. If 1. fails try to get first suitable shared connection
444 * 3. If 2. fails then nothing can help to poor ucred owner
445 */
446
447 int
448 ncp_conn_getbyli(struct ncp_conn_args *li, struct thread *td,
449 struct ucred *cred, int mode, struct ncp_conn **connpp)
450 {
451 struct ncp_conn *ncp, *ncp2 = NULL;
452 int error = 0, partial, haveserv;
453
454 partial = (li == NULL || li->server[0] == 0 || li->user == NULL);
455 haveserv = (li && li->server[0]);
456 ncp_conn_locklist(LK_SHARED, td);
457 SLIST_FOREACH(ncp, &conn_list, nc_next) {
458 if (partial) {
459 if (cred->cr_uid == ncp->nc_owner->cr_uid) {
460 if (haveserv) {
461 if (strcmp(ncp->li.server,li->server) == 0)
462 break;
463 } else {
464 if (ncp->flags & NCPFL_PRIMARY)
465 break;
466 ncp2 = ncp;
467 }
468 continue;
469 }
470 } else {
471 if (strcmp(ncp->li.server,li->server) != 0 ||
472 ncp->li.user == NULL ||
473 strcmp(ncp->li.user,li->user) != 0)
474 continue;
475 if (cred->cr_uid == ncp->nc_owner->cr_uid)
476 break;
477 if (ncp_suser(cred) == 0)
478 ncp2 = ncp;
479 }
480 error = ncp_conn_access(ncp,cred,mode);
481 if (!error && ncp2 == NULL)
482 ncp2 = ncp;
483 }
484 if (ncp == NULL) ncp = ncp2;
485 if (ncp == NULL) {
486 ncp_conn_unlocklist(td);
487 return(EBADF);
488 }
489 error = ncp_conn_lock2(ncp, td, cred,mode);
490 if (!error)
491 *connpp=ncp;
492 return (error);
493 }
494
495 /*
496 * Set primary connection flag, since it have sence only for an owner,
497 * only owner can modify this flag.
498 * connection expected to be locked.
499 */
500 int
501 ncp_conn_setprimary(struct ncp_conn *conn, int on)
502 {
503 struct ncp_conn *ncp=NULL;
504
505 if (conn->ucred->cr_uid != conn->nc_owner->cr_uid)
506 return EACCES;
507 ncp_conn_locklist(LK_SHARED, conn->td);
508 SLIST_FOREACH(ncp, &conn_list, nc_next) {
509 if (conn->ucred->cr_uid == ncp->nc_owner->cr_uid)
510 ncp->flags &= ~NCPFL_PRIMARY;
511 }
512 ncp_conn_unlocklist(conn->td);
513 if (on)
514 conn->flags |= NCPFL_PRIMARY;
515 return 0;
516 }
517 /*
518 * Lease conn to given proc, returning unique handle
519 * problem: how locks should be applied ?
520 */
521 int
522 ncp_conn_gethandle(struct ncp_conn *conn, struct thread *td, struct ncp_handle **handle)
523 {
524 struct ncp_handle *refp;
525
526 lockmgr(&lhlock, LK_EXCLUSIVE, 0, td);
527 SLIST_FOREACH(refp, &lhlist, nh_next)
528 if (refp->nh_conn == conn && td == refp->nh_td) break;
529 if (refp) {
530 conn->ref_cnt++;
531 refp->nh_ref++;
532 *handle = refp;
533 lockmgr(&lhlock, LK_RELEASE, 0, td);
534 return 0;
535 }
536 MALLOC(refp,struct ncp_handle *,sizeof(struct ncp_handle),M_NCPDATA,
537 M_WAITOK | M_ZERO);
538 SLIST_INSERT_HEAD(&lhlist,refp,nh_next);
539 refp->nh_ref++;
540 refp->nh_td = td;
541 refp->nh_conn = conn;
542 refp->nh_id = ncp_next_handle++;
543 *handle = refp;
544 conn->ref_cnt++;
545 lockmgr(&lhlock, LK_RELEASE, 0, td);
546 return 0;
547 }
548 /*
549 * release reference, if force - ignore refcount
550 */
551 int
552 ncp_conn_puthandle(struct ncp_handle *handle, struct thread *td, int force)
553 {
554 struct ncp_handle *refp = handle;
555
556 lockmgr(&lhlock, LK_EXCLUSIVE, 0, td);
557 refp->nh_ref--;
558 refp->nh_conn->ref_cnt--;
559 if (force) {
560 refp->nh_conn->ref_cnt -= refp->nh_ref;
561 refp->nh_ref = 0;
562 }
563 if (refp->nh_ref == 0) {
564 SLIST_REMOVE(&lhlist, refp, ncp_handle, nh_next);
565 FREE(refp, M_NCPDATA);
566 }
567 lockmgr(&lhlock, LK_RELEASE, 0, td);
568 return 0;
569 }
570 /*
571 * find a connHandle
572 */
573 int
574 ncp_conn_findhandle(int connHandle, struct thread *td, struct ncp_handle **handle) {
575 struct ncp_handle *refp;
576
577 lockmgr(&lhlock, LK_SHARED, 0, td);
578 SLIST_FOREACH(refp, &lhlist, nh_next)
579 if (refp->nh_td == td && refp->nh_id == connHandle) break;
580 lockmgr(&lhlock, LK_RELEASE, 0, td);
581 if (refp == NULL) {
582 return EBADF;
583 }
584 *handle = refp;
585 return 0;
586 }
587 /*
588 * Clear handles associated with specified process
589 */
590 int
591 ncp_conn_putprochandles(struct thread *td)
592 {
593 struct ncp_handle *hp, *nhp;
594 int haveone = 0;
595
596 lockmgr(&lhlock, LK_EXCLUSIVE, 0, td);
597 for (hp = SLIST_FIRST(&lhlist); hp; hp = nhp) {
598 nhp = SLIST_NEXT(hp, nh_next);
599 if (hp->nh_td != td) continue;
600 haveone = 1;
601 hp->nh_conn->ref_cnt -= hp->nh_ref;
602 SLIST_REMOVE(&lhlist, hp, ncp_handle, nh_next);
603 FREE(hp, M_NCPDATA);
604 }
605 lockmgr(&lhlock, LK_RELEASE, 0, td);
606 return haveone;
607 }
608 /*
609 * remove references in all possible connections,
610 * XXX - possible problem is a locked list.
611 */
612 /*void
613 ncp_conn_list_rm_ref(pid_t pid) {
614 struct ncp_conn *ncp;
615
616 ncp_conn_locklist(LK_SHARED, NULL);
617 SLIST_FOREACH(ncp, &conn_list, nc_next) {
618 ncp_conn_rm_ref(ncp,pid,1);
619 }
620 ncp_conn_unlocklist(NULL);
621 return;
622 }
623 */
624 int
625 ncp_conn_getinfo(struct ncp_conn *ncp, struct ncp_conn_stat *ncs) {
626 bzero(ncs,sizeof(*ncs));
627 ncs->li = ncp->li;
628 ncs->li.user = ncs->user;
629 if (ncp->li.user)
630 strcpy(ncs->user, ncp->li.user);
631 ncs->li.password = NULL;
632 ncs->connRef = ncp->nc_id;
633 ncs->ref_cnt = ncp->ref_cnt;
634 ncs->connid = ncp->connid;
635 ncs->owner = ncp->nc_owner->cr_uid;
636 ncs->group = ncp->nc_group;
637 ncs->flags = ncp->flags;
638 ncs->buffer_size = ncp->buffer_size;
639 return 0;
640 }
641
642 static int
643 ncp_sysctl_connstat(SYSCTL_HANDLER_ARGS)
644 {
645 int error;
646 struct ncp_conn_stat ncs;
647 struct ncp_conn *ncp;
648 /* struct ucred *cred = req->td->td_ucred;*/
649
650 error = sysctl_wire_old_buffer(req, 0);
651 if (error != 0)
652 return (error);
653 ncp_conn_locklist(LK_SHARED, req->td);
654 error = SYSCTL_OUT(req, &ncp_conn_cnt, sizeof(ncp_conn_cnt));
655 SLIST_FOREACH(ncp, &conn_list, nc_next) {
656 if (error) break;
657 /* I can't do conn_lock while list is locked */
658 ncp->nc_lwant++;
659 if (!error) {
660 ncp_conn_getinfo(ncp, &ncs);
661 } else {
662 bzero(&ncs,sizeof(ncs));
663 ncs.connRef = ncp->nc_id;
664 strcpy(ncs.li.server,"***");
665 }
666 ncp->nc_lwant--;
667 error = SYSCTL_OUT(req, &ncs, sizeof(ncs));
668 }
669 ncp_conn_unlocklist(req->td);
670 return(error);
671 }
Cache object: 8051138057c79770427d1a49ce009975
|