From eccc1379c8a0a79caa9071ac9f26400196b465d9 Mon Sep 17 00:00:00 2001 From: danfe Date: Wed, 20 Oct 2004 12:33:37 +0000 Subject: Fix code so it is favored by both GCCs (2.x and 3.x), and unbreak the build. Approved by: fjoe (mentor, implicit) maintainer timeout --- security/sfs/Makefile | 7 +- security/sfs/files/patch-arpc_rpctypes.h | 44 +++++++++ security/sfs/files/patch-arpc_xdrmisc.h | 10 ++ security/sfs/files/patch-async_ihash.h | 11 +++ security/sfs/files/patch-async_init.h | 41 ++++++++ security/sfs/files/patch-async_qhash.h | 11 +++ security/sfs/files/patch-async_refcnt.h | 118 ++++++++++++++++++++++ security/sfs/files/patch-async_vec.h | 143 +++++++++++++++++++++++++++ security/sfs/files/patch-sfsmisc_afsnode.h | 11 +++ security/sfs/files/patch-sfsmisc_nfsserv.h | 42 ++++++++ security/sfs/files/patch-sfsmisc_sfsclient.h | 10 ++ security/sfs/files/patch-sfsmisc_sfscrypt.h | 10 ++ 12 files changed, 454 insertions(+), 4 deletions(-) create mode 100644 security/sfs/files/patch-arpc_rpctypes.h create mode 100644 security/sfs/files/patch-arpc_xdrmisc.h create mode 100644 security/sfs/files/patch-async_ihash.h create mode 100644 security/sfs/files/patch-async_init.h create mode 100644 security/sfs/files/patch-async_qhash.h create mode 100644 security/sfs/files/patch-async_refcnt.h create mode 100644 security/sfs/files/patch-async_vec.h create mode 100644 security/sfs/files/patch-sfsmisc_afsnode.h create mode 100644 security/sfs/files/patch-sfsmisc_nfsserv.h create mode 100644 security/sfs/files/patch-sfsmisc_sfsclient.h create mode 100644 security/sfs/files/patch-sfsmisc_sfscrypt.h (limited to 'security/sfs') diff --git a/security/sfs/Makefile b/security/sfs/Makefile index 8793b7ef6129..74e9e3bbac23 100644 --- a/security/sfs/Makefile +++ b/security/sfs/Makefile @@ -20,6 +20,7 @@ PLIST_SUB= SFS_VERSION=${PORTVERSION} INFO= sfs USE_GMAKE= yes +USE_REINPLACE= yes USE_INC_LIBTOOL_VER=13 GNU_CONFIGURE= yes CONFIGURE_ARGS+=--with-sfsuser=sfs \ @@ -34,10 +35,6 @@ CONFIGURE_ARGS+=--with-sfsuser=sfs \ BROKEN= "Does not compile on !i386" .endif -.if ${OSVERSION} >= 502126 -BROKEN= "Does not compile on FreeBSD >= 5.x" -.endif - .if ${OSVERSION} > 500000 LIB_DEPENDS+= gmp.6:${PORTSDIR}/math/libgmp4 CONFIGURE_ARGS+=--with-gmp=${LOCALBASE} @@ -76,6 +73,8 @@ MAN8= \ post-extract: @${SED} -e "s=%%PREFIX%%=${PREFIX}=g" ${FILESDIR}/sfscd.sh > ${WRKSRC}/sfscd.sh @${SED} -e "s=%%PREFIX%%=${PREFIX}=g" ${FILESDIR}/sfssd.sh > ${WRKSRC}/sfssd.sh + @${FIND} -E ${WRKDIR} -type f -iregex ".*\.(C|h)" -print0 | \ + ${XARGS} -0 ${REINPLACE_CMD} -e 's/template get/get/' pre-install: PKG_PREFIX=${PREFIX} ${SH} pkg-install ${PKGNAME} PRE-INSTALL diff --git a/security/sfs/files/patch-arpc_rpctypes.h b/security/sfs/files/patch-arpc_rpctypes.h new file mode 100644 index 000000000000..4bd0ae3feebf --- /dev/null +++ b/security/sfs/files/patch-arpc_rpctypes.h @@ -0,0 +1,44 @@ +--- arpc/rpctypes.h.orig Mon Oct 11 16:43:34 2004 ++++ arpc/rpctypes.h Mon Oct 11 16:39:35 2004 +@@ -129,7 +129,7 @@ + if (&v != this) \ + assign (v) + +- void init () { mode = NOFREE; nelm = 0; vec = NULL; } ++ void init () { mode = freemode::NOFREE; nelm = 0; vec = NULL; } + void del () { + switch (mode) { + case NOFREE: +@@ -266,6 +266,8 @@ + a.swap (b); + } + ++extern const str rpc_emptystr; ++ + template struct rpc_str : str + { + enum { maxsize = max }; +@@ -301,12 +303,12 @@ + }; + + template struct rpc_opaque : array { +- rpc_opaque () { bzero (base (), size ()); } ++ rpc_opaque () { bzero (this->base (), this->size ()); } + }; + template struct rpc_bytes : rpc_vec { +- void setstrmem (const str &s) { set (s.cstr (), s.len (), NOFREE); } ++ void setstrmem (const str &s) { set (s.cstr (), s.len (), freemode::NOFREE); } + rpc_bytes &operator= (const str &s) +- { setsize (s.len ()); memcpy (base (), s.cstr (), size ()); return *this; } ++ { setsize (s.len ()); memcpy (this->base (), s.cstr (), this->size ()); return *this; } + template rpc_bytes &operator= (const rpc_vec &v) + { rpc_vec::operator= (v); return *this; } + template rpc_bytes &operator= (const array &v) +@@ -519,7 +521,6 @@ + + struct rpc_clear_t {}; + extern struct rpc_clear_t _rpcclear; +-extern const str rpc_emptystr; + + inline bool + rpc_traverse (rpc_clear_t &, u_int32_t &obj) diff --git a/security/sfs/files/patch-arpc_xdrmisc.h b/security/sfs/files/patch-arpc_xdrmisc.h new file mode 100644 index 000000000000..11b57af4fa1f --- /dev/null +++ b/security/sfs/files/patch-arpc_xdrmisc.h @@ -0,0 +1,10 @@ +--- arpc/xdrmisc.h.orig Mon Oct 11 16:43:34 2004 ++++ arpc/xdrmisc.h Mon Oct 11 16:39:35 2004 +@@ -26,6 +26,7 @@ + #ifndef _ARPC_XDRMISC_H_ + #define _ARPC_XDRMISC_H_ 1 + ++#include "wmstr.h" + #include "sysconf.h" + + extern "C" { diff --git a/security/sfs/files/patch-async_ihash.h b/security/sfs/files/patch-async_ihash.h new file mode 100644 index 000000000000..0418638c835d --- /dev/null +++ b/security/sfs/files/patch-async_ihash.h @@ -0,0 +1,11 @@ +--- async/ihash.h.orig Mon Oct 11 16:43:34 2004 ++++ async/ihash.h Mon Oct 11 16:39:35 2004 +@@ -213,7 +213,7 @@ + const H hash; + + public: +- ihash () {} ++ ihash () : eq (E ()), hash (H ()) {} + ihash (const E &e, const H &h) : eq (e), hash (h) {} + + void insert (V *elm) { insert_val (elm, hash (elm->*key)); } diff --git a/security/sfs/files/patch-async_init.h b/security/sfs/files/patch-async_init.h new file mode 100644 index 000000000000..75ad11d3fa13 --- /dev/null +++ b/security/sfs/files/patch-async_init.h @@ -0,0 +1,41 @@ +--- async/init.h.orig Mon Oct 11 16:43:34 2004 ++++ async/init.h Mon Oct 11 16:39:35 2004 +@@ -25,6 +25,12 @@ + #ifndef _ASYNC_INIT_H_ + #define _ASYNC_INIT_H_ 1 + ++#if __GNUC__ >= 3 ++# define __init_attribute__(x) ++#else /* gcc < 3 */ ++# define __init_attribute__(x) __attribute__ (x) ++#endif /* gcc < 3 */ ++ + #define INIT(name) \ + static class name { \ + static int count; \ +@@ -34,7 +40,7 @@ + public: \ + name () {if (!cnt ()++) start ();} \ + ~name () {if (!--cnt ()) stop ();} \ +-} init_ ## name __attribute__ ((unused)) ++} init_ ## name __init_attribute__ ((unused)) + + class initfn { + initfn (); +@@ -43,7 +49,7 @@ + }; + #define INITFN(fn) \ + static void fn (); \ +-static initfn init_ ## fn (fn) __attribute__ ((unused)) ++static initfn init_ ## fn (fn) __init_attribute__ ((unused)) + + class exitfn { + void (*const fn) (); +@@ -53,6 +59,6 @@ + }; + #define EXITFN(fn) \ + static void fn (); \ +-static exitfn exit_ ## fn (fn) __attribute__ ((unused)) ++static exitfn exit_ ## fn (fn) __init_attribute__ ((unused)) + + #endif /* !_ASYNC_INIT_H_ */ diff --git a/security/sfs/files/patch-async_qhash.h b/security/sfs/files/patch-async_qhash.h new file mode 100644 index 000000000000..9d94de278fc0 --- /dev/null +++ b/security/sfs/files/patch-async_qhash.h @@ -0,0 +1,11 @@ +--- async/qhash.h.orig Mon Oct 11 16:43:34 2004 ++++ async/qhash.h Mon Oct 11 16:39:35 2004 +@@ -166,7 +166,7 @@ + + public: + bhash () {} +- void clear () { deleteall (); } ++ void clear () { this->deleteall (); } + ~bhash () { clear (); } + + bool insert (const K &k) { diff --git a/security/sfs/files/patch-async_refcnt.h b/security/sfs/files/patch-async_refcnt.h new file mode 100644 index 000000000000..f555d6139779 --- /dev/null +++ b/security/sfs/files/patch-async_refcnt.h @@ -0,0 +1,118 @@ +--- async/refcnt.h.orig Mon Oct 11 16:43:34 2004 ++++ async/refcnt.h Mon Oct 11 16:39:35 2004 +@@ -409,7 +409,7 @@ + friend class refpriv; + + friend ref mkref (T *); +- ref (T *pp, refcount *cc) : refpriv (cc) { p = pp; inc (); } ++ ref (T *pp, refcount *cc) : refpriv (cc) { this->p = pp; inc (); } + + void inc () const { rinc (c); } + void dec () const { rdec (c); } +@@ -420,32 +420,32 @@ + + template + ref (refcounted *pp) +- : refpriv (rc (pp)) { p = refpriv::rp (pp); inc (); } ++ : refpriv (rc (pp)) { this->p = refpriv::rp (pp); inc (); } + /* At least with gcc, the copy constructor must be explicitly + * defined (though it would appear to be redundant given the + * template constructor bellow). */ +- ref (const ref &r) : refpriv (r.c) { p = r.p; inc (); } ++ ref (const ref &r) : refpriv (r.c) { this->p = r.p; inc (); } + template + ref (const ref &r) +- : refpriv (rc (r)) { p = refpriv::rp (r); inc (); } ++ : refpriv (rc (r)) { this->p = refpriv::rp (r); inc (); } + template + ref (const ::ptr &r) +- : refpriv (rc (r)) { p = refpriv::rp (r); inc (); } ++ : refpriv (rc (r)) { this->p = refpriv::rp (r); inc (); } + + ~ref () { dec (); } + + template ref &operator= (refcounted *pp) +- { rinc (pp); dec (); p = refpriv::rp (pp); c = rc (pp); return *this; } ++ { rinc (pp); dec (); this->p = refpriv::rp (pp); c = rc (pp); return *this; } + + /* The copy assignment operator must also explicitly be defined, + * despite a redundant template. */ + ref &operator= (const ref &r) +- { r.inc (); dec (); p = r.p; c = r.c; return *this; } ++ { r.inc (); dec (); this->p = r.p; c = r.c; return *this; } + template ref &operator= (const ref &r) +- { rinc (r); dec (); p = refpriv::rp (r); c = rc (r); return *this; } ++ { rinc (r); dec (); this->p = refpriv::rp (r); c = rc (r); return *this; } + /* Self asignment not possible. Use ref::inc to cause segfauls on NULL. */ + template ref &operator= (const ::ptr &r) +- { dec (); p = refpriv::rp (r); c = rc (r); inc (); return *this; } ++ { dec (); this->p = refpriv::rp (r); c = rc (r); inc (); return *this; } + }; + + /* To skip initialization of ptr's in BSS */ +@@ -464,13 +464,13 @@ + rinc (pp); + if (decme) + dec (); +- p = refpriv::rp (pp); ++ this->p = refpriv::rp (pp); + c = rc (pp); + } + else { + if (decme) + dec (); +- p = NULL; ++ this->p = NULL; + c = NULL; + } + } +@@ -480,31 +480,31 @@ + typedef ref ref; + + explicit ptr (__bss_init) {} +- ptr () : refpriv (NULL) { p = NULL; } +- ptr (privtype *) : refpriv (NULL) { p = NULL; } ++ ptr () : refpriv (NULL) { this->p = NULL; } ++ ptr (privtype *) : refpriv (NULL) { this->p = NULL; } + template + ptr (refcounted *pp) { set (pp, false); } +- ptr (const ptr &r) : refpriv (r.c) { p = r.p; inc (); } ++ ptr (const ptr &r) : refpriv (r.c) { this->p = r.p; inc (); } + template + ptr (const ptr &r) +- : refpriv (rc (r)) { p = refpriv::rp (r); inc (); } ++ : refpriv (rc (r)) { this->p = refpriv::rp (r); inc (); } + template + ptr (const ::ref &r) +- : refpriv (rc (r)) { p = refpriv::rp (r); inc (); } ++ : refpriv (rc (r)) { this->p = refpriv::rp (r); inc (); } + + ~ptr () { dec (); } + + ptr &operator= (privtype *) +- { dec (); p = NULL; c = NULL; return *this; } ++ { dec (); this->p = NULL; c = NULL; return *this; } + template ptr &operator= (refcounted *pp) + { set (pp, true); return *this; } + + ptr &operator= (const ptr &r) +- { r.inc (); dec (); p = r.p; c = r.c; return *this; } ++ { r.inc (); dec (); this->p = r.p; c = r.c; return *this; } + template ptr &operator= (const ptr &r) +- { rinc (r); dec (); p = refpriv::rp (r); c = rc (r); return *this; } ++ { rinc (r); dec (); this->p = refpriv::rp (r); c = rc (r); return *this; } + template ptr &operator= (const ::ref &r) +- { rinc (r); dec (); p = refpriv::rp (r); c = rc (r); return *this; } ++ { rinc (r); dec (); this->p = refpriv::rp (r); c = rc (r); return *this; } + }; + + template +@@ -512,7 +512,7 @@ + // Don't initialize (assume we were 0 initialized in the BSS) + bssptr () : ptr (__bss_init ()) {} + // Override the effects of destruction +- ~bssptr () { assert (globaldestruction); if (*this != NULL) Xleak (); } ++ ~bssptr () { assert (globaldestruction); if (*this != NULL) this->Xleak (); } + ptr &operator= (refpriv::privtype *p) { return ptr::operator= (p); } + template ptr &operator= (const ptr &r) + { return ptr::operator= (r); } diff --git a/security/sfs/files/patch-async_vec.h b/security/sfs/files/patch-async_vec.h new file mode 100644 index 000000000000..480173460e66 --- /dev/null +++ b/security/sfs/files/patch-async_vec.h @@ -0,0 +1,143 @@ +--- async/vec.h.orig Mon Oct 11 16:43:34 2004 ++++ async/vec.h Mon Oct 11 16:39:35 2004 +@@ -74,16 +74,16 @@ + template class vec : public vec_base { + typedef typename vec_base::elm_t elm_t; + void move (elm_t *dst) { +- if (dst == firstp) ++ if (dst == this->firstp) + return; +- assert (dst < firstp || dst >= lastp); +- basep = dst; +- for (elm_t *src = firstp; src < lastp; src++) { ++ assert (dst < this->firstp || dst >= this->lastp); ++ this->basep = dst; ++ for (elm_t *src = this->firstp; src < this->lastp; src++) { + new ((void *) (dst++)) elm_t (*src); + src->~elm_t (); + } +- lastp += basep - firstp; +- firstp = basep; ++ this->lastp += this->basep - this->firstp; ++ this->firstp = this->basep; + } + + static elm_t &construct (elm_t &e) +@@ -92,14 +92,14 @@ + { return *new (implicit_cast (&e)) elm_t (v); } + static void destroy (elm_t &e) { e.~elm_t (); } + +- void init () { lastp = firstp = basep = def_basep (); limp = def_limp (); } +- void del () { while (firstp < lastp) firstp++->~elm_t (); bfree (basep); } ++ void init () { this->lastp = this->firstp = this->basep = this->def_basep (); this->limp = this->def_limp (); } ++ void del () { while (this->firstp < this->lastp) (this->firstp)++->~elm_t (); bfree (this->basep); } + + #define append(v) \ + do { \ + reserve (v.size ()); \ + for (const elm_t *s = v.base (), *e = v.lim (); s < e; s++) \ +- cconstruct (*lastp++, *s); \ ++ cconstruct (*(this->lastp)++, *s); \ + } while (0) + + #ifdef CHECK_BOUNDS +@@ -125,19 +125,19 @@ + { clear (); append (v); return *this; } + + void reserve (size_t n) { +- if (lastp + n <= limp) ++ if (this->lastp + n <= this->limp) + return; +- size_t nalloc = limp - basep; +- size_t nwanted = lastp - firstp + n; ++ size_t nalloc = this->limp - this->basep; ++ size_t nwanted = this->lastp - this->firstp + n; + if (nwanted > nalloc / 2) { + nalloc = 1 << fls (max (nalloc, nwanted)); +- elm_t *obasep = basep; ++ elm_t *obasep = this->basep; + move (static_cast (txmalloc (nalloc * sizeof (elm_t)))); +- limp = basep + nalloc; ++ this->limp = this->basep + nalloc; + bfree (obasep); + } + else +- move (basep); ++ move (this->basep); + } + void setsize (size_t n) { + size_t s = size (); +@@ -145,47 +145,47 @@ + popn_back (s - n); + else if ((n -= s)) { + reserve (n); +- elm_t *sp = lastp; +- lastp += n; +- while (sp < lastp) ++ elm_t *sp = this->lastp; ++ this->lastp += n; ++ while (sp < this->lastp) + construct (*sp++); + } + } + +- elm_t *base () { return firstp; } +- const elm_t *base () const { return firstp; } +- elm_t *lim () { return lastp; } +- const elm_t *lim () const { return lastp; } +- size_t size () const { return lastp - firstp; } +- bool empty () const { return lastp == firstp; } +- +- elm_t &front () { zcheck (); return *firstp; } +- const elm_t &front () const { zcheck (); return *firstp; } +- elm_t &back () { zcheck (); return lastp[-1]; } +- const elm_t &back () const { zcheck (); return lastp[-1]; } ++ elm_t *base () { return this->firstp; } ++ const elm_t *base () const { return this->firstp; } ++ elm_t *lim () { return this->lastp; } ++ const elm_t *lim () const { return this->lastp; } ++ size_t size () const { return this->lastp - this->firstp; } ++ bool empty () const { return this->lastp == this->firstp; } ++ ++ elm_t &front () { zcheck (); return *(this->firstp); } ++ const elm_t &front () const { zcheck (); return *(this->firstp); } ++ elm_t &back () { zcheck (); return this->lastp[-1]; } ++ const elm_t &back () const { zcheck (); return this->lastp[-1]; } + +- elm_t &operator[] (ptrdiff_t i) { bcheck (i); return firstp[i]; } +- const elm_t &operator[] (ptrdiff_t i) const { bcheck (i); return firstp[i]; } ++ elm_t &operator[] (ptrdiff_t i) { bcheck (i); return this->firstp[i]; } ++ const elm_t &operator[] (ptrdiff_t i) const { bcheck (i); return this->firstp[i]; } + +- elm_t &push_back () { reserve (1); return construct (*lastp++); } ++ elm_t &push_back () { reserve (1); return construct (*(this->lastp)++); } + elm_t &push_back (const elm_t &e) +- { reserve (1); return cconstruct (*lastp++, e); } ++ { reserve (1); return cconstruct (*(this->lastp)++, e); } + +- elm_t pop_back () { zcheck (); return destroy_return (*--lastp); } ++ elm_t pop_back () { zcheck (); return destroy_return (*--(this->lastp)); } + void popn_back (size_t n) { + pcheck (n); +- elm_t *sp = lastp; +- lastp -= n; +- while (sp > lastp) ++ elm_t *sp = this->lastp; ++ this->lastp -= n; ++ while (sp > this->lastp) + destroy (*--sp); + } + +- elm_t pop_front () { zcheck (); return destroy_return (*firstp++); } ++ elm_t pop_front () { zcheck (); return destroy_return (*(this->firstp)++); } + void popn_front (size_t n) { + pcheck (n); +- elm_t *sp = firstp; +- firstp += n; +- while (sp < firstp) ++ elm_t *sp = this->firstp; ++ this->firstp += n; ++ while (sp < this->firstp) + destroy (*sp++); + } + diff --git a/security/sfs/files/patch-sfsmisc_afsnode.h b/security/sfs/files/patch-sfsmisc_afsnode.h new file mode 100644 index 000000000000..c3f81857d1f9 --- /dev/null +++ b/security/sfs/files/patch-sfsmisc_afsnode.h @@ -0,0 +1,11 @@ +--- sfsmisc/afsnode.h.orig Mon Oct 11 16:43:34 2004 ++++ sfsmisc/afsnode.h Mon Oct 11 16:39:35 2004 +@@ -168,7 +168,7 @@ + void mkfattr3 (fattr3 *, sfs_aid aid); + void setres (nfsstat err); + void setres (nfspath path); +- str readlink () const { return res.status ? str (NULL) : *res.data; } ++ str readlink () const { return res.status ? str (NULL) : str (*res.data); } + bool resset () { return resok; } + + void nfs_readlink (svccb *sbp); diff --git a/security/sfs/files/patch-sfsmisc_nfsserv.h b/security/sfs/files/patch-sfsmisc_nfsserv.h new file mode 100644 index 000000000000..adfd5d0ac68d --- /dev/null +++ b/security/sfs/files/patch-sfsmisc_nfsserv.h @@ -0,0 +1,42 @@ +--- sfsmisc/nfsserv.h.orig Mon Oct 11 16:43:34 2004 ++++ sfsmisc/nfsserv.h Mon Oct 11 16:39:35 2004 +@@ -110,6 +110,19 @@ + template T *getres () { return static_cast (getvoidres ()); } + }; + ++struct nfsserv : public virtual refcount { ++ typedef callback::ref cb_t; ++ static const cb_t stalecb; ++ cb_t cb; ++ const ptr nextserv; ++ explicit nfsserv (ptr n = NULL); ++ void setcb (const cb_t &c) { cb = c; } ++ void mkcb (nfscall *nc) { nc->curserv = this; (*cb) (nc); } ++ virtual void getcall (nfscall *nc) { mkcb (nc); } ++ virtual void getreply (nfscall *nc) { nc->sendreply (); } ++ virtual bool encodefh (nfs_fh3 &fh); ++}; ++ + template class nfscall_cb : public nfscall { + typedef typename nfs3proc::arg_type *arg_type; + typedef typename nfs3proc::res_type *res_type; +@@ -134,19 +147,6 @@ + svccb *sbp; + nfscall_rpc (svccb *sbp); + ~nfscall_rpc (); +-}; +- +-struct nfsserv : public virtual refcount { +- typedef callback::ref cb_t; +- static const cb_t stalecb; +- cb_t cb; +- const ptr nextserv; +- explicit nfsserv (ptr n = NULL); +- void setcb (const cb_t &c) { cb = c; } +- void mkcb (nfscall *nc) { nc->curserv = this; (*cb) (nc); } +- virtual void getcall (nfscall *nc) { mkcb (nc); } +- virtual void getreply (nfscall *nc) { nc->sendreply (); } +- virtual bool encodefh (nfs_fh3 &fh); + }; + + class nfsserv_udp : public nfsserv { diff --git a/security/sfs/files/patch-sfsmisc_sfsclient.h b/security/sfs/files/patch-sfsmisc_sfsclient.h new file mode 100644 index 000000000000..1893c8028714 --- /dev/null +++ b/security/sfs/files/patch-sfsmisc_sfsclient.h @@ -0,0 +1,10 @@ +--- sfsmisc/sfsclient.h.orig Mon Oct 11 16:43:34 2004 ++++ sfsmisc/sfsclient.h Mon Oct 11 16:39:35 2004 +@@ -31,6 +31,7 @@ + #include "qhash.h" + #include "axprt_crypt.h" + #include "sfscrypt.h" ++#include "sfscd_prot.h" + + struct sfscd_mountarg; + class rabin_priv; diff --git a/security/sfs/files/patch-sfsmisc_sfscrypt.h b/security/sfs/files/patch-sfsmisc_sfscrypt.h new file mode 100644 index 000000000000..e37ba1b3a8cd --- /dev/null +++ b/security/sfs/files/patch-sfsmisc_sfscrypt.h @@ -0,0 +1,10 @@ +--- sfsmisc/sfscrypt.h.orig Mon Oct 11 16:43:34 2004 ++++ sfsmisc/sfscrypt.h Mon Oct 11 16:39:35 2004 +@@ -89,7 +89,6 @@ + virtual u_char get_bad_opts () const { return (SFS_DECRYPT | SFS_SIGN); } + bool get_opt (u_char o) const { return (opts & o); } + const sfs_keytype ktype; +- const int eksb_id; + const u_char opts; + }; + -- cgit