add pathconf

[unix-history] / usr / src / sys / nfs / nfs_subs.c

diff --git a/usr/src/sys/nfs/nfs_subs.c b/usr/src/sys/nfs/nfs_subs.c
index 43ddc18..20e7cc1 100644 (file)
--- a/usr/src/sys/nfs/nfs_subs.c
+++ b/usr/src/sys/nfs/nfs_subs.c
@@ -7,7 +7,7 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)nfs_subs.c  7.59 (Berkeley) %G%
+ *     @(#)nfs_subs.c  7.70 (Berkeley) %G%

  */
 
 /*
  */
 
 /*


@@ -36,6 +36,8 @@
 #include <nfs/nqnfs.h>
 #include <nfs/nfsrtt.h>
 
 #include <nfs/nqnfs.h>
 #include <nfs/nfsrtt.h>
 

+#include <miscfs/specfs/specdev.h>
+

 #include <netinet/in.h>
 #ifdef ISO
 #include <netiso/iso.h>
 #include <netinet/in.h>
 #ifdef ISO
 #include <netiso/iso.h>


@@ -59,11 +61,10 @@ u_long nfs_vers, nfs_prog, nfs_true, nfs_false;
 static u_long nfs_xid = 0;
 enum vtype ntov_type[7] = { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON };
 extern struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON];
 static u_long nfs_xid = 0;
 enum vtype ntov_type[7] = { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON };
 extern struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON];

+extern struct queue_entry nfs_bufq;

 extern struct nfsreq nfsreqh;
 extern int nqnfs_piggy[NFS_NPROCS];
 extern struct nfsrtt nfsrtt;
 extern struct nfsreq nfsreqh;
 extern int nqnfs_piggy[NFS_NPROCS];
 extern struct nfsrtt nfsrtt;

-extern union nqsrvthead nqthead;
-extern union nqsrvthead nqfhead[NQLCHSZ];

 extern time_t nqnfsstarttime;
 extern u_long nqnfs_prog, nqnfs_vers;
 extern int nqsrv_clockskew;
 extern time_t nqnfsstarttime;
 extern u_long nqnfs_prog, nqnfs_vers;
 extern int nqsrv_clockskew;


@@ -209,14 +210,14 @@ nfsm_rpchead(cr, nqnfs, procid, auth_type, auth_len, auth_str, mrest,
                                mb->m_len = 0;
                                bpos = mtod(mb, caddr_t);
                        }
                                mb->m_len = 0;
                                bpos = mtod(mb, caddr_t);
                        }

-                       i = MIN(siz, M_TRAILINGSPACE(mb));
+                       i = min(siz, M_TRAILINGSPACE(mb));

                        bcopy(auth_str, bpos, i);
                        mb->m_len += i;
                        auth_str += i;
                        bpos += i;
                        siz -= i;
                }
                        bcopy(auth_str, bpos, i);
                        mb->m_len += i;
                        auth_str += i;
                        bpos += i;
                        siz -= i;
                }

-               if ((siz = nfsm_rndup(auth_len) - auth_len) > 0) {
+               if ((siz = (nfsm_rndup(auth_len) - auth_len)) > 0) {

                        for (i = 0; i < siz; i++)
                                *bpos++ = '\0';
                        mb->m_len += siz;
                        for (i = 0; i < siz; i++)
                                *bpos++ = '\0';
                        mb->m_len += siz;


@@ -585,6 +586,7 @@ nfs_init()
        /* Ensure async daemons disabled */
        for (i = 0; i < NFS_MAXASYNCDAEMON; i++)
                nfs_iodwant[i] = (struct proc *)0;
        /* Ensure async daemons disabled */
        for (i = 0; i < NFS_MAXASYNCDAEMON; i++)
                nfs_iodwant[i] = (struct proc *)0;

+       queue_init(&nfs_bufq);

        nfs_xdrneg1 = txdr_unsigned(-1);
        nfs_nhinit();                   /* Init the nfsnode table */
        nfsrv_init(0);                  /* Init server data structures */
        nfs_xdrneg1 = txdr_unsigned(-1);
        nfs_nhinit();                   /* Init the nfsnode table */
        nfsrv_init(0);                  /* Init server data structures */


@@ -601,11 +603,7 @@ nfs_init()
                nqnfs_vers = txdr_unsigned(NQNFS_VER1);
                nqthead.th_head[0] = &nqthead;
                nqthead.th_head[1] = &nqthead;
                nqnfs_vers = txdr_unsigned(NQNFS_VER1);
                nqthead.th_head[0] = &nqthead;
                nqthead.th_head[1] = &nqthead;

-               for (i = 0; i < NQLCHSZ; i++) {
-                       lhp = &nqfhead[i];
-                       lhp->th_head[0] = lhp;
-                       lhp->th_head[1] = lhp;
-               }
+               nqfhead = hashinit(NQLCHSZ, M_NQLEASE, &nqfheadhash);

        }
 
        /*
        }
 
        /*


@@ -639,30 +637,35 @@ nfs_loadattrcache(vpp, mdp, dposp, vaper)
        register struct vattr *vap;
        register struct nfsv2_fattr *fp;
        extern int (**spec_nfsv2nodeop_p)();
        register struct vattr *vap;
        register struct nfsv2_fattr *fp;
        extern int (**spec_nfsv2nodeop_p)();

-       extern int (**spec_vnodeop_p)();
-       register struct nfsnode *np;
+       register struct nfsnode *np, *nq, **nhpp;

        register long t1;
        caddr_t dpos, cp2;
        register long t1;
        caddr_t dpos, cp2;

-       int error = 0;
+       int error = 0, isnq;

        struct mbuf *md;
        enum vtype vtyp;
        u_short vmode;
        long rdev;
        struct mbuf *md;
        enum vtype vtyp;
        u_short vmode;
        long rdev;

-       struct timeval mtime;
+       struct timespec mtime;

        struct vnode *nvp;
 
        md = *mdp;
        dpos = *dposp;
        t1 = (mtod(md, caddr_t) + md->m_len) - dpos;
        struct vnode *nvp;
 
        md = *mdp;
        dpos = *dposp;
        t1 = (mtod(md, caddr_t) + md->m_len) - dpos;

-       if (error = nfsm_disct(&md, &dpos, NFSX_FATTR, t1, TRUE, &cp2))
+       isnq = (VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS);
+       if (error = nfsm_disct(&md, &dpos, NFSX_FATTR(isnq), t1, TRUE, &cp2))

                return (error);
        fp = (struct nfsv2_fattr *)cp2;
        vtyp = nfstov_type(fp->fa_type);
        vmode = fxdr_unsigned(u_short, fp->fa_mode);
        if (vtyp == VNON || vtyp == VREG)
                vtyp = IFTOVT(vmode);
                return (error);
        fp = (struct nfsv2_fattr *)cp2;
        vtyp = nfstov_type(fp->fa_type);
        vmode = fxdr_unsigned(u_short, fp->fa_mode);
        if (vtyp == VNON || vtyp == VREG)
                vtyp = IFTOVT(vmode);

-       rdev = fxdr_unsigned(long, fp->fa_rdev);
-       fxdr_time(&fp->fa_mtime, &mtime);
+       if (isnq) {
+               rdev = fxdr_unsigned(long, fp->fa_nqrdev);
+               fxdr_nqtime(&fp->fa_nqmtime, &mtime);
+       } else {
+               rdev = fxdr_unsigned(long, fp->fa_nfsrdev);
+               fxdr_nfstime(&fp->fa_nfsmtime, &mtime);
+       }

        /*
         * If v_type == VNON it is a new node, so fill in the v_type,
         * n_mtime fields. Check to see if it represents a special 
        /*
         * If v_type == VNON it is a new node, so fill in the v_type,
         * n_mtime fields. Check to see if it represents a special 


@@ -690,7 +693,9 @@ nfs_loadattrcache(vpp, mdp, dposp, vaper)
                                /*
                                 * Discard unneeded vnode, but save its nfsnode.
                                 */
                                /*
                                 * Discard unneeded vnode, but save its nfsnode.
                                 */

-                               remque(np);
+                               if (nq = np->n_forw)
+                                       nq->n_back = np->n_back;
+                               *np->n_back = nq;

                                nvp->v_data = vp->v_data;
                                vp->v_data = NULL;
                                vp->v_op = spec_vnodeop_p;
                                nvp->v_data = vp->v_data;
                                vp->v_data = NULL;
                                vp->v_op = spec_vnodeop_p;


@@ -700,12 +705,16 @@ nfs_loadattrcache(vpp, mdp, dposp, vaper)
                                 * Reinitialize aliased node.
                                 */
                                np->n_vnode = nvp;
                                 * Reinitialize aliased node.
                                 */
                                np->n_vnode = nvp;

-                               insque(np, nfs_hash(&np->n_fh));
+                               nhpp = (struct nfsnode **)nfs_hash(&np->n_fh);
+                               if (nq = *nhpp)
+                                       nq->n_back = &np->n_forw;
+                               np->n_forw = nq;
+                               np->n_back = nhpp;
+                               *nhpp = np;

                                *vpp = vp = nvp;
                        }
                }
                                *vpp = vp = nvp;
                        }
                }

-               if ((VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS) == 0)
-                       np->n_mtime = mtime.tv_sec;
+               np->n_mtime = mtime.ts_sec;

        }
        vap = &np->n_vattr;
        vap->va_type = vtyp;
        }
        vap = &np->n_vattr;
        vap->va_type = vtyp;


@@ -713,31 +722,54 @@ nfs_loadattrcache(vpp, mdp, dposp, vaper)
        vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink);
        vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid);
        vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid);
        vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink);
        vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid);
        vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid);

-       vap->va_size = fxdr_unsigned(u_long, fp->fa_size);
-       if ((np->n_flag & NMODIFIED) == 0 || vap->va_size > np->n_size) {
-               np->n_size = vap->va_size;
-               vnode_pager_setsize(vp, (u_long)np->n_size);
-       }
-       vap->va_blocksize = fxdr_unsigned(long, fp->fa_blocksize);

        vap->va_rdev = (dev_t)rdev;
        vap->va_rdev = (dev_t)rdev;

-       vap->va_bytes = fxdr_unsigned(long, fp->fa_blocks) * NFS_FABLKSIZE;
+       vap->va_mtime = mtime;

        vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
        vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];

-       vap->va_fileid = fxdr_unsigned(long, fp->fa_fileid);
-       vap->va_atime.ts_sec = fxdr_unsigned(long, fp->fa_atime.tv_sec);
-       vap->va_atime.ts_nsec = 0;
-       vap->va_flags = fxdr_unsigned(u_long, fp->fa_atime.tv_usec);
-       vap->va_mtime.ts_sec = mtime.tv_sec;
-       vap->va_mtime.ts_nsec = mtime.tv_usec * 1000;
-       vap->va_ctime.ts_sec = fxdr_unsigned(long, fp->fa_ctime.tv_sec);
-       vap->va_ctime.ts_nsec = 0;
-       vap->va_gen = fxdr_unsigned(u_long, fp->fa_ctime.tv_usec);
+       if (isnq) {
+               fxdr_hyper(&fp->fa_nqsize, &vap->va_size);
+               vap->va_blocksize = fxdr_unsigned(long, fp->fa_nqblocksize);
+               fxdr_hyper(&fp->fa_nqbytes, &vap->va_bytes);
+               vap->va_fileid = fxdr_unsigned(long, fp->fa_nqfileid);
+               fxdr_nqtime(&fp->fa_nqatime, &vap->va_atime);
+               vap->va_flags = fxdr_unsigned(u_long, fp->fa_nqflags);
+               fxdr_nqtime(&fp->fa_nqctime, &vap->va_ctime);
+               vap->va_gen = fxdr_unsigned(u_long, fp->fa_nqgen);
+               fxdr_hyper(&fp->fa_nqfilerev, &vap->va_filerev);
+       } else {
+               vap->va_size = fxdr_unsigned(u_long, fp->fa_nfssize);
+               vap->va_blocksize = fxdr_unsigned(long, fp->fa_nfsblocksize);
+               vap->va_bytes = fxdr_unsigned(long, fp->fa_nfsblocks) * NFS_FABLKSIZE;
+               vap->va_fileid = fxdr_unsigned(long, fp->fa_nfsfileid);
+               fxdr_nfstime(&fp->fa_nfsatime, &vap->va_atime);
+               vap->va_flags = 0;
+               vap->va_ctime.ts_sec = fxdr_unsigned(long, fp->fa_nfsctime.nfs_sec);
+               vap->va_ctime.ts_nsec = 0;
+               vap->va_gen = fxdr_unsigned(u_long, fp->fa_nfsctime.nfs_usec);
+               vap->va_filerev = 0;
+       }
+       if (vap->va_size != np->n_size) {
+               if (vap->va_type == VREG) {
+                       if (np->n_flag & NMODIFIED) {
+                               if (vap->va_size < np->n_size)
+                                       vap->va_size = np->n_size;
+                               else
+                                       np->n_size = vap->va_size;
+                       } else
+                               np->n_size = vap->va_size;
+                       vnode_pager_setsize(vp, (u_long)np->n_size);
+               } else
+                       np->n_size = vap->va_size;
+       }

        np->n_attrstamp = time.tv_sec;
        *dposp = dpos;
        *mdp = md;
        if (vaper != NULL) {
                bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap));
        np->n_attrstamp = time.tv_sec;
        *dposp = dpos;
        *mdp = md;
        if (vaper != NULL) {
                bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap));

-               if ((np->n_flag & NMODIFIED) && (np->n_size > vap->va_size))
+#ifdef notdef
+               if ((np->n_flag & NMODIFIED) && np->n_size > vap->va_size)
+               if (np->n_size > vap->va_size)

                        vaper->va_size = np->n_size;
                        vaper->va_size = np->n_size;

+#endif

                if (np->n_flag & NCHG) {
                        if (np->n_flag & NACC) {
                                vaper->va_atime.ts_sec = np->n_atim.tv_sec;
                if (np->n_flag & NCHG) {
                        if (np->n_flag & NACC) {
                                vaper->va_atime.ts_sec = np->n_atim.tv_sec;


@@ -759,37 +791,54 @@ nfs_loadattrcache(vpp, mdp, dposp, vaper)
  * If the cache is valid, copy contents to *vap and return 0
  * otherwise return an error
  */
  * If the cache is valid, copy contents to *vap and return 0
  * otherwise return an error
  */

-nfs_getattrcache(vp, vap)
+nfs_getattrcache(vp, vaper)

        register struct vnode *vp;
        register struct vnode *vp;

-       struct vattr *vap;
+       struct vattr *vaper;

 {
 {

-       register struct nfsnode *np;
+       register struct nfsnode *np = VTONFS(vp);
+       register struct vattr *vap;

 
 

-       np = VTONFS(vp);
-       if (VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS) {
+       if (VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQLOOKLEASE) {

                if (!NQNFS_CKCACHABLE(vp, NQL_READ) || np->n_attrstamp == 0) {
                        nfsstats.attrcache_misses++;
                        return (ENOENT);
                }
                if (!NQNFS_CKCACHABLE(vp, NQL_READ) || np->n_attrstamp == 0) {
                        nfsstats.attrcache_misses++;
                        return (ENOENT);
                }

-       } else if ((time.tv_sec - np->n_attrstamp) >= NFS_ATTRTIMEO) {
+       } else if ((time.tv_sec - np->n_attrstamp) >= NFS_ATTRTIMEO(np)) {

                nfsstats.attrcache_misses++;
                return (ENOENT);
        }
        nfsstats.attrcache_hits++;
                nfsstats.attrcache_misses++;
                return (ENOENT);
        }
        nfsstats.attrcache_hits++;

-       bcopy((caddr_t)&np->n_vattr,(caddr_t)vap,sizeof(struct vattr));
+       vap = &np->n_vattr;
+       if (vap->va_size != np->n_size) {
+               if (vap->va_type == VREG) {
+                       if (np->n_flag & NMODIFIED) {
+                               if (vap->va_size < np->n_size)
+                                       vap->va_size = np->n_size;
+                               else
+                                       np->n_size = vap->va_size;
+                       } else
+                               np->n_size = vap->va_size;
+                       vnode_pager_setsize(vp, (u_long)np->n_size);
+               } else
+                       np->n_size = vap->va_size;
+       }
+       bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(struct vattr));
+#ifdef notdef

        if ((np->n_flag & NMODIFIED) == 0) {
        if ((np->n_flag & NMODIFIED) == 0) {

-               np->n_size = vap->va_size;
+               np->n_size = vaper->va_size;

                vnode_pager_setsize(vp, (u_long)np->n_size);
                vnode_pager_setsize(vp, (u_long)np->n_size);

-       } else if (np->n_size > vap->va_size)
-               vap->va_size = np->n_size;
+       } else if (np->n_size > vaper->va_size)
+       if (np->n_size > vaper->va_size)
+               vaper->va_size = np->n_size;
+#endif

        if (np->n_flag & NCHG) {
                if (np->n_flag & NACC) {
        if (np->n_flag & NCHG) {
                if (np->n_flag & NACC) {

-                       vap->va_atime.ts_sec = np->n_atim.tv_sec;
-                       vap->va_atime.ts_nsec = np->n_atim.tv_usec * 1000;
+                       vaper->va_atime.ts_sec = np->n_atim.tv_sec;
+                       vaper->va_atime.ts_nsec = np->n_atim.tv_usec * 1000;

                }
                if (np->n_flag & NUPD) {
                }
                if (np->n_flag & NUPD) {

-                       vap->va_mtime.ts_sec = np->n_mtim.tv_sec;
-                       vap->va_mtime.ts_nsec = np->n_mtim.tv_usec * 1000;
+                       vaper->va_mtime.ts_sec = np->n_mtim.tv_sec;
+                       vaper->va_mtime.ts_nsec = np->n_mtim.tv_usec * 1000;

                }
        }
        return (0);
                }
        }
        return (0);


@@ -839,11 +888,6 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, p)
                        error = EINVAL;
                        goto out;
                }
                        error = EINVAL;
                        goto out;
                }

-               if (*fromcp & 0200)
-                       if ((*fromcp&0377) == ('/'|0200) || cnp->cn_nameiop != DELETE) {
-                               error = EINVAL;
-                               goto out;
-                       }

                cnp->cn_hash += (unsigned char)*fromcp;
                *tocp++ = *fromcp++;
                rem--;
                cnp->cn_hash += (unsigned char)*fromcp;
                *tocp++ = *fromcp++;
                rem--;


@@ -987,6 +1031,7 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp)
 {
        register struct mount *mp;
        register struct nfsuid *uidp;
 {
        register struct mount *mp;
        register struct nfsuid *uidp;

+       register int i;

        struct ucred *credanon;
        int error, exflags;
 
        struct ucred *credanon;
        int error, exflags;
 


@@ -1006,13 +1051,18 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp)
                        uidp = uidp->nu_hnext;
                }
                if (uidp) {
                        uidp = uidp->nu_hnext;
                }
                if (uidp) {

-                       if (cred->cr_ref != 1)
-                               panic("nsrv fhtovp");
-                       *cred = uidp->nu_cr;
-               } else
+                       cred->cr_uid = uidp->nu_cr.cr_uid;
+                       for (i = 0; i < uidp->nu_cr.cr_ngroups; i++)
+                               cred->cr_groups[i] = uidp->nu_cr.cr_groups[i];
+               } else {
+                       vput(*vpp);

                        return (NQNFS_AUTHERR);
                        return (NQNFS_AUTHERR);

-       } else if (cred->cr_uid == 0 || (exflags & MNT_EXPORTANON))
-               *cred = *credanon;
+               }
+       } else if (cred->cr_uid == 0 || (exflags & MNT_EXPORTANON)) {
+               cred->cr_uid = credanon->cr_uid;
+               for (i = 0; i < credanon->cr_ngroups && i < NGROUPS; i++)
+                       cred->cr_groups[i] = credanon->cr_groups[i];
+       }

        if (exflags & MNT_EXRDONLY)
                *rdonlyp = 1;
        else
        if (exflags & MNT_EXRDONLY)
                *rdonlyp = 1;
        else


@@ -1029,64 +1079,37 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp)
  * The AF_INET family is handled as a special case so that address mbufs
  * don't need to be saved to store "struct in_addr", which is only 4 bytes.
  */
  * The AF_INET family is handled as a special case so that address mbufs
  * don't need to be saved to store "struct in_addr", which is only 4 bytes.
  */

-netaddr_match(family, haddr, hmask, nam)
+netaddr_match(family, haddr, nam)

        int family;
        union nethostaddr *haddr;
        int family;
        union nethostaddr *haddr;

-       union nethostaddr *hmask;

        struct mbuf *nam;
 {
        register struct sockaddr_in *inetaddr;
        struct mbuf *nam;
 {
        register struct sockaddr_in *inetaddr;

-#ifdef ISO
-       register struct sockaddr_iso *isoaddr1, *isoaddr2;
-#endif
-

 
        switch (family) {
        case AF_INET:
                inetaddr = mtod(nam, struct sockaddr_in *);
 
        switch (family) {
        case AF_INET:
                inetaddr = mtod(nam, struct sockaddr_in *);

-               if (inetaddr->sin_family != AF_INET)
-                       return (0);
-               if (hmask) {
-                       if ((inetaddr->sin_addr.s_addr & hmask->had_inetaddr) ==
-                           (haddr->had_inetaddr & hmask->had_inetaddr))
-                               return (1);
-               } else if (inetaddr->sin_addr.s_addr == haddr->had_inetaddr)
+               if (inetaddr->sin_family == AF_INET &&
+                   inetaddr->sin_addr.s_addr == haddr->had_inetaddr)

                        return (1);
                break;
 #ifdef ISO
        case AF_ISO:
                        return (1);
                break;
 #ifdef ISO
        case AF_ISO:

+           {
+               register struct sockaddr_iso *isoaddr1, *isoaddr2;
+

                isoaddr1 = mtod(nam, struct sockaddr_iso *);
                isoaddr1 = mtod(nam, struct sockaddr_iso *);

-               if (isoaddr1->siso_family != AF_ISO)
-                       return (0);

                isoaddr2 = mtod(haddr->had_nam, struct sockaddr_iso *);
                isoaddr2 = mtod(haddr->had_nam, struct sockaddr_iso *);

-               if (isoaddr1->siso_nlen > 0 &&
+               if (isoaddr1->siso_family == AF_ISO &&
+                   isoaddr1->siso_nlen > 0 &&

                    isoaddr1->siso_nlen == isoaddr2->siso_nlen &&
                    SAME_ISOADDR(isoaddr1, isoaddr2))
                        return (1);
                break;
                    isoaddr1->siso_nlen == isoaddr2->siso_nlen &&
                    SAME_ISOADDR(isoaddr1, isoaddr2))
                        return (1);
                break;

+           }

 #endif /* ISO */
        default:
                break;
        };
        return (0);
 }
 #endif /* ISO */
        default:
                break;
        };
        return (0);
 }

-
-/*
- * Generate a hash code for an iso host address. Used by NETADDRHASH() for
- * iso addresses.
- */
-iso_addrhash(saddr)
-       struct sockaddr *saddr;
-{
-#ifdef ISO
-       register struct sockaddr_iso *siso;
-       register int i, sum;
-
-       sum = 0;
-       for (i = 0; i < siso->siso_nlen; i++)
-               sum += siso->siso_data[i];
-       return (sum & (NETHASHSZ - 1));
-#else
-       return (0);
-#endif /* ISO */
-}