From 9d2441df89afe55816d17e63c4391a31b11cdefe Mon Sep 17 00:00:00 2001 From: Marcin Juszkiewicz Date: Tue, 19 Mar 2013 15:05:21 +0100 Subject: libtirpc: add RPC parts from glibc - patches from OpenMandriva Signed-off-by: Marcin Juszkiewicz --- .../libtirpc/libtirpc-0.2.3/key_prot.h | 343 ++ ...ibtirpc-0.2.3-add-missing-bits-from-glibc.patch | 1766 ++++++ .../libtirpc-0.2.3/libtirpc-0.2.3-types.h.patch | 14 + ...Add-rpcgen-program-from-nfs-utils-sources.patch | 6408 ++++++++++++++++++++ .../recipes-extended/libtirpc/libtirpc-0.2.3/nis.h | 616 ++ .../libtirpc/libtirpc-0.2.3/nis_tags.h | 129 + .../libtirpc/libtirpc-0.2.3/nislib.h | 288 + .../libtirpc/libtirpc-0.2.3/rpc_des.h | 71 + .../libtirpc/libtirpc-0.2.3/yp_prot.h | 366 ++ .../libtirpc/libtirpc-0.2.3/ypclnt.h | 89 + meta/recipes-extended/libtirpc/libtirpc_0.2.3.bb | 35 +- 11 files changed, 10121 insertions(+), 4 deletions(-) create mode 100644 meta/recipes-extended/libtirpc/libtirpc-0.2.3/key_prot.h create mode 100644 meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0.2.3-add-missing-bits-from-glibc.patch create mode 100644 meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0.2.3-types.h.patch create mode 100644 meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0008-Add-rpcgen-program-from-nfs-utils-sources.patch create mode 100644 meta/recipes-extended/libtirpc/libtirpc-0.2.3/nis.h create mode 100644 meta/recipes-extended/libtirpc/libtirpc-0.2.3/nis_tags.h create mode 100644 meta/recipes-extended/libtirpc/libtirpc-0.2.3/nislib.h create mode 100644 meta/recipes-extended/libtirpc/libtirpc-0.2.3/rpc_des.h create mode 100644 meta/recipes-extended/libtirpc/libtirpc-0.2.3/yp_prot.h create mode 100644 meta/recipes-extended/libtirpc/libtirpc-0.2.3/ypclnt.h diff --git a/meta/recipes-extended/libtirpc/libtirpc-0.2.3/key_prot.h b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/key_prot.h new file mode 100644 index 0000000000..74627e66cc --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/key_prot.h @@ -0,0 +1,343 @@ +/* + * Please do not edit this file. + * It was generated using rpcgen. + */ + +#ifndef _KEY_PROT_H_RPCGEN +#define _KEY_PROT_H_RPCGEN + +#include + +/* Copyright (c) 2010, Oracle America, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials + * provided with the distribution. + * * Neither the name of the "Oracle America, Inc." nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Compiled from key_prot.x using rpcgen. + * DO NOT EDIT THIS FILE! + * This is NOT source code! + */ +#define PROOT 3 +#define HEXMODULUS "d4a0ba0250b6fd2ec626e7efd637df76c716e22d0944b88b" +#define HEXKEYBYTES 48 +#define KEYSIZE 192 +#define KEYBYTES 24 +#define KEYCHECKSUMSIZE 16 + +enum keystatus { + KEY_SUCCESS = 0, + KEY_NOSECRET = 1, + KEY_UNKNOWN = 2, + KEY_SYSTEMERR = 3, +}; +typedef enum keystatus keystatus; +#ifdef __cplusplus +extern "C" bool_t xdr_keystatus(XDR *, keystatus*); +#elif __STDC__ +extern bool_t xdr_keystatus(XDR *, keystatus*); +#else /* Old Style C */ +bool_t xdr_keystatus(); +#endif /* Old Style C */ + + +typedef char keybuf[HEXKEYBYTES]; +#ifdef __cplusplus +extern "C" bool_t xdr_keybuf(XDR *, keybuf); +#elif __STDC__ +extern bool_t xdr_keybuf(XDR *, keybuf); +#else /* Old Style C */ +bool_t xdr_keybuf(); +#endif /* Old Style C */ + + +typedef char *netnamestr; +#ifdef __cplusplus +extern "C" bool_t xdr_netnamestr(XDR *, netnamestr*); +#elif __STDC__ +extern bool_t xdr_netnamestr(XDR *, netnamestr*); +#else /* Old Style C */ +bool_t xdr_netnamestr(); +#endif /* Old Style C */ + + +struct cryptkeyarg { + netnamestr remotename; + des_block deskey; +}; +typedef struct cryptkeyarg cryptkeyarg; +#ifdef __cplusplus +extern "C" bool_t xdr_cryptkeyarg(XDR *, cryptkeyarg*); +#elif __STDC__ +extern bool_t xdr_cryptkeyarg(XDR *, cryptkeyarg*); +#else /* Old Style C */ +bool_t xdr_cryptkeyarg(); +#endif /* Old Style C */ + + +struct cryptkeyarg2 { + netnamestr remotename; + netobj remotekey; + des_block deskey; +}; +typedef struct cryptkeyarg2 cryptkeyarg2; +#ifdef __cplusplus +extern "C" bool_t xdr_cryptkeyarg2(XDR *, cryptkeyarg2*); +#elif __STDC__ +extern bool_t xdr_cryptkeyarg2(XDR *, cryptkeyarg2*); +#else /* Old Style C */ +bool_t xdr_cryptkeyarg2(); +#endif /* Old Style C */ + + +struct cryptkeyres { + keystatus status; + union { + des_block deskey; + } cryptkeyres_u; +}; +typedef struct cryptkeyres cryptkeyres; +#ifdef __cplusplus +extern "C" bool_t xdr_cryptkeyres(XDR *, cryptkeyres*); +#elif __STDC__ +extern bool_t xdr_cryptkeyres(XDR *, cryptkeyres*); +#else /* Old Style C */ +bool_t xdr_cryptkeyres(); +#endif /* Old Style C */ + +#define MAXGIDS 16 + +struct unixcred { + u_int uid; + u_int gid; + struct { + u_int gids_len; + u_int *gids_val; + } gids; +}; +typedef struct unixcred unixcred; +#ifdef __cplusplus +extern "C" bool_t xdr_unixcred(XDR *, unixcred*); +#elif __STDC__ +extern bool_t xdr_unixcred(XDR *, unixcred*); +#else /* Old Style C */ +bool_t xdr_unixcred(); +#endif /* Old Style C */ + + +struct getcredres { + keystatus status; + union { + unixcred cred; + } getcredres_u; +}; +typedef struct getcredres getcredres; +#ifdef __cplusplus +extern "C" bool_t xdr_getcredres(XDR *, getcredres*); +#elif __STDC__ +extern bool_t xdr_getcredres(XDR *, getcredres*); +#else /* Old Style C */ +bool_t xdr_getcredres(); +#endif /* Old Style C */ + + +struct key_netstarg { + keybuf st_priv_key; + keybuf st_pub_key; + netnamestr st_netname; +}; +typedef struct key_netstarg key_netstarg; +#ifdef __cplusplus +extern "C" bool_t xdr_key_netstarg(XDR *, key_netstarg*); +#elif __STDC__ +extern bool_t xdr_key_netstarg(XDR *, key_netstarg*); +#else /* Old Style C */ +bool_t xdr_key_netstarg(); +#endif /* Old Style C */ + + +struct key_netstres { + keystatus status; + union { + key_netstarg knet; + } key_netstres_u; +}; +typedef struct key_netstres key_netstres; +#ifdef __cplusplus +extern "C" bool_t xdr_key_netstres(XDR *, key_netstres*); +#elif __STDC__ +extern bool_t xdr_key_netstres(XDR *, key_netstres*); +#else /* Old Style C */ +bool_t xdr_key_netstres(); +#endif /* Old Style C */ + + +#ifndef opaque +#define opaque char +#endif + + +#define KEY_PROG ((u_long)100029) +#define KEY_VERS ((u_long)1) + +#ifdef __cplusplus +#define KEY_SET ((u_long)1) +extern "C" keystatus * key_set_1(opaque *, CLIENT *); +extern "C" keystatus * key_set_1_svc(opaque *, struct svc_req *); +#define KEY_ENCRYPT ((u_long)2) +extern "C" cryptkeyres * key_encrypt_1(cryptkeyarg *, CLIENT *); +extern "C" cryptkeyres * key_encrypt_1_svc(cryptkeyarg *, struct svc_req *); +#define KEY_DECRYPT ((u_long)3) +extern "C" cryptkeyres * key_decrypt_1(cryptkeyarg *, CLIENT *); +extern "C" cryptkeyres * key_decrypt_1_svc(cryptkeyarg *, struct svc_req *); +#define KEY_GEN ((u_long)4) +extern "C" des_block * key_gen_1(void *, CLIENT *); +extern "C" des_block * key_gen_1_svc(void *, struct svc_req *); +#define KEY_GETCRED ((u_long)5) +extern "C" getcredres * key_getcred_1(netnamestr *, CLIENT *); +extern "C" getcredres * key_getcred_1_svc(netnamestr *, struct svc_req *); + +#elif __STDC__ +#define KEY_SET ((u_long)1) +extern keystatus * key_set_1(opaque *, CLIENT *); +extern keystatus * key_set_1_svc(opaque *, struct svc_req *); +#define KEY_ENCRYPT ((u_long)2) +extern cryptkeyres * key_encrypt_1(cryptkeyarg *, CLIENT *); +extern cryptkeyres * key_encrypt_1_svc(cryptkeyarg *, struct svc_req *); +#define KEY_DECRYPT ((u_long)3) +extern cryptkeyres * key_decrypt_1(cryptkeyarg *, CLIENT *); +extern cryptkeyres * key_decrypt_1_svc(cryptkeyarg *, struct svc_req *); +#define KEY_GEN ((u_long)4) +extern des_block * key_gen_1(void *, CLIENT *); +extern des_block * key_gen_1_svc(void *, struct svc_req *); +#define KEY_GETCRED ((u_long)5) +extern getcredres * key_getcred_1(netnamestr *, CLIENT *); +extern getcredres * key_getcred_1_svc(netnamestr *, struct svc_req *); + +#else /* Old Style C */ +#define KEY_SET ((u_long)1) +extern keystatus * key_set_1(); +extern keystatus * key_set_1_svc(); +#define KEY_ENCRYPT ((u_long)2) +extern cryptkeyres * key_encrypt_1(); +extern cryptkeyres * key_encrypt_1_svc(); +#define KEY_DECRYPT ((u_long)3) +extern cryptkeyres * key_decrypt_1(); +extern cryptkeyres * key_decrypt_1_svc(); +#define KEY_GEN ((u_long)4) +extern des_block * key_gen_1(); +extern des_block * key_gen_1_svc(); +#define KEY_GETCRED ((u_long)5) +extern getcredres * key_getcred_1(); +extern getcredres * key_getcred_1_svc(); +#endif /* Old Style C */ +#define KEY_VERS2 ((u_long)2) + +#ifdef __cplusplus +extern "C" keystatus * key_set_2(opaque *, CLIENT *); +extern "C" keystatus * key_set_2_svc(opaque *, struct svc_req *); +extern "C" cryptkeyres * key_encrypt_2(cryptkeyarg *, CLIENT *); +extern "C" cryptkeyres * key_encrypt_2_svc(cryptkeyarg *, struct svc_req *); +extern "C" cryptkeyres * key_decrypt_2(cryptkeyarg *, CLIENT *); +extern "C" cryptkeyres * key_decrypt_2_svc(cryptkeyarg *, struct svc_req *); +extern "C" des_block * key_gen_2(void *, CLIENT *); +extern "C" des_block * key_gen_2_svc(void *, struct svc_req *); +extern "C" getcredres * key_getcred_2(netnamestr *, CLIENT *); +extern "C" getcredres * key_getcred_2_svc(netnamestr *, struct svc_req *); +#define KEY_ENCRYPT_PK ((u_long)6) +extern "C" cryptkeyres * key_encrypt_pk_2(cryptkeyarg2 *, CLIENT *); +extern "C" cryptkeyres * key_encrypt_pk_2_svc(cryptkeyarg2 *, struct svc_req *); +#define KEY_DECRYPT_PK ((u_long)7) +extern "C" cryptkeyres * key_decrypt_pk_2(cryptkeyarg2 *, CLIENT *); +extern "C" cryptkeyres * key_decrypt_pk_2_svc(cryptkeyarg2 *, struct svc_req *); +#define KEY_NET_PUT ((u_long)8) +extern "C" keystatus * key_net_put_2(key_netstarg *, CLIENT *); +extern "C" keystatus * key_net_put_2_svc(key_netstarg *, struct svc_req *); +#define KEY_NET_GET ((u_long)9) +extern "C" key_netstres * key_net_get_2(void *, CLIENT *); +extern "C" key_netstres * key_net_get_2_svc(void *, struct svc_req *); +#define KEY_GET_CONV ((u_long)10) +extern "C" cryptkeyres * key_get_conv_2(opaque *, CLIENT *); +extern "C" cryptkeyres * key_get_conv_2_svc(opaque *, struct svc_req *); + +#elif __STDC__ +extern keystatus * key_set_2(opaque *, CLIENT *); +extern keystatus * key_set_2_svc(opaque *, struct svc_req *); +extern cryptkeyres * key_encrypt_2(cryptkeyarg *, CLIENT *); +extern cryptkeyres * key_encrypt_2_svc(cryptkeyarg *, struct svc_req *); +extern cryptkeyres * key_decrypt_2(cryptkeyarg *, CLIENT *); +extern cryptkeyres * key_decrypt_2_svc(cryptkeyarg *, struct svc_req *); +extern des_block * key_gen_2(void *, CLIENT *); +extern des_block * key_gen_2_svc(void *, struct svc_req *); +extern getcredres * key_getcred_2(netnamestr *, CLIENT *); +extern getcredres * key_getcred_2_svc(netnamestr *, struct svc_req *); +#define KEY_ENCRYPT_PK ((u_long)6) +extern cryptkeyres * key_encrypt_pk_2(cryptkeyarg2 *, CLIENT *); +extern cryptkeyres * key_encrypt_pk_2_svc(cryptkeyarg2 *, struct svc_req *); +#define KEY_DECRYPT_PK ((u_long)7) +extern cryptkeyres * key_decrypt_pk_2(cryptkeyarg2 *, CLIENT *); +extern cryptkeyres * key_decrypt_pk_2_svc(cryptkeyarg2 *, struct svc_req *); +#define KEY_NET_PUT ((u_long)8) +extern keystatus * key_net_put_2(key_netstarg *, CLIENT *); +extern keystatus * key_net_put_2_svc(key_netstarg *, struct svc_req *); +#define KEY_NET_GET ((u_long)9) +extern key_netstres * key_net_get_2(void *, CLIENT *); +extern key_netstres * key_net_get_2_svc(void *, struct svc_req *); +#define KEY_GET_CONV ((u_long)10) +extern cryptkeyres * key_get_conv_2(opaque *, CLIENT *); +extern cryptkeyres * key_get_conv_2_svc(opaque *, struct svc_req *); + +#else /* Old Style C */ +extern keystatus * key_set_2(); +extern keystatus * key_set_2_svc(); +extern cryptkeyres * key_encrypt_2(); +extern cryptkeyres * key_encrypt_2_svc(); +extern cryptkeyres * key_decrypt_2(); +extern cryptkeyres * key_decrypt_2_svc(); +extern des_block * key_gen_2(); +extern des_block * key_gen_2_svc(); +extern getcredres * key_getcred_2(); +extern getcredres * key_getcred_2_svc(); +#define KEY_ENCRYPT_PK ((u_long)6) +extern cryptkeyres * key_encrypt_pk_2(); +extern cryptkeyres * key_encrypt_pk_2_svc(); +#define KEY_DECRYPT_PK ((u_long)7) +extern cryptkeyres * key_decrypt_pk_2(); +extern cryptkeyres * key_decrypt_pk_2_svc(); +#define KEY_NET_PUT ((u_long)8) +extern keystatus * key_net_put_2(); +extern keystatus * key_net_put_2_svc(); +#define KEY_NET_GET ((u_long)9) +extern key_netstres * key_net_get_2(); +extern key_netstres * key_net_get_2_svc(); +#define KEY_GET_CONV ((u_long)10) +extern cryptkeyres * key_get_conv_2(); +extern cryptkeyres * key_get_conv_2_svc(); +#endif /* Old Style C */ + +#endif /* !_KEY_PROT_H_RPCGEN */ diff --git a/meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0.2.3-add-missing-bits-from-glibc.patch b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0.2.3-add-missing-bits-from-glibc.patch new file mode 100644 index 0000000000..43a093b8d6 --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0.2.3-add-missing-bits-from-glibc.patch @@ -0,0 +1,1766 @@ +diff -urN libtirpc-0.2.3/src/des_crypt.c libtirpc-0.2.3.new/src/des_crypt.c +--- libtirpc-0.2.3/src/des_crypt.c 2013-02-13 16:13:59.000000000 +0100 ++++ libtirpc-0.2.3.new/src/des_crypt.c 2013-03-19 12:24:24.368923058 +0100 +@@ -1,66 +1,60 @@ + /* +- * Copyright (c) 2009, Sun Microsystems, Inc. +- * All rights reserved. ++ * des_crypt.c, DES encryption library routines ++ * Copyright (c) 2010, Oracle America, Inc. ++ * Adaption to work inside tirpc rather than glibc ++ * (c) 2012 Bernhard Rosenkraenzer + * + * Redistribution and use in source and binary forms, with or without +- * modification, are permitted provided that the following conditions are met: +- * - Redistributions of source code must retain the above copyright notice, +- * this list of conditions and the following disclaimer. +- * - Redistributions in binary form must reproduce the above copyright notice, +- * this list of conditions and the following disclaimer in the documentation +- * and/or other materials provided with the distribution. +- * - Neither the name of Sun Microsystems, Inc. nor the names of its +- * contributors may be used to endorse or promote products derived +- * from this software without specific prior written permission. ++ * modification, are permitted provided that the following conditions are ++ * met: + * +- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +- * POSSIBILITY OF SUCH DAMAGE. +- */ +-/* +- * des_crypt.c, DES encryption library routines +- * Copyright (C) 1986, Sun Microsystems, Inc. ++ * * Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * * Redistributions in binary form must reproduce the above ++ * copyright notice, this list of conditions and the following ++ * disclaimer in the documentation and/or other materials ++ * provided with the distribution. ++ * * Neither the name of the "Oracle America, Inc." nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ++ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ++ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, ++ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE ++ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, ++ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING ++ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + #include +-#include + #include +-#include +-#if 0 +-#ifndef lint +-static char sccsid[] = "@(#)des_crypt.c 2.2 88/08/10 4.0 RPCSRC; from 1.13 88/02/08 SMI"; +-#endif +-#endif +-#include +- +-static int common_crypt( char *, char *, unsigned, unsigned, struct desparams * ); +-int (*__des_crypt_LOCAL)() = 0; +-extern int _des_crypt_call(char *, int, struct desparams *); ++#include ++ ++extern int _des_crypt (char *, unsigned, struct desparams *); ++ + /* + * Copy 8 bytes + */ + #define COPY8(src, dst) { \ +- char *a = (char *) dst; \ +- char *b = (char *) src; \ ++ register char *a = (char *) dst; \ ++ register char *b = (char *) src; \ + *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \ + *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \ + } +- ++ + /* + * Copy multiple of 8 bytes + */ + #define DESCOPY(src, dst, len) { \ +- char *a = (char *) dst; \ +- char *b = (char *) src; \ +- int i; \ ++ register char *a = (char *) dst; \ ++ register char *b = (char *) src; \ ++ register int i; \ + for (i = (int) len; i > 0; i -= 8) { \ + *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \ + *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \ +@@ -68,87 +62,56 @@ + } + + /* +- * CBC mode encryption ++ * Common code to cbc_crypt() & ecb_crypt() + */ +-int +-cbc_crypt(key, buf, len, mode, ivec) +- char *key; +- char *buf; +- unsigned len; +- unsigned mode; +- char *ivec; ++static int ++common_crypt (char *key, char *buf, register unsigned len, ++ unsigned mode, register struct desparams *desp) + { +- int err; +- struct desparams dp; ++ register int desdev; + +-#ifdef BROKEN_DES +- dp.UDES.UDES_buf = buf; +- dp.des_mode = ECB; +-#else +- dp.des_mode = CBC; +-#endif +- COPY8(ivec, dp.des_ivec); +- err = common_crypt(key, buf, len, mode, &dp); +- COPY8(dp.des_ivec, ivec); +- return(err); +-} ++ if ((len % 8) != 0 || len > DES_MAXDATA) ++ return DESERR_BADPARAM; ++ ++ desp->des_dir = ++ ((mode & DES_DIRMASK) == DES_ENCRYPT) ? ENCRYPT : DECRYPT; ++ ++ desdev = mode & DES_DEVMASK; ++ COPY8 (key, desp->des_key); ++ /* ++ * software ++ */ ++ if (!_des_crypt (buf, len, desp)) ++ return DESERR_HWERROR; + ++ return desdev == DES_SW ? DESERR_NONE : DESERR_NOHWDEVICE; ++} + + /* +- * ECB mode encryption ++ * CBC mode encryption + */ + int +-ecb_crypt(key, buf, len, mode) +- char *key; +- char *buf; +- unsigned len; +- unsigned mode; ++cbc_crypt (char *key, char *buf, unsigned int len, unsigned int mode, ++ char *ivec) + { +- struct desparams dp; ++ int err; ++ struct desparams dp; + +-#ifdef BROKEN_DES +- dp.UDES.UDES_buf = buf; +- dp.des_mode = CBC; +-#else +- dp.des_mode = ECB; +-#endif +- return(common_crypt(key, buf, len, mode, &dp)); ++ dp.des_mode = CBC; ++ COPY8 (ivec, dp.des_ivec); ++ err = common_crypt (key, buf, len, mode, &dp); ++ COPY8 (dp.des_ivec, ivec); ++ return err; + } + +- +- + /* +- * Common code to cbc_crypt() & ecb_crypt() ++ * ECB mode encryption + */ +-static int +-common_crypt(key, buf, len, mode, desp) +- char *key; +- char *buf; +- unsigned len; +- unsigned mode; +- struct desparams *desp; ++int ++ecb_crypt (char *key, char *buf, unsigned int len, unsigned int mode) + { +- int desdev; ++ struct desparams dp; + +- if ((len % 8) != 0 || len > DES_MAXDATA) { +- return(DESERR_BADPARAM); +- } +- desp->des_dir = +- ((mode & DES_DIRMASK) == DES_ENCRYPT) ? ENCRYPT : DECRYPT; +- +- desdev = mode & DES_DEVMASK; +- COPY8(key, desp->des_key); +- /* +- * software +- */ +- if (__des_crypt_LOCAL != NULL) { +- if (!__des_crypt_LOCAL(buf, len, desp)) { +- return (DESERR_HWERROR); +- } +- } else { +- if (!_des_crypt_call(buf, len, desp)) { +- return (DESERR_HWERROR); +- } +- } +- return(desdev == DES_SW ? DESERR_NONE : DESERR_NOHWDEVICE); ++ dp.des_mode = ECB; ++ return common_crypt (key, buf, len, mode, &dp); + } +diff -urN libtirpc-0.2.3/src/des_impl.c libtirpc-0.2.3.new/src/des_impl.c +--- libtirpc-0.2.3/src/des_impl.c 1970-01-01 01:00:00.000000000 +0100 ++++ libtirpc-0.2.3.new/src/des_impl.c 2013-03-19 12:24:24.368923058 +0100 +@@ -0,0 +1,593 @@ ++/* Copyright (C) 1992 Eric Young */ ++/* Collected from libdes and modified for SECURE RPC by Martin Kuck 1994 */ ++/* This file is distributed under the terms of the GNU Lesser General */ ++/* Public License, version 2.1 or later - see the file COPYING.LIB for details.*/ ++/* If you did not receive a copy of the license with this program, please*/ ++/* see to obtain a copy. */ ++#include ++#include ++#include ++ ++ ++static const uint32_t des_SPtrans[8][64] = ++{ ++ { /* nibble 0 */ ++ 0x00820200, 0x00020000, 0x80800000, 0x80820200, ++ 0x00800000, 0x80020200, 0x80020000, 0x80800000, ++ 0x80020200, 0x00820200, 0x00820000, 0x80000200, ++ 0x80800200, 0x00800000, 0x00000000, 0x80020000, ++ 0x00020000, 0x80000000, 0x00800200, 0x00020200, ++ 0x80820200, 0x00820000, 0x80000200, 0x00800200, ++ 0x80000000, 0x00000200, 0x00020200, 0x80820000, ++ 0x00000200, 0x80800200, 0x80820000, 0x00000000, ++ 0x00000000, 0x80820200, 0x00800200, 0x80020000, ++ 0x00820200, 0x00020000, 0x80000200, 0x00800200, ++ 0x80820000, 0x00000200, 0x00020200, 0x80800000, ++ 0x80020200, 0x80000000, 0x80800000, 0x00820000, ++ 0x80820200, 0x00020200, 0x00820000, 0x80800200, ++ 0x00800000, 0x80000200, 0x80020000, 0x00000000, ++ 0x00020000, 0x00800000, 0x80800200, 0x00820200, ++ 0x80000000, 0x80820000, 0x00000200, 0x80020200}, ++ ++ { /* nibble 1 */ ++ 0x10042004, 0x00000000, 0x00042000, 0x10040000, ++ 0x10000004, 0x00002004, 0x10002000, 0x00042000, ++ 0x00002000, 0x10040004, 0x00000004, 0x10002000, ++ 0x00040004, 0x10042000, 0x10040000, 0x00000004, ++ 0x00040000, 0x10002004, 0x10040004, 0x00002000, ++ 0x00042004, 0x10000000, 0x00000000, 0x00040004, ++ 0x10002004, 0x00042004, 0x10042000, 0x10000004, ++ 0x10000000, 0x00040000, 0x00002004, 0x10042004, ++ 0x00040004, 0x10042000, 0x10002000, 0x00042004, ++ 0x10042004, 0x00040004, 0x10000004, 0x00000000, ++ 0x10000000, 0x00002004, 0x00040000, 0x10040004, ++ 0x00002000, 0x10000000, 0x00042004, 0x10002004, ++ 0x10042000, 0x00002000, 0x00000000, 0x10000004, ++ 0x00000004, 0x10042004, 0x00042000, 0x10040000, ++ 0x10040004, 0x00040000, 0x00002004, 0x10002000, ++ 0x10002004, 0x00000004, 0x10040000, 0x00042000}, ++ ++ { /* nibble 2 */ ++ 0x41000000, 0x01010040, 0x00000040, 0x41000040, ++ 0x40010000, 0x01000000, 0x41000040, 0x00010040, ++ 0x01000040, 0x00010000, 0x01010000, 0x40000000, ++ 0x41010040, 0x40000040, 0x40000000, 0x41010000, ++ 0x00000000, 0x40010000, 0x01010040, 0x00000040, ++ 0x40000040, 0x41010040, 0x00010000, 0x41000000, ++ 0x41010000, 0x01000040, 0x40010040, 0x01010000, ++ 0x00010040, 0x00000000, 0x01000000, 0x40010040, ++ 0x01010040, 0x00000040, 0x40000000, 0x00010000, ++ 0x40000040, 0x40010000, 0x01010000, 0x41000040, ++ 0x00000000, 0x01010040, 0x00010040, 0x41010000, ++ 0x40010000, 0x01000000, 0x41010040, 0x40000000, ++ 0x40010040, 0x41000000, 0x01000000, 0x41010040, ++ 0x00010000, 0x01000040, 0x41000040, 0x00010040, ++ 0x01000040, 0x00000000, 0x41010000, 0x40000040, ++ 0x41000000, 0x40010040, 0x00000040, 0x01010000}, ++ ++ { /* nibble 3 */ ++ 0x00100402, 0x04000400, 0x00000002, 0x04100402, ++ 0x00000000, 0x04100000, 0x04000402, 0x00100002, ++ 0x04100400, 0x04000002, 0x04000000, 0x00000402, ++ 0x04000002, 0x00100402, 0x00100000, 0x04000000, ++ 0x04100002, 0x00100400, 0x00000400, 0x00000002, ++ 0x00100400, 0x04000402, 0x04100000, 0x00000400, ++ 0x00000402, 0x00000000, 0x00100002, 0x04100400, ++ 0x04000400, 0x04100002, 0x04100402, 0x00100000, ++ 0x04100002, 0x00000402, 0x00100000, 0x04000002, ++ 0x00100400, 0x04000400, 0x00000002, 0x04100000, ++ 0x04000402, 0x00000000, 0x00000400, 0x00100002, ++ 0x00000000, 0x04100002, 0x04100400, 0x00000400, ++ 0x04000000, 0x04100402, 0x00100402, 0x00100000, ++ 0x04100402, 0x00000002, 0x04000400, 0x00100402, ++ 0x00100002, 0x00100400, 0x04100000, 0x04000402, ++ 0x00000402, 0x04000000, 0x04000002, 0x04100400}, ++ ++ { /* nibble 4 */ ++ 0x02000000, 0x00004000, 0x00000100, 0x02004108, ++ 0x02004008, 0x02000100, 0x00004108, 0x02004000, ++ 0x00004000, 0x00000008, 0x02000008, 0x00004100, ++ 0x02000108, 0x02004008, 0x02004100, 0x00000000, ++ 0x00004100, 0x02000000, 0x00004008, 0x00000108, ++ 0x02000100, 0x00004108, 0x00000000, 0x02000008, ++ 0x00000008, 0x02000108, 0x02004108, 0x00004008, ++ 0x02004000, 0x00000100, 0x00000108, 0x02004100, ++ 0x02004100, 0x02000108, 0x00004008, 0x02004000, ++ 0x00004000, 0x00000008, 0x02000008, 0x02000100, ++ 0x02000000, 0x00004100, 0x02004108, 0x00000000, ++ 0x00004108, 0x02000000, 0x00000100, 0x00004008, ++ 0x02000108, 0x00000100, 0x00000000, 0x02004108, ++ 0x02004008, 0x02004100, 0x00000108, 0x00004000, ++ 0x00004100, 0x02004008, 0x02000100, 0x00000108, ++ 0x00000008, 0x00004108, 0x02004000, 0x02000008}, ++ ++ { /* nibble 5 */ ++ 0x20000010, 0x00080010, 0x00000000, 0x20080800, ++ 0x00080010, 0x00000800, 0x20000810, 0x00080000, ++ 0x00000810, 0x20080810, 0x00080800, 0x20000000, ++ 0x20000800, 0x20000010, 0x20080000, 0x00080810, ++ 0x00080000, 0x20000810, 0x20080010, 0x00000000, ++ 0x00000800, 0x00000010, 0x20080800, 0x20080010, ++ 0x20080810, 0x20080000, 0x20000000, 0x00000810, ++ 0x00000010, 0x00080800, 0x00080810, 0x20000800, ++ 0x00000810, 0x20000000, 0x20000800, 0x00080810, ++ 0x20080800, 0x00080010, 0x00000000, 0x20000800, ++ 0x20000000, 0x00000800, 0x20080010, 0x00080000, ++ 0x00080010, 0x20080810, 0x00080800, 0x00000010, ++ 0x20080810, 0x00080800, 0x00080000, 0x20000810, ++ 0x20000010, 0x20080000, 0x00080810, 0x00000000, ++ 0x00000800, 0x20000010, 0x20000810, 0x20080800, ++ 0x20080000, 0x00000810, 0x00000010, 0x20080010}, ++ ++ { /* nibble 6 */ ++ 0x00001000, 0x00000080, 0x00400080, 0x00400001, ++ 0x00401081, 0x00001001, 0x00001080, 0x00000000, ++ 0x00400000, 0x00400081, 0x00000081, 0x00401000, ++ 0x00000001, 0x00401080, 0x00401000, 0x00000081, ++ 0x00400081, 0x00001000, 0x00001001, 0x00401081, ++ 0x00000000, 0x00400080, 0x00400001, 0x00001080, ++ 0x00401001, 0x00001081, 0x00401080, 0x00000001, ++ 0x00001081, 0x00401001, 0x00000080, 0x00400000, ++ 0x00001081, 0x00401000, 0x00401001, 0x00000081, ++ 0x00001000, 0x00000080, 0x00400000, 0x00401001, ++ 0x00400081, 0x00001081, 0x00001080, 0x00000000, ++ 0x00000080, 0x00400001, 0x00000001, 0x00400080, ++ 0x00000000, 0x00400081, 0x00400080, 0x00001080, ++ 0x00000081, 0x00001000, 0x00401081, 0x00400000, ++ 0x00401080, 0x00000001, 0x00001001, 0x00401081, ++ 0x00400001, 0x00401080, 0x00401000, 0x00001001}, ++ ++ { /* nibble 7 */ ++ 0x08200020, 0x08208000, 0x00008020, 0x00000000, ++ 0x08008000, 0x00200020, 0x08200000, 0x08208020, ++ 0x00000020, 0x08000000, 0x00208000, 0x00008020, ++ 0x00208020, 0x08008020, 0x08000020, 0x08200000, ++ 0x00008000, 0x00208020, 0x00200020, 0x08008000, ++ 0x08208020, 0x08000020, 0x00000000, 0x00208000, ++ 0x08000000, 0x00200000, 0x08008020, 0x08200020, ++ 0x00200000, 0x00008000, 0x08208000, 0x00000020, ++ 0x00200000, 0x00008000, 0x08000020, 0x08208020, ++ 0x00008020, 0x08000000, 0x00000000, 0x00208000, ++ 0x08200020, 0x08008020, 0x08008000, 0x00200020, ++ 0x08208000, 0x00000020, 0x00200020, 0x08008000, ++ 0x08208020, 0x00200000, 0x08200000, 0x08000020, ++ 0x00208000, 0x00008020, 0x08008020, 0x08200000, ++ 0x00000020, 0x08208000, 0x00208020, 0x00000000, ++ 0x08000000, 0x08200020, 0x00008000, 0x00208020}}; ++ ++static const uint32_t des_skb[8][64] = ++{ ++ { /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */ ++ 0x00000000, 0x00000010, 0x20000000, 0x20000010, ++ 0x00010000, 0x00010010, 0x20010000, 0x20010010, ++ 0x00000800, 0x00000810, 0x20000800, 0x20000810, ++ 0x00010800, 0x00010810, 0x20010800, 0x20010810, ++ 0x00000020, 0x00000030, 0x20000020, 0x20000030, ++ 0x00010020, 0x00010030, 0x20010020, 0x20010030, ++ 0x00000820, 0x00000830, 0x20000820, 0x20000830, ++ 0x00010820, 0x00010830, 0x20010820, 0x20010830, ++ 0x00080000, 0x00080010, 0x20080000, 0x20080010, ++ 0x00090000, 0x00090010, 0x20090000, 0x20090010, ++ 0x00080800, 0x00080810, 0x20080800, 0x20080810, ++ 0x00090800, 0x00090810, 0x20090800, 0x20090810, ++ 0x00080020, 0x00080030, 0x20080020, 0x20080030, ++ 0x00090020, 0x00090030, 0x20090020, 0x20090030, ++ 0x00080820, 0x00080830, 0x20080820, 0x20080830, ++ 0x00090820, 0x00090830, 0x20090820, 0x20090830}, ++ { /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */ ++ 0x00000000, 0x02000000, 0x00002000, 0x02002000, ++ 0x00200000, 0x02200000, 0x00202000, 0x02202000, ++ 0x00000004, 0x02000004, 0x00002004, 0x02002004, ++ 0x00200004, 0x02200004, 0x00202004, 0x02202004, ++ 0x00000400, 0x02000400, 0x00002400, 0x02002400, ++ 0x00200400, 0x02200400, 0x00202400, 0x02202400, ++ 0x00000404, 0x02000404, 0x00002404, 0x02002404, ++ 0x00200404, 0x02200404, 0x00202404, 0x02202404, ++ 0x10000000, 0x12000000, 0x10002000, 0x12002000, ++ 0x10200000, 0x12200000, 0x10202000, 0x12202000, ++ 0x10000004, 0x12000004, 0x10002004, 0x12002004, ++ 0x10200004, 0x12200004, 0x10202004, 0x12202004, ++ 0x10000400, 0x12000400, 0x10002400, 0x12002400, ++ 0x10200400, 0x12200400, 0x10202400, 0x12202400, ++ 0x10000404, 0x12000404, 0x10002404, 0x12002404, ++ 0x10200404, 0x12200404, 0x10202404, 0x12202404}, ++ { /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */ ++ 0x00000000, 0x00000001, 0x00040000, 0x00040001, ++ 0x01000000, 0x01000001, 0x01040000, 0x01040001, ++ 0x00000002, 0x00000003, 0x00040002, 0x00040003, ++ 0x01000002, 0x01000003, 0x01040002, 0x01040003, ++ 0x00000200, 0x00000201, 0x00040200, 0x00040201, ++ 0x01000200, 0x01000201, 0x01040200, 0x01040201, ++ 0x00000202, 0x00000203, 0x00040202, 0x00040203, ++ 0x01000202, 0x01000203, 0x01040202, 0x01040203, ++ 0x08000000, 0x08000001, 0x08040000, 0x08040001, ++ 0x09000000, 0x09000001, 0x09040000, 0x09040001, ++ 0x08000002, 0x08000003, 0x08040002, 0x08040003, ++ 0x09000002, 0x09000003, 0x09040002, 0x09040003, ++ 0x08000200, 0x08000201, 0x08040200, 0x08040201, ++ 0x09000200, 0x09000201, 0x09040200, 0x09040201, ++ 0x08000202, 0x08000203, 0x08040202, 0x08040203, ++ 0x09000202, 0x09000203, 0x09040202, 0x09040203}, ++ { /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */ ++ 0x00000000, 0x00100000, 0x00000100, 0x00100100, ++ 0x00000008, 0x00100008, 0x00000108, 0x00100108, ++ 0x00001000, 0x00101000, 0x00001100, 0x00101100, ++ 0x00001008, 0x00101008, 0x00001108, 0x00101108, ++ 0x04000000, 0x04100000, 0x04000100, 0x04100100, ++ 0x04000008, 0x04100008, 0x04000108, 0x04100108, ++ 0x04001000, 0x04101000, 0x04001100, 0x04101100, ++ 0x04001008, 0x04101008, 0x04001108, 0x04101108, ++ 0x00020000, 0x00120000, 0x00020100, 0x00120100, ++ 0x00020008, 0x00120008, 0x00020108, 0x00120108, ++ 0x00021000, 0x00121000, 0x00021100, 0x00121100, ++ 0x00021008, 0x00121008, 0x00021108, 0x00121108, ++ 0x04020000, 0x04120000, 0x04020100, 0x04120100, ++ 0x04020008, 0x04120008, 0x04020108, 0x04120108, ++ 0x04021000, 0x04121000, 0x04021100, 0x04121100, ++ 0x04021008, 0x04121008, 0x04021108, 0x04121108}, ++ { /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */ ++ 0x00000000, 0x10000000, 0x00010000, 0x10010000, ++ 0x00000004, 0x10000004, 0x00010004, 0x10010004, ++ 0x20000000, 0x30000000, 0x20010000, 0x30010000, ++ 0x20000004, 0x30000004, 0x20010004, 0x30010004, ++ 0x00100000, 0x10100000, 0x00110000, 0x10110000, ++ 0x00100004, 0x10100004, 0x00110004, 0x10110004, ++ 0x20100000, 0x30100000, 0x20110000, 0x30110000, ++ 0x20100004, 0x30100004, 0x20110004, 0x30110004, ++ 0x00001000, 0x10001000, 0x00011000, 0x10011000, ++ 0x00001004, 0x10001004, 0x00011004, 0x10011004, ++ 0x20001000, 0x30001000, 0x20011000, 0x30011000, ++ 0x20001004, 0x30001004, 0x20011004, 0x30011004, ++ 0x00101000, 0x10101000, 0x00111000, 0x10111000, ++ 0x00101004, 0x10101004, 0x00111004, 0x10111004, ++ 0x20101000, 0x30101000, 0x20111000, 0x30111000, ++ 0x20101004, 0x30101004, 0x20111004, 0x30111004}, ++ { /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */ ++ 0x00000000, 0x08000000, 0x00000008, 0x08000008, ++ 0x00000400, 0x08000400, 0x00000408, 0x08000408, ++ 0x00020000, 0x08020000, 0x00020008, 0x08020008, ++ 0x00020400, 0x08020400, 0x00020408, 0x08020408, ++ 0x00000001, 0x08000001, 0x00000009, 0x08000009, ++ 0x00000401, 0x08000401, 0x00000409, 0x08000409, ++ 0x00020001, 0x08020001, 0x00020009, 0x08020009, ++ 0x00020401, 0x08020401, 0x00020409, 0x08020409, ++ 0x02000000, 0x0A000000, 0x02000008, 0x0A000008, ++ 0x02000400, 0x0A000400, 0x02000408, 0x0A000408, ++ 0x02020000, 0x0A020000, 0x02020008, 0x0A020008, ++ 0x02020400, 0x0A020400, 0x02020408, 0x0A020408, ++ 0x02000001, 0x0A000001, 0x02000009, 0x0A000009, ++ 0x02000401, 0x0A000401, 0x02000409, 0x0A000409, ++ 0x02020001, 0x0A020001, 0x02020009, 0x0A020009, ++ 0x02020401, 0x0A020401, 0x02020409, 0x0A020409}, ++ { /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */ ++ 0x00000000, 0x00000100, 0x00080000, 0x00080100, ++ 0x01000000, 0x01000100, 0x01080000, 0x01080100, ++ 0x00000010, 0x00000110, 0x00080010, 0x00080110, ++ 0x01000010, 0x01000110, 0x01080010, 0x01080110, ++ 0x00200000, 0x00200100, 0x00280000, 0x00280100, ++ 0x01200000, 0x01200100, 0x01280000, 0x01280100, ++ 0x00200010, 0x00200110, 0x00280010, 0x00280110, ++ 0x01200010, 0x01200110, 0x01280010, 0x01280110, ++ 0x00000200, 0x00000300, 0x00080200, 0x00080300, ++ 0x01000200, 0x01000300, 0x01080200, 0x01080300, ++ 0x00000210, 0x00000310, 0x00080210, 0x00080310, ++ 0x01000210, 0x01000310, 0x01080210, 0x01080310, ++ 0x00200200, 0x00200300, 0x00280200, 0x00280300, ++ 0x01200200, 0x01200300, 0x01280200, 0x01280300, ++ 0x00200210, 0x00200310, 0x00280210, 0x00280310, ++ 0x01200210, 0x01200310, 0x01280210, 0x01280310}, ++ { /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */ ++ 0x00000000, 0x04000000, 0x00040000, 0x04040000, ++ 0x00000002, 0x04000002, 0x00040002, 0x04040002, ++ 0x00002000, 0x04002000, 0x00042000, 0x04042000, ++ 0x00002002, 0x04002002, 0x00042002, 0x04042002, ++ 0x00000020, 0x04000020, 0x00040020, 0x04040020, ++ 0x00000022, 0x04000022, 0x00040022, 0x04040022, ++ 0x00002020, 0x04002020, 0x00042020, 0x04042020, ++ 0x00002022, 0x04002022, 0x00042022, 0x04042022, ++ 0x00000800, 0x04000800, 0x00040800, 0x04040800, ++ 0x00000802, 0x04000802, 0x00040802, 0x04040802, ++ 0x00002800, 0x04002800, 0x00042800, 0x04042800, ++ 0x00002802, 0x04002802, 0x00042802, 0x04042802, ++ 0x00000820, 0x04000820, 0x00040820, 0x04040820, ++ 0x00000822, 0x04000822, 0x00040822, 0x04040822, ++ 0x00002820, 0x04002820, 0x00042820, 0x04042820, ++ 0x00002822, 0x04002822, 0x00042822, 0x04042822}, ++}; ++ ++#define c2l(c,l) (l =((unsigned long)(*((c)++))) , \ ++ l|=((unsigned long)(*((c)++)))<< 8, \ ++ l|=((unsigned long)(*((c)++)))<<16, \ ++ l|=((unsigned long)(*((c)++)))<<24) ++ ++#define l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \ ++ *((c)++)=(unsigned char)(((l)>> 8)&0xff), \ ++ *((c)++)=(unsigned char)(((l)>>16)&0xff), \ ++ *((c)++)=(unsigned char)(((l)>>24)&0xff)) ++ ++/* ++ * IP and FP ++ * The problem is more of a geometric problem that random bit fiddling. ++ * 0 1 2 3 4 5 6 7 62 54 46 38 30 22 14 6 ++ * 8 9 10 11 12 13 14 15 60 52 44 36 28 20 12 4 ++ * 16 17 18 19 20 21 22 23 58 50 42 34 26 18 10 2 ++ * 24 25 26 27 28 29 30 31 to 56 48 40 32 24 16 8 0 ++ * ++ * 32 33 34 35 36 37 38 39 63 55 47 39 31 23 15 7 ++ * 40 41 42 43 44 45 46 47 61 53 45 37 29 21 13 5 ++ * 48 49 50 51 52 53 54 55 59 51 43 35 27 19 11 3 ++ * 56 57 58 59 60 61 62 63 57 49 41 33 25 17 9 1 ++ * ++ * The output has been subject to swaps of the form ++ * 0 1 -> 3 1 but the odd and even bits have been put into ++ * 2 3 2 0 ++ * different words. The main trick is to remember that ++ * t=((l>>size)^r)&(mask); ++ * r^=t; ++ * l^=(t<>(n))^(b))&(m)),\ ++ (b)^=(t),\ ++ (a)^=((t)<<(n))) ++ ++#define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\ ++ (a)=(a)^(t)^(t>>(16-(n)))) ++ ++ ++#define D_ENCRYPT(L,R,S) \ ++ u=(R^s[S ]); \ ++ t=R^s[S+1]; \ ++ t=((t>>4)+(t<<28)); \ ++ L^= des_SPtrans[1][(t )&0x3f]| \ ++ des_SPtrans[3][(t>> 8)&0x3f]| \ ++ des_SPtrans[5][(t>>16)&0x3f]| \ ++ des_SPtrans[7][(t>>24)&0x3f]| \ ++ des_SPtrans[0][(u )&0x3f]| \ ++ des_SPtrans[2][(u>> 8)&0x3f]| \ ++ des_SPtrans[4][(u>>16)&0x3f]| \ ++ des_SPtrans[6][(u>>24)&0x3f]; ++ ++#define ITERATIONS 16 ++ ++static const char shifts2[16] = ++{0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0}; ++ ++static void des_set_key (unsigned char *, unsigned long *); ++static void des_encrypt (unsigned long *, unsigned long *, int); ++int _des_crypt (char *, unsigned, struct desparams *); ++ ++static void ++des_set_key (unsigned char *key, unsigned long *schedule) ++{ ++ register unsigned long c, d, t, s; ++ register unsigned char *in; ++ register unsigned long *k; ++ register int i; ++ ++ k = (unsigned long *) schedule; ++ in = key; ++ ++ c2l (in, c); ++ c2l (in, d); ++ ++ /* I now do it in 47 simple operations :-) ++ * Thanks to John Fletcher (john_fletcher@lccmail.ocf.llnl.gov) ++ * for the inspiration. :-) */ ++ PERM_OP (d, c, t, 4, 0x0f0f0f0f); ++ HPERM_OP (c, t, -2, 0xcccc0000); ++ HPERM_OP (d, t, -2, 0xcccc0000); ++ PERM_OP (d, c, t, 1, 0x55555555); ++ PERM_OP (c, d, t, 8, 0x00ff00ff); ++ PERM_OP (d, c, t, 1, 0x55555555); ++ d = (((d & 0x000000ff) << 16) | (d & 0x0000ff00) | ++ ((d & 0x00ff0000) >> 16) | ((c & 0xf0000000) >> 4)); ++ c &= 0x0fffffff; ++ ++ for (i = 0; i < ITERATIONS; i++) ++ { ++ if (shifts2[i]) ++ { ++ c = ((c >> 2) | (c << 26)); ++ d = ((d >> 2) | (d << 26)); ++ } ++ else ++ { ++ c = ((c >> 1) | (c << 27)); ++ d = ((d >> 1) | (d << 27)); ++ } ++ c &= 0x0fffffff; ++ d &= 0x0fffffff; ++ /* could be a few less shifts but I am to lazy at this ++ * point in time to investigate */ ++ s = des_skb[0][(c) & 0x3f] | ++ des_skb[1][((c >> 6) & 0x03) | ((c >> 7) & 0x3c)] | ++ des_skb[2][((c >> 13) & 0x0f) | ((c >> 14) & 0x30)] | ++ des_skb[3][((c >> 20) & 0x01) | ((c >> 21) & 0x06) | ((c >> 22) & 0x38)]; ++ t = des_skb[4][(d) & 0x3f] | ++ des_skb[5][((d >> 7) & 0x03) | ((d >> 8) & 0x3c)] | ++ des_skb[6][(d >> 15) & 0x3f] | ++ des_skb[7][((d >> 21) & 0x0f) | ((d >> 22) & 0x30)]; ++ ++ /* table contained 0213 4657 */ ++ *(k++) = ((t << 16) | (s & 0x0000ffff)) & 0xffffffff; ++ s = ((s >> 16) | (t & 0xffff0000)); ++ ++ s = (s << 4) | (s >> 28); ++ *(k++) = s & 0xffffffff; ++ } ++} ++ ++ ++static void ++des_encrypt (unsigned long *buf, unsigned long *schedule, int encrypt) ++{ ++ register unsigned long l, r, t, u; ++ register int i; ++ register unsigned long *s; ++ ++ l = buf[0]; ++ r = buf[1]; ++ ++ /* do IP */ ++ PERM_OP (r, l, t, 4, 0x0f0f0f0f); ++ PERM_OP (l, r, t, 16, 0x0000ffff); ++ PERM_OP (r, l, t, 2, 0x33333333); ++ PERM_OP (l, r, t, 8, 0x00ff00ff); ++ PERM_OP (r, l, t, 1, 0x55555555); ++ /* r and l are reversed - remember that :-) - fix ++ * it in the next step */ ++ ++ /* Things have been modified so that the initial rotate is ++ * done outside the loop. This required the ++ * des_SPtrans values in sp.h to be rotated 1 bit to the right. ++ * One perl script later and things have a 5% speed up on a sparc2. ++ * Thanks to Richard Outerbridge <71755.204@CompuServe.COM> ++ * for pointing this out. */ ++ t = (r << 1) | (r >> 31); ++ r = (l << 1) | (l >> 31); ++ l = t; ++ ++ /* clear the top bits on machines with 8byte longs */ ++ l &= 0xffffffff; ++ r &= 0xffffffff; ++ ++ s = (unsigned long *) schedule; ++ /* I don't know if it is worth the effort of loop unrolling the ++ * inner loop */ ++ if (encrypt) ++ { ++ for (i = 0; i < 32; i += 4) ++ { ++ D_ENCRYPT (l, r, i + 0); /* 1 */ ++ D_ENCRYPT (r, l, i + 2); /* 2 */ ++ } ++ } ++ else ++ { ++ for (i = 30; i > 0; i -= 4) ++ { ++ D_ENCRYPT (l, r, i - 0); /* 16 */ ++ D_ENCRYPT (r, l, i - 2); /* 15 */ ++ } ++ } ++ l = (l >> 1) | (l << 31); ++ r = (r >> 1) | (r << 31); ++ /* clear the top bits on machines with 8byte longs */ ++ l &= 0xffffffff; ++ r &= 0xffffffff; ++ ++ /* swap l and r ++ * we will not do the swap so just remember they are ++ * reversed for the rest of the subroutine ++ * luckily FP fixes this problem :-) */ ++ ++ PERM_OP (r, l, t, 1, 0x55555555); ++ PERM_OP (l, r, t, 8, 0x00ff00ff); ++ PERM_OP (r, l, t, 2, 0x33333333); ++ PERM_OP (l, r, t, 16, 0x0000ffff); ++ PERM_OP (r, l, t, 4, 0x0f0f0f0f); ++ ++ buf[0] = l; ++ buf[1] = r; ++ ++ l = r = t = u = 0; ++} ++ ++ ++int ++_des_crypt (char *buf, unsigned len, struct desparams *desp) ++{ ++ unsigned long schedule[32]; ++ register unsigned long tin0, tin1; ++ register unsigned long tout0, tout1, xor0, xor1; ++ register unsigned char *in, *out; ++ unsigned long tbuf[2]; ++ unsigned char *iv, *oiv; ++ int cbc_mode; ++ ++ cbc_mode = (desp->des_mode == CBC) ? 1 : 0; ++ ++ in = (unsigned char *) buf; ++ out = (unsigned char *) buf; ++ oiv = iv = (unsigned char *) desp->des_ivec; ++ ++ des_set_key (desp->des_key, schedule); ++ ++ tin0 = tin1 = 0; /* For GCC */ ++ if (desp->des_dir == ENCRYPT) ++ { ++ c2l (iv, tout0); ++ c2l (iv, tout1); ++ for (; len > 0; len -= 8) ++ { ++ c2l (in, tin0); ++ c2l (in, tin1); ++ if (cbc_mode) ++ { ++ tin0 ^= tout0; ++ tin1 ^= tout1; ++ } ++ tbuf[0] = tin0; ++ tbuf[1] = tin1; ++ des_encrypt (tbuf, schedule, 1); ++ tout0 = tbuf[0]; ++ tout1 = tbuf[1]; ++ l2c (tout0, out); ++ l2c (tout1, out); ++ } ++ l2c (tout0, oiv); ++ l2c (tout1, oiv); ++ } ++ else ++ { ++ c2l (iv, xor0); ++ c2l (iv, xor1); ++ for (; len > 0; len -= 8) ++ { ++ c2l (in, tin0); ++ c2l (in, tin1); ++ tbuf[0] = tin0; ++ tbuf[1] = tin1; ++ des_encrypt (tbuf, schedule, 0); ++ if (cbc_mode) ++ { ++ tout0 = tbuf[0] ^ xor0; ++ tout1 = tbuf[1] ^ xor1; ++ xor0 = tin0; ++ xor1 = tin1; ++ } ++ else ++ { ++ tout0 = tbuf[0]; ++ tout1 = tbuf[1]; ++ } ++ l2c (tout0, out); ++ l2c (tout1, out); ++ } ++ l2c (tin0, oiv); ++ l2c (tin1, oiv); ++ } ++ tin0 = tin1 = tout0 = tout1 = xor0 = xor1 = 0; ++ tbuf[0] = tbuf[1] = 0; ++ __bzero (schedule, sizeof (schedule)); ++ ++ return (1); ++} +diff -urN libtirpc-0.2.3/src/key_call.c libtirpc-0.2.3.new/src/key_call.c +--- libtirpc-0.2.3/src/key_call.c 2013-02-13 16:13:59.000000000 +0100 ++++ libtirpc-0.2.3.new/src/key_call.c 2013-03-19 12:24:24.368923058 +0100 +@@ -1,452 +1,551 @@ + /* +- * Copyright (c) 2009, Sun Microsystems, Inc. +- * All rights reserved. ++ * Copyright (c) 2010, Oracle America, Inc. + * + * Redistribution and use in source and binary forms, with or without +- * modification, are permitted provided that the following conditions are met: +- * - Redistributions of source code must retain the above copyright notice, +- * this list of conditions and the following disclaimer. +- * - Redistributions in binary form must reproduce the above copyright notice, +- * this list of conditions and the following disclaimer in the documentation +- * and/or other materials provided with the distribution. +- * - Neither the name of Sun Microsystems, Inc. nor the names of its +- * contributors may be used to endorse or promote products derived +- * from this software without specific prior written permission. ++ * modification, are permitted provided that the following conditions are ++ * met: + * +- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +- * POSSIBILITY OF SUCH DAMAGE. ++ * * Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * * Redistributions in binary form must reproduce the above ++ * copyright notice, this list of conditions and the following ++ * disclaimer in the documentation and/or other materials ++ * provided with the distribution. ++ * * Neither the name of the "Oracle America, Inc." nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ++ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ++ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, ++ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE ++ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, ++ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING ++ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + /* +- * Copyright (c) 1986-1991 by Sun Microsystems Inc. ++ * The original source is from the RPCSRC 4.0 package from Sun Microsystems. ++ * The Interface to keyserver protocoll 2, RPC over AF_UNIX and Linux/doors ++ * was added by Thorsten Kukuk ++ * Since the Linux/doors project was stopped, I doubt that this code will ++ * ever be useful . + */ + +- +-#include +- +-/* +- * key_call.c, Interface to keyserver +- * +- * setsecretkey(key) - set your secret key +- * encryptsessionkey(agent, deskey) - encrypt a session key to talk to agent +- * decryptsessionkey(agent, deskey) - decrypt ditto +- * gendeskey(deskey) - generate a secure des key +- */ +- +-#include +-#include + #include +-#include +-#include + #include ++#include ++#include ++#include ++#include + #include + #include +-#include +-#include +-#include +-#include +-#include +-#include +-#include + #include +-#include ++#include ++#include ++#include ++#include + ++#define KEY_TIMEOUT 5 /* per-try timeout in seconds */ ++#define KEY_NRETRY 12 /* number of retries */ + +-#define KEY_TIMEOUT 5 /* per-try timeout in seconds */ +-#define KEY_NRETRY 12 /* number of retries */ ++#define debug(msg) /* turn off debugging */ + +-#ifdef DEBUG +-#define debug(msg) (void) fprintf(stderr, "%s\n", msg); +-#else +-#define debug(msg) +-#endif /* DEBUG */ ++#ifndef SO_PASSCRED ++extern int _openchild (const char *command, FILE **fto, FILE **ffrom); ++#endif + +-/* +- * Hack to allow the keyserver to use AUTH_DES (for authenticated +- * NIS+ calls, for example). The only functions that get called +- * are key_encryptsession_pk, key_decryptsession_pk, and key_gendes. +- * +- * The approach is to have the keyserver fill in pointers to local +- * implementations of these functions, and to call those in key_call(). +- */ ++static int key_call (u_long, xdrproc_t xdr_arg, char *, ++ xdrproc_t xdr_rslt, char *); + +-cryptkeyres *(*__key_encryptsession_pk_LOCAL)() = 0; +-cryptkeyres *(*__key_decryptsession_pk_LOCAL)() = 0; +-des_block *(*__key_gendes_LOCAL)() = 0; +- +-static int key_call( u_long, xdrproc_t, void *, xdrproc_t, void *); ++static const struct timeval trytimeout = {KEY_TIMEOUT, 0}; ++static const struct timeval tottimeout = {KEY_TIMEOUT *KEY_NRETRY, 0}; + + int +-key_setsecret(secretkey) +- const char *secretkey; ++key_setsecret (const char *secretkey) + { +- keystatus status; ++ keystatus status; + +- if (!key_call((u_long) KEY_SET, (xdrproc_t)xdr_keybuf, +- (void *)secretkey, +- (xdrproc_t)xdr_keystatus, &status)) { +- return (-1); +- } +- if (status != KEY_SUCCESS) { +- debug("set status is nonzero"); +- return (-1); +- } +- return (0); ++ if (!key_call ((u_long) KEY_SET, (xdrproc_t) xdr_keybuf, secretkey, ++ (xdrproc_t) xdr_keystatus, (char *) &status)) ++ return -1; ++ if (status != KEY_SUCCESS) ++ { ++ debug ("set status is nonzero"); ++ return -1; ++ } ++ return 0; + } + +- + /* key_secretkey_is_set() returns 1 if the keyserver has a secret key + * stored for the caller's effective uid; it returns 0 otherwise + * + * N.B.: The KEY_NET_GET key call is undocumented. Applications shouldn't + * be using it, because it allows them to get the user's secret key. + */ +- + int +-key_secretkey_is_set(void) ++key_secretkey_is_set (void) + { +- struct key_netstres kres; ++ struct key_netstres kres; + +- memset((void*)&kres, 0, sizeof (kres)); +- if (key_call((u_long) KEY_NET_GET, (xdrproc_t)xdr_void, NULL, +- (xdrproc_t)xdr_key_netstres, &kres) && +- (kres.status == KEY_SUCCESS) && +- (kres.key_netstres_u.knet.st_priv_key[0] != 0)) { +- /* avoid leaving secret key in memory */ +- memset(kres.key_netstres_u.knet.st_priv_key, 0, HEXKEYBYTES); +- return (1); +- } +- return (0); ++ memset (&kres, 0, sizeof (kres)); ++ if (key_call ((u_long) KEY_NET_GET, (xdrproc_t) xdr_void, ++ (char *) NULL, (xdrproc_t) xdr_key_netstres, ++ (char *) &kres) && ++ (kres.status == KEY_SUCCESS) && ++ (kres.key_netstres_u.knet.st_priv_key[0] != 0)) ++ { ++ /* avoid leaving secret key in memory */ ++ memset (kres.key_netstres_u.knet.st_priv_key, 0, HEXKEYBYTES); ++ return 1; ++ } ++ return 0; + } + + int +-key_encryptsession_pk(remotename, remotekey, deskey) +- char *remotename; +- netobj *remotekey; +- des_block *deskey; +-{ +- cryptkeyarg2 arg; +- cryptkeyres res; +- +- arg.remotename = remotename; +- arg.remotekey = *remotekey; +- arg.deskey = *deskey; +- if (!key_call((u_long)KEY_ENCRYPT_PK, (xdrproc_t)xdr_cryptkeyarg2, &arg, +- (xdrproc_t)xdr_cryptkeyres, &res)) { +- return (-1); +- } +- if (res.status != KEY_SUCCESS) { +- debug("encrypt status is nonzero"); +- return (-1); +- } +- *deskey = res.cryptkeyres_u.deskey; +- return (0); +-} ++key_encryptsession (const char *remotename, des_block *deskey) ++{ ++ cryptkeyarg arg; ++ cryptkeyres res; + +-int +-key_decryptsession_pk(remotename, remotekey, deskey) +- char *remotename; +- netobj *remotekey; +- des_block *deskey; +-{ +- cryptkeyarg2 arg; +- cryptkeyres res; +- +- arg.remotename = remotename; +- arg.remotekey = *remotekey; +- arg.deskey = *deskey; +- if (!key_call((u_long)KEY_DECRYPT_PK, (xdrproc_t)xdr_cryptkeyarg2, &arg, +- (xdrproc_t)xdr_cryptkeyres, &res)) { +- return (-1); +- } +- if (res.status != KEY_SUCCESS) { +- debug("decrypt status is nonzero"); +- return (-1); +- } +- *deskey = res.cryptkeyres_u.deskey; +- return (0); ++ arg.remotename = remotename; ++ arg.deskey = *deskey; ++ if (!key_call ((u_long) KEY_ENCRYPT, (xdrproc_t) xdr_cryptkeyarg, ++ (char *) &arg, (xdrproc_t) xdr_cryptkeyres, ++ (char *) &res)) ++ return -1; ++ ++ if (res.status != KEY_SUCCESS) ++ { ++ debug ("encrypt status is nonzero"); ++ return -1; ++ } ++ *deskey = res.cryptkeyres_u.deskey; ++ return 0; + } + + int +-key_encryptsession(remotename, deskey) +- const char *remotename; +- des_block *deskey; +-{ +- cryptkeyarg arg; +- cryptkeyres res; +- +- arg.remotename = (char *) remotename; +- arg.deskey = *deskey; +- if (!key_call((u_long)KEY_ENCRYPT, (xdrproc_t)xdr_cryptkeyarg, &arg, +- (xdrproc_t)xdr_cryptkeyres, &res)) { +- return (-1); +- } +- if (res.status != KEY_SUCCESS) { +- debug("encrypt status is nonzero"); +- return (-1); +- } +- *deskey = res.cryptkeyres_u.deskey; +- return (0); ++key_decryptsession (const char *remotename, des_block *deskey) ++{ ++ cryptkeyarg arg; ++ cryptkeyres res; ++ ++ arg.remotename = remotename; ++ arg.deskey = *deskey; ++ if (!key_call ((u_long) KEY_DECRYPT, (xdrproc_t) xdr_cryptkeyarg, ++ (char *) &arg, (xdrproc_t) xdr_cryptkeyres, ++ (char *) &res)) ++ return -1; ++ if (res.status != KEY_SUCCESS) ++ { ++ debug ("decrypt status is nonzero"); ++ return -1; ++ } ++ *deskey = res.cryptkeyres_u.deskey; ++ return 0; + } + + int +-key_decryptsession(remotename, deskey) +- const char *remotename; +- des_block *deskey; +-{ +- cryptkeyarg arg; +- cryptkeyres res; +- +- arg.remotename = (char *) remotename; +- arg.deskey = *deskey; +- if (!key_call((u_long)KEY_DECRYPT, (xdrproc_t)xdr_cryptkeyarg, &arg, +- (xdrproc_t)xdr_cryptkeyres, &res)) { +- return (-1); +- } +- if (res.status != KEY_SUCCESS) { +- debug("decrypt status is nonzero"); +- return (-1); +- } +- *deskey = res.cryptkeyres_u.deskey; +- return (0); ++key_encryptsession_pk (char *remotename, netobj *remotekey, ++ des_block *deskey) ++{ ++ cryptkeyarg2 arg; ++ cryptkeyres res; ++ ++ arg.remotename = remotename; ++ arg.remotekey = *remotekey; ++ arg.deskey = *deskey; ++ if (!key_call ((u_long) KEY_ENCRYPT_PK, (xdrproc_t) xdr_cryptkeyarg2, ++ (char *) &arg, (xdrproc_t) xdr_cryptkeyres, ++ (char *) &res)) ++ return -1; ++ ++ if (res.status != KEY_SUCCESS) ++ { ++ debug ("encrypt status is nonzero"); ++ return -1; ++ } ++ *deskey = res.cryptkeyres_u.deskey; ++ return 0; + } + + int +-key_gendes(key) +- des_block *key; ++key_decryptsession_pk (char *remotename, netobj *remotekey, ++ des_block *deskey) + { +- if (!key_call((u_long)KEY_GEN, (xdrproc_t)xdr_void, NULL, +- (xdrproc_t)xdr_des_block, key)) { +- return (-1); +- } +- return (0); ++ cryptkeyarg2 arg; ++ cryptkeyres res; ++ ++ arg.remotename = remotename; ++ arg.remotekey = *remotekey; ++ arg.deskey = *deskey; ++ if (!key_call ((u_long) KEY_DECRYPT_PK, (xdrproc_t) xdr_cryptkeyarg2, ++ (char *) &arg, (xdrproc_t) xdr_cryptkeyres, ++ (char *) &res)) ++ return -1; ++ ++ if (res.status != KEY_SUCCESS) ++ { ++ debug ("decrypt status is nonzero"); ++ return -1; ++ } ++ *deskey = res.cryptkeyres_u.deskey; ++ return 0; + } + + int +-key_setnet(arg) +-struct key_netstarg *arg; ++key_gendes (des_block *key) + { +- keystatus status; ++ struct sockaddr_in sin; ++ CLIENT *client; ++ int socket; ++ enum clnt_stat stat; ++ ++ sin.sin_family = AF_INET; ++ sin.sin_port = 0; ++ sin.sin_addr.s_addr = htonl (INADDR_LOOPBACK); ++ __bzero (sin.sin_zero, sizeof (sin.sin_zero)); ++ socket = RPC_ANYSOCK; ++ client = clntudp_bufcreate (&sin, (u_long) KEY_PROG, (u_long) KEY_VERS, ++ trytimeout, &socket, RPCSMALLMSGSIZE, ++ RPCSMALLMSGSIZE); ++ if (client == NULL) ++ return -1; ++ ++ stat = clnt_call (client, KEY_GEN, (xdrproc_t) xdr_void, NULL, ++ (xdrproc_t) xdr_des_block, (caddr_t) key, ++ tottimeout); ++ clnt_destroy (client); ++ close (socket); ++ if (stat != RPC_SUCCESS) ++ return -1; + ++ return 0; ++} + +- if (!key_call((u_long) KEY_NET_PUT, (xdrproc_t)xdr_key_netstarg, arg, +- (xdrproc_t)xdr_keystatus, &status)){ +- return (-1); +- } ++int ++key_setnet (struct key_netstarg *arg) ++{ ++ keystatus status; + +- if (status != KEY_SUCCESS) { +- debug("key_setnet status is nonzero"); +- return (-1); +- } +- return (1); ++ if (!key_call ((u_long) KEY_NET_PUT, (xdrproc_t) xdr_key_netstarg, ++ (char *) arg,(xdrproc_t) xdr_keystatus, ++ (char *) &status)) ++ return -1; ++ ++ if (status != KEY_SUCCESS) ++ { ++ debug ("key_setnet status is nonzero"); ++ return -1; ++ } ++ return 1; + } + +- + int +-key_get_conv(pkey, deskey) +- char *pkey; +- des_block *deskey; +-{ +- cryptkeyres res; +- +- if (!key_call((u_long) KEY_GET_CONV, (xdrproc_t)xdr_keybuf, pkey, +- (xdrproc_t)xdr_cryptkeyres, &res)) { +- return (-1); +- } +- if (res.status != KEY_SUCCESS) { +- debug("get_conv status is nonzero"); +- return (-1); +- } +- *deskey = res.cryptkeyres_u.deskey; +- return (0); ++key_get_conv (char *pkey, des_block *deskey) ++{ ++ cryptkeyres res; ++ ++ if (!key_call ((u_long) KEY_GET_CONV, (xdrproc_t) xdr_keybuf, pkey, ++ (xdrproc_t) xdr_cryptkeyres, (char *) &res)) ++ return -1; ++ ++ if (res.status != KEY_SUCCESS) ++ { ++ debug ("get_conv status is nonzero"); ++ return -1; ++ } ++ *deskey = res.cryptkeyres_u.deskey; ++ return 0; + } + +-struct key_call_private { +- CLIENT *client; /* Client handle */ +- pid_t pid; /* process-id at moment of creation */ +- uid_t uid; /* user-id at last authorization */ +-}; +-static struct key_call_private *key_call_private_main = NULL; ++/* ++ * Hack to allow the keyserver to use AUTH_DES (for authenticated ++ * NIS+ calls, for example). The only functions that get called ++ * are key_encryptsession_pk, key_decryptsession_pk, and key_gendes. ++ * ++ * The approach is to have the keyserver fill in pointers to local ++ * implementations of these functions, and to call those in key_call(). ++ */ ++ ++cryptkeyres *(*__key_encryptsession_pk_LOCAL) (uid_t, char *); ++cryptkeyres *(*__key_decryptsession_pk_LOCAL) (uid_t, char *); ++des_block *(*__key_gendes_LOCAL) (uid_t, char *); + +-static void +-key_call_destroy(void *vp) ++#ifndef SO_PASSCRED ++static int ++key_call_keyenvoy (u_long proc, xdrproc_t xdr_arg, char *arg, ++ xdrproc_t xdr_rslt, char *rslt) + { +- struct key_call_private *kcp = (struct key_call_private *)vp; ++ XDR xdrargs; ++ XDR xdrrslt; ++ FILE *fargs; ++ FILE *frslt; ++ sigset_t oldmask, mask; ++ union wait status; ++ int pid; ++ int success; ++ uid_t ruid; ++ uid_t euid; ++ static const char MESSENGER[] = "/usr/etc/keyenvoy"; ++ ++ success = 1; ++ sigemptyset (&mask); ++ sigaddset (&mask, SIGCHLD); ++ __sigprocmask (SIG_BLOCK, &mask, &oldmask); ++ ++ /* ++ * We are going to exec a set-uid program which makes our effective uid ++ * zero, and authenticates us with our real uid. We need to make the ++ * effective uid be the real uid for the setuid program, and ++ * the real uid be the effective uid so that we can change things back. ++ */ ++ euid = geteuid (); ++ ruid = getuid (); ++ __setreuid (euid, ruid); ++ pid = _openchild (MESSENGER, &fargs, &frslt); ++ __setreuid (ruid, euid); ++ if (pid < 0) ++ { ++ debug ("open_streams"); ++ __sigprocmask (SIG_SETMASK, &oldmask, NULL); ++ return (0); ++ } ++ xdrstdio_create (&xdrargs, fargs, XDR_ENCODE); ++ xdrstdio_create (&xdrrslt, frslt, XDR_DECODE); ++ ++ if (!xdr_u_long (&xdrargs, &proc) || !(*xdr_arg) (&xdrargs, arg)) ++ { ++ debug ("xdr args"); ++ success = 0; ++ } ++ fclose (fargs); ++ ++ if (success && !(*xdr_rslt) (&xdrrslt, rslt)) ++ { ++ debug ("xdr rslt"); ++ success = 0; ++ } ++ fclose(frslt); ++ ++ wait_again: ++ if (__wait4 (pid, &status, 0, NULL) < 0) ++ { ++ if (errno == EINTR) ++ goto wait_again; ++ debug ("wait4"); ++ if (errno == ECHILD || errno == ESRCH) ++ perror ("wait"); ++ else ++ success = 0; ++ } ++ else ++ if (status.w_retcode) ++ { ++ debug ("wait4 1"); ++ success = 0; ++ } ++ __sigprocmask (SIG_SETMASK, &oldmask, NULL); + +- if (kcp) { +- if (kcp->client) +- clnt_destroy(kcp->client); +- free(kcp); +- } ++ return success; + } ++#endif ++ ++struct key_call_private { ++ CLIENT *client; /* Client handle */ ++ pid_t pid; /* process-id at moment of creation */ ++ uid_t uid; /* user-id at last authorization */ ++}; ++#ifdef _RPC_THREAD_SAFE_ ++#define key_call_private_main RPC_THREAD_VARIABLE(key_call_private_s) ++#else ++static struct key_call_private *key_call_private_main; ++#endif + + /* + * Keep the handle cached. This call may be made quite often. + */ + static CLIENT * +-getkeyserv_handle(vers) +-int vers; ++getkeyserv_handle (int vers) + { +- void *localhandle; +- struct netconfig *nconf; +- struct netconfig *tpconf; +- struct key_call_private *kcp = key_call_private_main; +- struct timeval wait_time; +- struct utsname u; +- int fd; +- extern thread_key_t key_call_key; +- extern mutex_t tsd_lock; +- +-#define TOTAL_TIMEOUT 30 /* total timeout talking to keyserver */ +-#define TOTAL_TRIES 5 /* Number of tries */ +- +- if (key_call_key == -1) { +- mutex_lock(&tsd_lock); +- if (key_call_key == -1) +- thr_keycreate(&key_call_key, key_call_destroy); +- mutex_unlock(&tsd_lock); +- } +- kcp = (struct key_call_private *)thr_getspecific(key_call_key); +- if (kcp == (struct key_call_private *)NULL) { +- kcp = (struct key_call_private *)malloc(sizeof (*kcp)); +- if (kcp == (struct key_call_private *)NULL) { +- return ((CLIENT *) NULL); +- } +- thr_setspecific(key_call_key, (void *) kcp); +- kcp->client = NULL; +- } ++ struct key_call_private *kcp = key_call_private_main; ++ struct timeval wait_time; ++ int fd; ++ struct sockaddr_un name; ++ socklen_t namelen = sizeof(struct sockaddr_un); ++ ++#define TOTAL_TIMEOUT 30 /* total timeout talking to keyserver */ ++#define TOTAL_TRIES 5 /* Number of tries */ ++ ++ if (kcp == (struct key_call_private *)NULL) ++ { ++ kcp = (struct key_call_private *)malloc (sizeof (*kcp)); ++ if (kcp == (struct key_call_private *)NULL) ++ return (CLIENT *) NULL; ++ ++ key_call_private_main = kcp; ++ kcp->client = NULL; ++ } ++ ++ /* if pid has changed, destroy client and rebuild */ ++ if (kcp->client != NULL && kcp->pid != getpid ()) ++ { ++ auth_destroy (kcp->client->cl_auth); ++ clnt_destroy (kcp->client); ++ kcp->client = NULL; ++ } ++ ++ if (kcp->client != NULL) ++ { ++ /* if other side closed socket, build handle again */ ++ clnt_control (kcp->client, CLGET_FD, (char *)&fd); ++ if (getpeername (fd,(struct sockaddr *)&name,&namelen) == -1) ++ { ++ auth_destroy (kcp->client->cl_auth); ++ clnt_destroy (kcp->client); ++ kcp->client = NULL; ++ } ++ } ++ ++ if (kcp->client != NULL) ++ { ++ /* if uid has changed, build client handle again */ ++ if (kcp->uid != geteuid ()) ++ { ++ kcp->uid = geteuid (); ++ auth_destroy (kcp->client->cl_auth); ++ kcp->client->cl_auth = ++ authunix_create ((char *)"", kcp->uid, 0, 0, NULL); ++ if (kcp->client->cl_auth == NULL) ++ { ++ clnt_destroy (kcp->client); ++ kcp->client = NULL; ++ return ((CLIENT *) NULL); ++ } ++ } ++ /* Change the version number to the new one */ ++ clnt_control (kcp->client, CLSET_VERS, (void *)&vers); ++ return kcp->client; ++ } ++ ++ if ((kcp->client == (CLIENT *) NULL)) ++ /* Use the AF_UNIX transport */ ++ kcp->client = clnt_create ("/var/run/keyservsock", KEY_PROG, vers, "unix"); ++ ++ if (kcp->client == (CLIENT *) NULL) ++ return (CLIENT *) NULL; ++ ++ kcp->uid = geteuid (); ++ kcp->pid = getpid (); ++ kcp->client->cl_auth = authunix_create ((char *)"", kcp->uid, 0, 0, NULL); ++ if (kcp->client->cl_auth == NULL) ++ { ++ clnt_destroy (kcp->client); ++ kcp->client = NULL; ++ return (CLIENT *) NULL; ++ } ++ ++ wait_time.tv_sec = TOTAL_TIMEOUT/TOTAL_TRIES; ++ wait_time.tv_usec = 0; ++ clnt_control (kcp->client, CLSET_RETRY_TIMEOUT, ++ (char *)&wait_time); ++ if (clnt_control (kcp->client, CLGET_FD, (char *)&fd)) ++ fcntl (fd, F_SETFD, FD_CLOEXEC); /* make it "close on exec" */ + +- /* if pid has changed, destroy client and rebuild */ +- if (kcp->client != NULL && kcp->pid != getpid()) { +- clnt_destroy(kcp->client); +- kcp->client = NULL; +- } ++ return kcp->client; ++} + +- if (kcp->client != NULL) { +- /* if uid has changed, build client handle again */ +- if (kcp->uid != geteuid()) { +- kcp->uid = geteuid(); +- auth_destroy(kcp->client->cl_auth); +- kcp->client->cl_auth = +- authsys_create("", kcp->uid, 0, 0, NULL); +- if (kcp->client->cl_auth == NULL) { +- clnt_destroy(kcp->client); +- kcp->client = NULL; +- return ((CLIENT *) NULL); +- } +- } +- /* Change the version number to the new one */ +- clnt_control(kcp->client, CLSET_VERS, (void *)&vers); +- return (kcp->client); +- } +- if (!(localhandle = setnetconfig())) { +- return ((CLIENT *) NULL); +- } +- tpconf = NULL; +- if (uname(&u) == -1) { +- endnetconfig(localhandle); +- return ((CLIENT *) NULL); +- } +- while ((nconf = getnetconfig(localhandle)) != NULL) { +- if (strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0) { +- /* +- * We use COTS_ORD here so that the caller can +- * find out immediately if the server is dead. +- */ +- if (nconf->nc_semantics == NC_TPI_COTS_ORD) { +- kcp->client = clnt_tp_create(u.nodename, +- KEY_PROG, vers, nconf); +- if (kcp->client) +- break; +- } else { +- tpconf = nconf; +- } +- } +- } +- if ((kcp->client == (CLIENT *) NULL) && (tpconf)) +- /* Now, try the CLTS or COTS loopback transport */ +- kcp->client = clnt_tp_create(u.nodename, +- KEY_PROG, vers, tpconf); +- endnetconfig(localhandle); +- +- if (kcp->client == (CLIENT *) NULL) { +- return ((CLIENT *) NULL); +- } +- kcp->uid = geteuid(); +- kcp->pid = getpid(); +- kcp->client->cl_auth = authsys_create("", kcp->uid, 0, 0, NULL); +- if (kcp->client->cl_auth == NULL) { +- clnt_destroy(kcp->client); +- kcp->client = NULL; +- return ((CLIENT *) NULL); +- } ++/* returns 0 on failure, 1 on success */ ++static int ++key_call_socket (u_long proc, xdrproc_t xdr_arg, char *arg, ++ xdrproc_t xdr_rslt, char *rslt) ++{ ++ CLIENT *clnt; ++ struct timeval wait_time; ++ int result = 0; + +- wait_time.tv_sec = TOTAL_TIMEOUT/TOTAL_TRIES; +- wait_time.tv_usec = 0; +- (void) clnt_control(kcp->client, CLSET_RETRY_TIMEOUT, +- (char *)&wait_time); +- if (clnt_control(kcp->client, CLGET_FD, (char *)&fd)) +- fcntl(fd, F_SETFD, 1); /* make it "close on exec" */ ++ if ((proc == KEY_ENCRYPT_PK) || (proc == KEY_DECRYPT_PK) || ++ (proc == KEY_NET_GET) || (proc == KEY_NET_PUT) || ++ (proc == KEY_GET_CONV)) ++ clnt = getkeyserv_handle(2); /* talk to version 2 */ ++ else ++ clnt = getkeyserv_handle(1); /* talk to version 1 */ + +- return (kcp->client); ++ if (clnt != NULL) ++ { ++ wait_time.tv_sec = TOTAL_TIMEOUT; ++ wait_time.tv_usec = 0; ++ ++ if (clnt_call (clnt, proc, xdr_arg, arg, xdr_rslt, rslt, ++ wait_time) == RPC_SUCCESS) ++ result = 1; ++ } ++ ++ return result; + } + +-/* returns 0 on failure, 1 on success */ + ++/* returns 0 on failure, 1 on success */ + static int +-key_call(proc, xdr_arg, arg, xdr_rslt, rslt) +- u_long proc; +- xdrproc_t xdr_arg; +- void *arg; +- xdrproc_t xdr_rslt; +- void *rslt; +-{ +- CLIENT *clnt; +- struct timeval wait_time; +- +- if (proc == KEY_ENCRYPT_PK && __key_encryptsession_pk_LOCAL) { +- cryptkeyres *res; +- res = (*__key_encryptsession_pk_LOCAL)(geteuid(), arg); +- *(cryptkeyres*)rslt = *res; +- return (1); +- } else if (proc == KEY_DECRYPT_PK && __key_decryptsession_pk_LOCAL) { +- cryptkeyres *res; +- res = (*__key_decryptsession_pk_LOCAL)(geteuid(), arg); +- *(cryptkeyres*)rslt = *res; +- return (1); +- } else if (proc == KEY_GEN && __key_gendes_LOCAL) { +- des_block *res; +- res = (*__key_gendes_LOCAL)(geteuid(), 0); +- *(des_block*)rslt = *res; +- return (1); +- } +- +- if ((proc == KEY_ENCRYPT_PK) || (proc == KEY_DECRYPT_PK) || +- (proc == KEY_NET_GET) || (proc == KEY_NET_PUT) || +- (proc == KEY_GET_CONV)) +- clnt = getkeyserv_handle(2); /* talk to version 2 */ +- else +- clnt = getkeyserv_handle(1); /* talk to version 1 */ ++key_call (u_long proc, xdrproc_t xdr_arg, char *arg, ++ xdrproc_t xdr_rslt, char *rslt) ++{ ++#ifndef SO_PASSCRED ++ static int use_keyenvoy; ++#endif ++ ++ if (proc == KEY_ENCRYPT_PK && __key_encryptsession_pk_LOCAL) ++ { ++ cryptkeyres *res; ++ res = (*__key_encryptsession_pk_LOCAL) (geteuid (), arg); ++ *(cryptkeyres *) rslt = *res; ++ return 1; ++ } ++ else if (proc == KEY_DECRYPT_PK && __key_decryptsession_pk_LOCAL) ++ { ++ cryptkeyres *res; ++ res = (*__key_decryptsession_pk_LOCAL) (geteuid (), arg); ++ *(cryptkeyres *) rslt = *res; ++ return 1; ++ } ++ else if (proc == KEY_GEN && __key_gendes_LOCAL) ++ { ++ des_block *res; ++ res = (*__key_gendes_LOCAL) (geteuid (), 0); ++ *(des_block *) rslt = *res; ++ return 1; ++ } + +- if (clnt == NULL) { +- return (0); +- } ++#ifdef SO_PASSCRED ++ return key_call_socket (proc, xdr_arg, arg, xdr_rslt, rslt); ++#else ++ if (!use_keyenvoy) ++ { ++ if (key_call_socket (proc, xdr_arg, arg, xdr_rslt, rslt)) ++ return 1; ++ use_keyenvoy = 1; ++ } ++ return key_call_keyenvoy (proc, xdr_arg, arg, xdr_rslt, rslt); ++#endif ++} + +- wait_time.tv_sec = TOTAL_TIMEOUT; +- wait_time.tv_usec = 0; ++#ifdef _RPC_THREAD_SAFE_ ++void ++__rpc_thread_key_cleanup (void) ++{ ++ struct key_call_private *kcp = RPC_THREAD_VARIABLE(key_call_private_s); + +- if (clnt_call(clnt, proc, xdr_arg, arg, xdr_rslt, rslt, +- wait_time) == RPC_SUCCESS) { +- return (1); +- } else { +- return (0); ++ if (kcp) { ++ if (kcp->client) { ++ if (kcp->client->cl_auth) ++ auth_destroy (kcp->client->cl_auth); ++ clnt_destroy(kcp->client); ++ } ++ free (kcp); + } + } ++#endif /* _RPC_THREAD_SAFE_ */ +diff -urN libtirpc-0.2.3/src/Makefile.am libtirpc-0.2.3.new/src/Makefile.am +--- libtirpc-0.2.3/src/Makefile.am 2013-02-13 16:13:59.000000000 +0100 ++++ libtirpc-0.2.3.new/src/Makefile.am 2013-03-19 12:24:24.368923058 +0100 +@@ -50,7 +50,7 @@ + rpc_callmsg.c rpc_generic.c rpc_soc.c rpcb_clnt.c rpcb_prot.c \ + rpcb_st_xdr.c svc.c svc_auth.c svc_dg.c svc_auth_unix.c svc_auth_none.c \ + svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c \ +- auth_time.c auth_des.c authdes_prot.c ++ auth_time.c auth_des.c authdes_prot.c des_crypt.c key_call.c key_prot_xdr.c netname.c getpublickey.c rpcdname.c des_impl.c + + ## XDR + libtirpc_la_SOURCES += xdr.c xdr_rec.c xdr_array.c xdr_float.c xdr_mem.c xdr_reference.c xdr_stdio.c diff --git a/meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0.2.3-types.h.patch b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0.2.3-types.h.patch new file mode 100644 index 0000000000..2a0768d5c8 --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0.2.3-types.h.patch @@ -0,0 +1,14 @@ +--- libtirpc-0.2.3/tirpc/rpc/types.h.bero 2013-01-28 23:59:14.383069929 +0100 ++++ libtirpc-0.2.3/tirpc/rpc/types.h 2013-01-28 23:59:39.123777626 +0100 +@@ -38,6 +38,11 @@ + #ifndef _TIRPC_TYPES_H + #define _TIRPC_TYPES_H + ++#ifndef _BSD_SOURCE ++/* For uint_t and friends */ ++#define _BSD_SOURCE 1 ++#endif ++ + #include + + typedef int32_t bool_t; diff --git a/meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0008-Add-rpcgen-program-from-nfs-utils-sources.patch b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0008-Add-rpcgen-program-from-nfs-utils-sources.patch new file mode 100644 index 0000000000..60f43dfb83 --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/libtirpc-0008-Add-rpcgen-program-from-nfs-utils-sources.patch @@ -0,0 +1,6408 @@ +--- libtirpc-0.2.3/configure.ac.0005~ 2013-02-11 21:47:03.982289136 +0100 ++++ libtirpc-0.2.3/configure.ac 2013-02-11 21:47:03.990289233 +0100 +@@ -25,6 +25,16 @@ AC_CHECK_HEADERS([arpa/inet.h fcntl.h li + AC_CHECK_LIB([pthread], [pthread_create]) + AC_CHECK_LIB([nsl], [yp_get_default_domain]) + ++AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes) + +-AC_CONFIG_FILES([Makefile src/Makefile man/Makefile doc/Makefile]) ++ ++AC_MSG_CHECKING([for a C compiler for build tools]) ++if test $cross_compiling = yes; then ++ AC_CHECK_PROGS(CC_FOR_BUILD, gcc cc) ++else ++ CC_FOR_BUILD=$CC ++fi ++AC_MSG_RESULT([$CC_FOR_BUILD]) ++AC_SUBST(CC_FOR_BUILD) ++AC_CONFIG_FILES([Makefile src/Makefile man/Makefile doc/Makefile rpcgen/Makefile]) + AC_OUTPUT(libtirpc.pc) +--- libtirpc-0.2.3/Makefile.am.0005~ 2012-04-26 21:54:02.000000000 +0200 ++++ libtirpc-0.2.3/Makefile.am 2013-02-11 21:47:03.990289233 +0100 +@@ -1,4 +1,4 @@ +-SUBDIRS = src man doc ++SUBDIRS = src man doc rpcgen + ACLOCAL_AMFLAGS = -I m4 + + nobase_include_HEADERS = tirpc/netconfig.h \ +--- libtirpc-0.2.3/rpcgen/Makefile.am.0005~ 2013-02-11 21:47:03.990289233 +0100 ++++ libtirpc-0.2.3/rpcgen/Makefile.am 2013-02-11 21:49:37.233184084 +0100 +@@ -0,0 +1,24 @@ ++INCLUDES = -I$(top_srcdir)/tirpc -DPORTMAP -DINET6 -DVERSION="\"$(VERSION)\"" \ ++ -D_GNU_SOURCE -Wall -pipe ++COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ ++ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) ++LINK = $(CC) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ ++ ++bin_PROGRAMS = rpcgen ++ ++rpcgen_SOURCES = \ ++ rpc_clntout.c \ ++ rpc_cout.c \ ++ rpc_hout.c \ ++ rpc_main.c \ ++ rpc_parse.c \ ++ rpc_sample.c \ ++ rpc_scan.c \ ++ rpc_svcout.c \ ++ rpc_tblout.c \ ++ rpc_util.c \ ++ rpc_parse.h \ ++ rpc_scan.h \ ++ rpc_util.h ++ ++dist_man1_MANS = rpcgen.1 +--- libtirpc-0.2.3/rpcgen/rpc_clntout.c.0005~ 2013-02-11 21:47:03.990289233 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_clntout.c 2013-02-11 21:47:03.990289233 +0100 +@@ -0,0 +1,217 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#if 0 ++static char sccsid[] = "@(#)rpc_clntout.c 1.11 89/02/22 (C) 1987 SMI"; ++#endif ++ ++/* ++ * rpc_clntout.c, Client-stub outputter for the RPC protocol compiler ++ * Copyright (C) 1987, Sun Microsytsems, Inc. ++ */ ++#include ++#include ++#include ++#include "rpc_parse.h" ++#include "rpc_util.h" ++#include "rpc_output.h" ++ ++/* extern pdeclaration(); */ ++/* void printarglist(); */ ++ ++#define DEFAULT_TIMEOUT 25 /* in seconds */ ++static char RESULT[] = "clnt_res"; ++ ++static void write_program(definition *def); ++static void printbody(proc_list *proc); ++ ++ ++void ++write_stubs(void) ++{ ++ list *l; ++ definition *def; ++ ++ f_print(fout, ++ "\n/* Default timeout can be changed using clnt_control() */\n"); ++ f_print(fout, "static struct timeval TIMEOUT = { %d, 0 };\n", ++ DEFAULT_TIMEOUT); ++ for (l = defined; l != NULL; l = l->next) { ++ def = (definition *) l->val; ++ if (def->def_kind == DEF_PROGRAM) { ++ write_program(def); ++ } ++ } ++} ++ ++static void ++write_program(definition *def) ++{ ++ version_list *vp; ++ proc_list *proc; ++ ++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { ++ for (proc = vp->procs; proc != NULL; proc = proc->next) { ++ f_print(fout, "\n"); ++ ptype(proc->res_prefix, proc->res_type, 1); ++ f_print(fout, "*\n"); ++ pvname(proc->proc_name, vp->vers_num); ++ printarglist(proc, "clnt", "CLIENT *"); ++ f_print(fout, "{\n"); ++ printbody(proc); ++ f_print(fout, "}\n"); ++ } ++ } ++} ++ ++/* ++ * Writes out declarations of procedure's argument list. ++ * In either ANSI C style, in one of old rpcgen style (pass by reference), ++ * or new rpcgen style (multiple arguments, pass by value); ++ */ ++ ++/* sample addargname = "clnt"; sample addargtype = "CLIENT * " */ ++ ++void ++printarglist(proc_list *proc, char *addargname, char *addargtype) ++{ ++ ++ decl_list *l; ++ ++ if (!newstyle) { /* old style: always pass arg by reference */ ++ if (Cflag) { /* C++ style heading */ ++ f_print(fout, "("); ++ ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1); ++ f_print(fout, "*argp, %s%s)\n", addargtype, addargname); ++ } else { ++ f_print(fout, "(argp, %s)\n", addargname); ++ f_print(fout, "\t"); ++ ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1); ++ f_print(fout, "*argp;\n"); ++ } ++ } else if (streq(proc->args.decls->decl.type, "void")) { ++ /* newstyle, 0 argument */ ++ if (Cflag) ++ f_print(fout, "(%s%s)\n", addargtype, addargname); ++ else ++ f_print(fout, "(%s)\n", addargname); ++ } else { ++ /* new style, 1 or multiple arguments */ ++ if (!Cflag) { ++ f_print(fout, "("); ++ for (l = proc->args.decls; l != NULL; l = l->next) ++ f_print(fout, "%s, ", l->decl.name); ++ f_print(fout, "%s)\n", addargname); ++ for (l = proc->args.decls; l != NULL; l = l->next) { ++ pdeclaration(proc->args.argname, &l->decl, 1, ";\n"); ++ } ++ } else { /* C++ style header */ ++ f_print(fout, "("); ++ for (l = proc->args.decls; l != NULL; l = l->next) { ++ pdeclaration(proc->args.argname, &l->decl, 0, ", "); ++ } ++ f_print(fout, " %s%s)\n", addargtype, addargname); ++ } ++ } ++ ++ if (!Cflag) ++ f_print(fout, "\t%s%s;\n", addargtype, addargname); ++} ++ ++ ++ ++static char * ++ampr(char *type) ++{ ++ if (isvectordef(type, REL_ALIAS)) { ++ return (""); ++ } else { ++ return ("&"); ++ } ++} ++ ++static void ++printbody(proc_list *proc) ++{ ++ decl_list *l; ++ bool_t args2 = (proc->arg_num > 1); ++ ++ /* For new style with multiple arguments, need a structure in which ++ * to stuff the arguments. */ ++ if (newstyle && args2) { ++ f_print(fout, "\t%s", proc->args.argname); ++ f_print(fout, " arg;\n"); ++ } ++ f_print(fout, "\tstatic "); ++ if (streq(proc->res_type, "void")) { ++ f_print(fout, "char "); ++ } else { ++ ptype(proc->res_prefix, proc->res_type, 0); ++ } ++ f_print(fout, "%s;\n", RESULT); ++ f_print(fout, "\n"); ++ f_print(fout, "\tmemset((char *)%s%s, 0, sizeof(%s));\n", ++ ampr(proc->res_type), RESULT, RESULT); ++ if (newstyle && !args2 && (streq(proc->args.decls->decl.type, "void"))) { ++ /* newstyle, 0 arguments */ ++ f_print(fout, ++ "\tif (clnt_call(clnt, %s, (xdrproc_t) xdr_void, (caddr_t) NULL, " ++ "(xdrproc_t) xdr_%s, (caddr_t) %s%s, TIMEOUT) != RPC_SUCCESS) {\n", ++ proc->proc_name, ++ stringfix(proc->res_type), ampr(proc->res_type), RESULT); ++ ++ } else if (newstyle && args2) { ++ /* newstyle, multiple arguments: stuff arguments into structure */ ++ for (l = proc->args.decls; l != NULL; l = l->next) { ++ f_print(fout, "\targ.%s = %s;\n", ++ l->decl.name, l->decl.name); ++ } ++ f_print(fout, ++ "\tif (clnt_call(clnt, %s, (xdrproc_t) xdr_%s, (caddr_t) &arg, " ++ "(xdrproc_t) xdr_%s, (caddr_t) %s%s, TIMEOUT) != RPC_SUCCESS) {\n", ++ proc->proc_name, proc->args.argname, ++ stringfix(proc->res_type), ampr(proc->res_type), RESULT); ++ } else { /* single argument, new or old style */ ++ f_print(fout, ++ "\tif (clnt_call(clnt, %s, (xdrproc_t) xdr_%s, " ++ "(caddr_t) %s%s, (xdrproc_t) xdr_%s, (caddr_t) %s%s, TIMEOUT) != RPC_SUCCESS) {\n", ++ proc->proc_name, ++ stringfix(proc->args.decls->decl.type), ++ (newstyle ? "&" : ""), ++ (newstyle ? proc->args.decls->decl.name : "argp"), ++ stringfix(proc->res_type), ampr(proc->res_type), RESULT); ++ } ++ f_print(fout, "\t\treturn (NULL);\n"); ++ f_print(fout, "\t}\n"); ++ if (streq(proc->res_type, "void")) { ++ f_print(fout, "\treturn ((void *)%s%s);\n", ++ ampr(proc->res_type), RESULT); ++ } else { ++ f_print(fout, "\treturn (%s%s);\n", ampr(proc->res_type), RESULT); ++ } ++} +--- libtirpc-0.2.3/rpcgen/rpc_cout.c.0005~ 2013-02-11 21:47:03.991289244 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_cout.c 2013-02-11 21:47:03.991289244 +0100 +@@ -0,0 +1,706 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#if 0 ++static char sccsid[] = "@(#)rpc_cout.c 1.13 89/02/22 (C) 1987 SMI"; ++#endif ++ ++/* ++ * rpc_cout.c, XDR routine outputter for the RPC protocol compiler ++ */ ++#include ++#include ++#include ++#include ++#include ++#include "rpc_parse.h" ++#include "rpc_util.h" ++ ++static int findtype(definition *def, char *type); ++static int undefined(char *type); ++static void print_generic_header(char *procname, int pointerp); ++static void print_header(definition *def); ++static void print_prog_header(proc_list *plist); ++static void print_trailer(void); ++static void print_ifopen(int indent, char *name); ++static void print_ifarg(char *arg); ++static void print_ifsizeof(char *prefix, char *type); ++static void print_ifclose(int indent); ++static void print_ifstat(int indent, char *prefix, char *type, relation rel, ++ char *amax, char *objname, char *name); ++static void emit_enum(definition *def); ++static void emit_program(definition *def); ++static void emit_union(definition *def); ++static void emit_struct(definition *def); ++static void emit_typedef(definition *def); ++static void print_stat(int indent, declaration *dec); ++static void emit_inline(declaration *decl, int flag); ++static void emit_single_in_line(declaration *decl, int flag, relation rel); ++static char * upcase(char *str); ++ ++/* ++ * Emit the C-routine for the given definition ++ */ ++void ++emit(definition *def) ++{ ++ if (def->def_kind == DEF_CONST) { ++ return; ++ } ++ if (def->def_kind == DEF_PROGRAM) { ++ emit_program(def); ++ return; ++ } ++ if (def->def_kind == DEF_TYPEDEF) { ++ /* now we need to handle declarations like ++ * struct typedef foo foo; ++ * since we dont want this to be expanded into 2 calls ++ * to xdr_foo */ ++ ++ if (strcmp(def->def.ty.old_type, def->def_name) == 0) ++ return; ++ }; ++ ++ print_header(def); ++ switch (def->def_kind) { ++ case DEF_UNION: ++ emit_union(def); ++ break; ++ case DEF_ENUM: ++ emit_enum(def); ++ break; ++ case DEF_STRUCT: ++ emit_struct(def); ++ break; ++ case DEF_TYPEDEF: ++ emit_typedef(def); ++ break; ++ default: ++ break; ++ } ++ print_trailer(); ++} ++ ++static int ++findtype(definition *def, char *type) ++{ ++ ++ if (def->def_kind == DEF_PROGRAM || def->def_kind == DEF_CONST) { ++ return (0); ++ } else { ++ return (streq(def->def_name, type)); ++ } ++} ++ ++static int ++undefined(char *type) ++{ ++ definition *def; ++ ++ def = (definition *) FINDVAL(defined, type, findtype); ++ ++ return (def == NULL); ++} ++ ++ ++static void ++print_generic_header(char *procname, int pointerp) ++{ ++ f_print(fout, "\n"); ++ f_print(fout, "bool_t\n"); ++ if (Cflag) { ++ f_print(fout, "xdr_%s(", procname); ++ f_print(fout, "XDR *xdrs, "); ++ f_print(fout, "%s ", procname); ++ if (pointerp) ++ f_print(fout, "*"); ++ f_print(fout, "objp)\n{\n\n"); ++ } else { ++ f_print(fout, "xdr_%s(xdrs, objp)\n", procname); ++ f_print(fout, "\tXDR *xdrs;\n"); ++ f_print(fout, "\t%s ", procname); ++ if (pointerp) ++ f_print(fout, "*"); ++ f_print(fout, "objp;\n{\n\n"); ++ } ++} ++ ++static void ++print_header(definition *def) ++{ ++ print_generic_header(def->def_name, ++ def->def_kind != DEF_TYPEDEF || ++ !isvectordef(def->def.ty.old_type, def->def.ty.rel)); ++ ++ /* Now add Inline support */ ++ ++ ++ if (Inline == 0) ++ return; ++} ++ ++static void ++print_prog_header(proc_list *plist) ++{ ++ print_generic_header(plist->args.argname, 1); ++} ++ ++static void ++print_trailer(void) ++{ ++ f_print(fout, "\treturn (TRUE);\n"); ++ f_print(fout, "}\n"); ++} ++ ++ ++static void ++print_ifopen(int indent, char *name) ++{ ++ tabify(fout, indent); ++ f_print(fout, " if (!xdr_%s(xdrs", name); ++} ++ ++static void ++print_ifarg(char *arg) ++{ ++ f_print(fout, ", %s", arg); ++} ++ ++static void ++print_ifsizeof(char *prefix, char *type) ++{ ++ if (streq(type, "bool")) { ++ f_print(fout, ", sizeof(bool_t), (xdrproc_t)xdr_bool"); ++ } else { ++ f_print(fout, ", sizeof("); ++ if (undefined(type) && prefix) { ++ f_print(fout, "%s ", prefix); ++ } ++ f_print(fout, "%s), (xdrproc_t)xdr_%s", type, type); ++ } ++} ++ ++static void ++print_ifclose(int indent) ++{ ++ f_print(fout, ")) {\n"); ++ tabify(fout, indent); ++ f_print(fout, "\t return (FALSE);\n"); ++ tabify(fout, indent); ++ f_print(fout, " }\n"); ++} ++ ++static void ++print_ifstat(int indent, char *prefix, char *type, relation rel, ++ char *amax, char *objname, char *name) ++{ ++ char *alt = NULL; ++ ++ switch (rel) { ++ case REL_POINTER: ++ print_ifopen(indent, "pointer"); ++ print_ifarg("(char **)"); ++ f_print(fout, "%s", objname); ++ print_ifsizeof(prefix, type); ++ break; ++ case REL_VECTOR: ++ if (streq(type, "string")) { ++ alt = "string"; ++ } else if (streq(type, "opaque")) { ++ alt = "opaque"; ++ } ++ if (alt) { ++ print_ifopen(indent, alt); ++ print_ifarg(objname); ++ } else { ++ print_ifopen(indent, "vector"); ++ print_ifarg("(char *)"); ++ f_print(fout, "%s", objname); ++ } ++ print_ifarg(amax); ++ if (!alt) { ++ print_ifsizeof(prefix, type); ++ } ++ break; ++ case REL_ARRAY: ++ if (streq(type, "string")) { ++ alt = "string"; ++ } else if (streq(type, "opaque")) { ++ alt = "bytes"; ++ } ++ if (streq(type, "string")) { ++ print_ifopen(indent, alt); ++ print_ifarg(objname); ++ } else { ++ if (alt) { ++ print_ifopen(indent, alt); ++ } else { ++ print_ifopen(indent, "array"); ++ } ++ /* The (void*) avoids a gcc-4.1 warning */ ++ print_ifarg("(char **)(void*)"); ++ if (*objname == '&') { ++ f_print(fout, "%s.%s_val, (u_int *)%s.%s_len", ++ objname, name, objname, name); ++ } else { ++ f_print(fout, "&%s->%s_val, (u_int *)&%s->%s_len", ++ objname, name, objname, name); ++ } ++ } ++ print_ifarg(amax); ++ if (!alt) { ++ print_ifsizeof(prefix, type); ++ } ++ break; ++ case REL_ALIAS: ++ print_ifopen(indent, type); ++ print_ifarg(objname); ++ break; ++ } ++ print_ifclose(indent); ++} ++ ++static void ++emit_enum(definition *def) ++{ ++ print_ifopen(1, "enum"); ++ print_ifarg("(enum_t *)objp"); ++ print_ifclose(1); ++} ++ ++static void ++emit_program(definition *def) ++{ ++ decl_list *dl; ++ version_list *vlist; ++ proc_list *plist; ++ ++ for (vlist = def->def.pr.versions; vlist != NULL; vlist = vlist->next) ++ for (plist = vlist->procs; plist != NULL; plist = plist->next) { ++ if (!newstyle || plist->arg_num < 2) ++ continue;/* old style, or single argument */ ++ print_prog_header(plist); ++ for (dl = plist->args.decls; dl != NULL; dl = dl->next) ++ print_stat(1, &dl->decl); ++ print_trailer(); ++ } ++} ++ ++ ++static void ++emit_union(definition *def) ++{ ++ declaration *dflt; ++ case_list *cl; ++ declaration *cs; ++ char *object; ++ char *vecformat = "objp->%s_u.%s"; ++ char *format = "&objp->%s_u.%s"; ++ ++ print_stat(1,&def->def.un.enum_decl); ++ f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name); ++ for (cl = def->def.un.cases; cl != NULL; cl = cl->next) { ++ ++ f_print(fout, "\tcase %s:\n", cl->case_name); ++ if(cl->contflag == 1) /* a continued case statement */ ++ continue; ++ cs = &cl->case_decl; ++ if (!streq(cs->type, "void")) { ++ object = alloc(strlen(def->def_name) + strlen(format) + ++ strlen(cs->name) + 1); ++ if (isvectordef (cs->type, cs->rel)) { ++ s_print(object, vecformat, def->def_name, ++ cs->name); ++ } else { ++ s_print(object, format, def->def_name, ++ cs->name); ++ } ++ print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max, ++ object, cs->name); ++ free(object); ++ } ++ f_print(fout, "\t\tbreak;\n"); ++ } ++ dflt = def->def.un.default_decl; ++ if (dflt != NULL) { ++ if (!streq(dflt->type, "void")) { ++ f_print(fout, "\tdefault:\n"); ++ object = alloc(strlen(def->def_name) + strlen(format) + ++ strlen(dflt->name) + 1); ++ if (isvectordef (dflt->type, dflt->rel)) { ++ s_print(object, vecformat, def->def_name, ++ dflt->name); ++ } else { ++ s_print(object, format, def->def_name, ++ dflt->name); ++ } ++ ++ print_ifstat(2, dflt->prefix, dflt->type, dflt->rel, ++ dflt->array_max, object, dflt->name); ++ free(object); ++ f_print(fout, "\t\tbreak;\n"); ++ } else { ++ /* Avoid gcc warnings about `value not handled in switch' */ ++ f_print(fout, "\tdefault:\n"); ++ f_print(fout, "\t\tbreak;\n"); ++ } ++ } else { ++ f_print(fout, "\tdefault:\n"); ++ f_print(fout, "\t\treturn (FALSE);\n"); ++ } ++ ++ f_print(fout, "\t}\n"); ++} ++ ++static void ++emit_struct(definition *def) ++{ ++ decl_list *dl; ++ int i, j, size, flag; ++ decl_list *cur = NULL, *psav; ++ bas_type *ptr; ++ char *sizestr, *plus; ++ char ptemp[256]; ++ int can_inline; ++ const char *buf_declaration; ++ ++ ++ if (Inline == 0) { ++ for (dl = def->def.st.decls; dl != NULL; dl = dl->next) ++ print_stat(1, &dl->decl); ++ } else { ++ size = 0; ++ can_inline = 0; ++ for (dl = def->def.st.decls; dl != NULL; dl = dl->next) ++ if ((dl->decl.prefix == NULL) && ((ptr = find_type(dl->decl.type)) != NULL) && ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) { ++ ++ if (dl->decl.rel == REL_ALIAS) ++ size += ptr->length; ++ else { ++ can_inline = 1; ++ break; /* can be inlined */ ++ }; ++ } else { ++ if (size >= Inline) { ++ can_inline = 1; ++ break; /* can be inlined */ ++ } ++ size = 0; ++ } ++ if (size > Inline) ++ can_inline = 1; ++ ++ if (can_inline == 0) { /* can not inline, drop back to old mode */ ++ for (dl = def->def.st.decls; dl != NULL; dl = dl->next) ++ print_stat(1, &dl->decl); ++ return; ++ }; ++ ++ ++ ++ ++ flag = PUT; ++ for (j = 0; j < 2; j++) { ++ ++ if (flag == PUT) ++ f_print(fout, "\n\t if (xdrs->x_op == XDR_ENCODE) {\n"); ++ else ++ f_print(fout, "\n \t return (TRUE);\n\t} else if (xdrs->x_op == XDR_DECODE) {\n"); ++ ++ ++ i = 0; ++ size = 0; ++ sizestr = NULL; ++ buf_declaration = "int32_t *"; ++ for (dl = def->def.st.decls; dl != NULL; dl = dl->next) { /* xxx */ ++ ++ /* now walk down the list and check for basic types */ ++ if ((dl->decl.prefix == NULL) && ((ptr = find_type(dl->decl.type)) != NULL) && ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) { ++ if (i == 0) ++ cur = dl; ++ i++; ++ ++ if (dl->decl.rel == REL_ALIAS) ++ size += ptr->length; ++ else { ++ /* this is required to handle arrays */ ++ ++ if (sizestr == NULL) ++ plus = " "; ++ else ++ plus = "+"; ++ ++ if (ptr->length != 1) ++ s_print(ptemp, " %s %s * %d", plus, dl->decl.array_max, ptr->length); ++ else ++ s_print(ptemp, " %s %s ", plus, dl->decl.array_max); ++ ++ /*now concatenate to sizestr !!!! */ ++ if (sizestr == NULL) ++ sizestr = strdup(ptemp); ++ else { ++ sizestr = realloc(sizestr, strlen(sizestr) + strlen(ptemp) + 1); ++ if (sizestr == NULL) { ++ ++ f_print(stderr, "Fatal error : no memory \n"); ++ crash(); ++ }; ++ sizestr = strcat(sizestr, ptemp); /*build up length of array */ ++ ++ } ++ } ++ ++ } else { ++ if (i > 0) ++ { ++ if (sizestr == NULL && size < Inline) { ++ /* don't expand into inline code if size < inline */ ++ while (cur != dl) { ++ print_stat(1, &cur->decl); ++ cur = cur->next; ++ } ++ } else { ++ ++ ++ ++ /* were already looking at a xdr_inlineable structure */ ++ if (sizestr == NULL) ++ f_print(fout, "\t %sbuf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);", ++ buf_declaration, size); ++ else if (size == 0) ++ f_print(fout, ++ "\t %sbuf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);", ++ buf_declaration, sizestr); ++ else ++ f_print(fout, ++ "\t %sbuf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);", ++ buf_declaration, size, sizestr); ++ buf_declaration = ""; ++ ++ f_print(fout, "\n\t if (buf == NULL) {\n"); ++ ++ psav = cur; ++ while (cur != dl) { ++ print_stat(2, &cur->decl); ++ cur = cur->next; ++ } ++ ++ f_print(fout, "\n\t }\n\t else {\n"); ++ ++ cur = psav; ++ while (cur != dl) { ++ emit_inline(&cur->decl, flag); ++ cur = cur->next; ++ } ++ ++ f_print(fout, "\t }\n"); ++ } ++ } ++ size = 0; ++ i = 0; ++ sizestr = NULL; ++ print_stat(1, &dl->decl); ++ } ++ ++ } ++ if (i > 0) ++ { ++ if (sizestr == NULL && size < Inline) { ++ /* don't expand into inline code if size < inline */ ++ while (cur != dl) { ++ print_stat(1, &cur->decl); ++ cur = cur->next; ++ } ++ } else { ++ ++ /* were already looking at a xdr_inlineable structure */ ++ if (sizestr == NULL) ++ f_print(fout, "\t\t%sbuf = XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);", ++ buf_declaration, size); ++ else if (size == 0) ++ f_print(fout, ++ "\t\t%sbuf = XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);", ++ buf_declaration, sizestr); ++ else ++ f_print(fout, ++ "\t\t%sbuf = XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);", ++ buf_declaration, size, sizestr); ++ buf_declaration = ""; ++ ++ f_print(fout, "\n\t\tif (buf == NULL) {\n"); ++ ++ psav = cur; ++ while (cur != NULL) { ++ print_stat(2, &cur->decl); ++ cur = cur->next; ++ } ++ f_print(fout, "\n\t }\n\t else {\n"); ++ ++ cur = psav; ++ while (cur != dl) { ++ emit_inline(&cur->decl, flag); ++ cur = cur->next; ++ } ++ ++ f_print(fout, "\t }\n"); ++ ++ } ++ } ++ flag = GET; ++ } ++ f_print(fout, "\t return(TRUE);\n\t}\n\n"); ++ ++ /* now take care of XDR_FREE case */ ++ ++ for (dl = def->def.st.decls; dl != NULL; dl = dl->next) ++ print_stat(1, &dl->decl); ++ } ++} ++ ++ ++ ++ ++static void ++emit_typedef(definition *def) ++{ ++ char *prefix = def->def.ty.old_prefix; ++ char *type = def->def.ty.old_type; ++ char *amax = def->def.ty.array_max; ++ relation rel = def->def.ty.rel; ++ ++ ++ print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name); ++} ++ ++static void ++print_stat(int indent, declaration *dec) ++{ ++ char *prefix = dec->prefix; ++ char *type = dec->type; ++ char *amax = dec->array_max; ++ relation rel = dec->rel; ++ char name[256]; ++ ++ if (isvectordef(type, rel)) { ++ s_print(name, "objp->%s", dec->name); ++ } else { ++ s_print(name, "&objp->%s", dec->name); ++ } ++ print_ifstat(indent, prefix, type, rel, amax, name, dec->name); ++} ++ ++ ++static void ++emit_inline(declaration *decl, int flag) ++{ ++ ++ /*check whether an array or not */ ++ ++ switch (decl->rel) { ++ case REL_ALIAS: ++ emit_single_in_line(decl, flag, REL_ALIAS); ++ break; ++ case REL_VECTOR: ++ f_print(fout, "\t\t{ register %s *genp; \n", decl->type); ++ f_print(fout, "\t\t int i;\n"); ++ f_print(fout, "\t\t for ( i = 0,genp=objp->%s;\n \t\t\ti < %s; i++){\n\t\t", ++ decl->name, decl->array_max); ++ emit_single_in_line(decl, flag, REL_VECTOR); ++ f_print(fout, "\t\t }\n\t\t };\n"); ++ break; ++ default: ++ break; ++ } ++} ++ ++static void ++emit_single_in_line(declaration *decl, int flag, relation rel) ++{ ++ char *upp_case; ++ int freed=0; ++ ++ if(flag == PUT) ++ f_print(fout,"\t\t (void) IXDR_PUT_"); ++ else ++ if(rel== REL_ALIAS) ++ f_print(fout,"\t\t objp->%s = IXDR_GET_",decl->name); ++ else ++ f_print(fout,"\t\t *genp++ = IXDR_GET_"); ++ ++ upp_case=upcase(decl->type); ++ ++ /* hack - XX */ ++ if(strcmp(upp_case,"INT") == 0) ++ { ++ free(upp_case); ++ freed=1; ++ upp_case="INT32"; ++ } ++ ++ if(strcmp(upp_case,"U_INT") == 0) ++ { ++ free(upp_case); ++ freed=1; ++ upp_case="U_INT32"; ++ } ++ ++ ++ if(flag == PUT) ++ if(rel== REL_ALIAS) ++ f_print(fout,"%s(buf,objp->%s);\n",upp_case,decl->name); ++ else ++ f_print(fout,"%s(buf,*genp++);\n",upp_case); ++ ++ else ++ f_print(fout,"%s(buf);\n",upp_case); ++ if(!freed) ++ free(upp_case); ++ ++} ++ ++ ++static char * ++upcase(char *str) ++{ ++ char *ptr, *hptr; ++ ++ ++ ptr = (char *) malloc(strlen(str)+1); ++ if (ptr == (char *) NULL) { ++ f_print(stderr, "malloc failed \n"); ++ exit(1); ++ }; ++ ++ hptr = ptr; ++ while (*str != '\0') ++ *ptr++ = toupper(*str++); ++ ++ *ptr = '\0'; ++ return (hptr); ++ ++} +--- libtirpc-0.2.3/rpcgen/rpcgen.1.0005~ 2013-02-11 21:47:03.991289244 +0100 ++++ libtirpc-0.2.3/rpcgen/rpcgen.1 2013-02-11 21:47:03.991289244 +0100 +@@ -0,0 +1,521 @@ ++.\" @(#)rpcgen.1 1.35 93/06/02 SMI ++.\" $FreeBSD: src/usr.bin/rpcgen/rpcgen.1,v 1.12.2.4 2002/06/21 15:28:50 charnier Exp $ ++.\" Copyright 1985-1993 Sun Microsystems, Inc. ++.Dd March 28, 1993 ++.Dt RPCGEN 1 ++.Os ++.Sh NAME ++.Nm rpcgen ++.Nd an RPC protocol compiler ++.Sh SYNOPSIS ++.Nm ++.Ar infile ++.Nm ++.Op Fl a ++.Op Fl b ++.Op Fl C ++.Oo ++.Fl D Ns Ar name Ns Op Ar =value ++.Oc ++.Op Fl i Ar size ++.Op Fl I Op Fl K Ar seconds ++.Op Fl L ++.Op Fl M ++.Op Fl N ++.Op Fl T ++.Op Fl Y Ar pathname ++.Ar infile ++.Nm ++.Oo ++.Fl c | ++.Fl h | ++.Fl l | ++.Fl m | ++.Fl t | ++.Fl \&Sc | ++.Fl \&Ss | ++.Fl \&Sm ++.Oc ++.Op Fl o Ar outfile ++.Op Ar infile ++.Nm ++.Op Fl s Ar nettype ++.Op Fl o Ar outfile ++.Op Ar infile ++.Nm ++.Op Fl n Ar netid ++.Op Fl o Ar outfile ++.Op Ar infile ++.\" .SH AVAILABILITY ++.\" .LP ++.\" SUNWcsu ++.Sh DESCRIPTION ++The ++.Nm ++utility is a tool that generates C code to implement an ++.Tn RPC ++protocol. ++The input to ++.Nm ++is a language similar to C known as ++.Tn RPC ++Language (Remote Procedure Call Language). ++.Pp ++The ++.Nm ++utility is normally used as in the first synopsis where ++it takes an input file and generates three output files. ++If the ++.Ar infile ++is named ++.Pa proto.x , ++then ++.Nm ++generates a header in ++.Pa proto.h , ++XDR routines in ++.Pa proto_xdr.c , ++server-side stubs in ++.Pa proto_svc.c , ++and client-side stubs in ++.Pa proto_clnt.c . ++With the ++.Fl T ++option, ++it also generates the ++.Tn RPC ++dispatch table in ++.Pa proto_tbl.i . ++.Pp ++The ++.Nm ++utility can also generate sample client and server files ++that can be customized to suit a particular application. ++The ++.Fl \&Sc , ++.Fl \&Ss ++and ++.Fl \&Sm ++options generate sample client, server and makefile, respectively. ++The ++.Fl a ++option generates all files, including sample files. ++If the ++.Ar infile ++is ++.Pa proto.x , ++then the client side sample file is written to ++.Pa proto_client.c , ++the server side sample file to ++.Pa proto_server.c ++and the sample makefile to ++.Pa makefile.proto . ++.Pp ++The server created can be started both by the port monitors ++(for example, ++.Xr inetd 8 ) ++or by itself. ++When it is started by a port monitor, ++it creates servers only for the transport for which ++the file descriptor ++.Em 0 ++was passed. ++The name of the transport must be specified ++by setting up the environment variable ++.Ev PM_TRANSPORT . ++When the server generated by ++.Nm ++is executed, ++it creates server handles for all the transports ++specified in ++.Ev NETPATH ++environment variable, ++or if it is unset, ++it creates server handles for all the visible transports from ++.Pa /etc/netconfig ++file. ++Note: ++the transports are chosen at run time and not at compile time. ++When the server is self-started, ++it backgrounds itself by default. ++A special define symbol ++.Em RPC_SVC_FG ++can be used to run the server process in foreground. ++.Pp ++The second synopsis provides special features which allow ++for the creation of more sophisticated ++.Tn RPC ++servers. ++These features include support for user provided ++.Em #defines ++and ++.Tn RPC ++dispatch tables. ++The entries in the ++.Tn RPC ++dispatch table contain: ++.Bl -bullet -offset indent -compact ++.It ++pointers to the service routine corresponding to that procedure, ++.It ++a pointer to the input and output arguments, ++.It ++the size of these routines. ++.El ++A server can use the dispatch table to check authorization ++and then to execute the service routine; ++a client library may use it to deal with the details of storage ++management and XDR data conversion. ++.Pp ++The other three synopses shown above are used when ++one does not want to generate all the output files, ++but only a particular one. ++See the ++.Sx EXAMPLES ++section below for examples of ++.Nm ++usage. ++When ++.Nm ++is executed with the ++.Fl s ++option, ++it creates servers for that particular class of transports. ++When ++executed with the ++.Fl n ++option, ++it creates a server for the transport specified by ++.Ar netid . ++If ++.Ar infile ++is not specified, ++.Nm ++accepts the standard input. ++.Pp ++The C preprocessor, ++.Em cc -E ++is run on the input file before it is actually interpreted by ++.Nm . ++For each type of output file, ++.Nm ++defines a special preprocessor symbol for use by the ++.Nm ++programmer: ++.Bl -tag -width indent ++.It RPC_HDR ++defined when compiling into headers ++.It RPC_XDR ++defined when compiling into XDR routines ++.It RPC_SVC ++defined when compiling into server-side stubs ++.It RPC_CLNT ++defined when compiling into client-side stubs ++.It RPC_TBL ++defined when compiling into RPC dispatch tables ++.El ++.Pp ++Any line beginning with ++.Dq % ++is passed directly into the output file, ++uninterpreted by ++.Nm . ++To specify the path name of the C preprocessor use ++.Fl Y ++flag. ++.Pp ++For every data type referred to in ++.Ar infile , ++.Nm ++assumes that there exists a ++routine with the string ++.Em xdr_ ++prepended to the name of the data type. ++If this routine does not exist in the ++.Tn RPC/XDR ++library, it must be provided. ++Providing an undefined data type ++allows customization of ++.Xr xdr 3 ++routines. ++.Sh OPTIONS ++The following options are available: ++.Bl -tag -width indent ++.It Fl a ++Generate all files, including sample files. ++.It Fl b ++Backward compatibility mode. ++Generate transport specific ++.Tn RPC ++code for older versions ++of the operating system. ++.Pp ++Note: in ++.Fx , ++this compatibility flag is turned on by ++default since ++.Fx ++supports only the older ++.Tn ONC RPC ++library. ++.It Fl c ++Compile into ++.Tn XDR ++routines. ++.It Fl C ++Generate header and stub files which can be used with ++.Tn ANSI ++C compilers. Headers generated with this flag can also be ++used with C++ programs. ++.It Fl D Ns Ar name ++.It Fl D Ns Ar name=value ++.\".It Fl D Ns Ar name Ns Op Ar =value ++Define a symbol ++.Ar name . ++Equivalent to the ++.Em #define ++directive in the source. ++If no ++.Ar value ++is given, ++.Ar value ++is defined as ++.Em 1 . ++This option may be specified more than once. ++.It Fl h ++Compile into C data-definitions (a header). ++.Fl T ++option can be used in conjunction to produce a ++header which supports ++.Tn RPC ++dispatch tables. ++.It Fl i Ar size ++Size at which to start generating inline code. ++This option is useful for optimization. ++The default size is 5. ++.Pp ++Note: in order to provide backwards compatibility with the older ++.Nm ++on the ++.Fx ++platform, the default is actually 0 (which means ++that inline code generation is disabled by default). You must specify ++a non-zero value explicitly to override this default. ++.It Fl I ++Compile support for ++.Xr inetd 8 ++in the server side stubs. ++Such servers can be self-started or can be started by ++.Nm inetd . ++When the server is self-started, it backgrounds itself by default. ++A special define symbol ++.Em RPC_SVC_FG ++can be used to run the ++server process in foreground, or the user may simply compile without ++the ++.Fl I ++option. ++.Pp ++If there are no pending client requests, the ++.Nm inetd ++servers exit after 120 seconds (default). ++The default can be changed with the ++.Fl K ++option. ++All the error messages for ++.Nm inetd ++servers ++are always logged with ++.Xr syslog 3 . ++.\" .IP ++.\" Note: ++.\" this option is supported for backward compatibility only. ++.\" By default, ++.\" .B rpcgen ++.\" generates servers that can be invoked through portmonitors. ++.Pp ++.It Fl K Ar seconds ++By default, services created using ++.Nm ++and invoked through ++port monitors wait 120 seconds ++after servicing a request before exiting. ++That interval can be changed using the ++.Fl K ++flag. ++To create a server that exits immediately upon servicing a request, ++use ++.Fl K Ar 0 . ++To create a server that never exits, the appropriate argument is ++.Fl k Ar -1 . ++.Pp ++When monitoring for a server, ++some portmonitors ++.Em always ++spawn a new process in response to a service request. ++If it is known that a server will be used with such a monitor, the ++server should exit immediately on completion. ++For such servers, ++.Nm ++should be used with ++.Fl K Ar 0 . ++.It Fl l ++Compile into client-side stubs. ++.It Fl L ++When the servers are started in foreground, use ++.Xr syslog 3 ++to log the server errors instead of printing them on the standard ++error. ++.It Fl m ++Compile into server-side stubs, ++but do not generate a ++.Qq main ++routine. ++This option is useful for doing callback-routines ++and for users who need to write their own ++.Qq main ++routine to do initialization. ++.It Fl M ++Generate multithread-safe stubs for passing arguments and results between ++rpcgen generated code and user written code. ++This option is useful ++for users who want to use threads in their code. ++However, the ++.Xr rpc_svc_calls 3 ++functions are not yet MT-safe, which means that rpcgen generated server-side ++code will not be MT-safe. ++.It Fl N ++This option allows procedures to have multiple arguments. ++It also uses the style of parameter passing that closely resembles C. ++So, when passing an argument to a remote procedure, you do not have to ++pass a pointer to the argument, but can pass the argument itself. ++This behavior is different from the old style of ++.Nm ++generated code. ++To maintain backward compatibility, ++this option is not the default. ++.It Fl n Ar netid ++Compile into server-side stubs for the transport ++specified by ++.Ar netid . ++There should be an entry for ++.Ar netid ++in the ++netconfig database. ++This option may be specified more than once, ++so as to compile a server that serves multiple transports. ++.It Fl o Ar outfile ++Specify the name of the output file. ++If none is specified, ++standard output is used ++( ++.Fl c , ++.Fl h , ++.Fl l , ++.Fl m , ++.Fl n , ++.Fl s , ++.Fl \&Sc , ++.Fl \&Sm , ++.Fl \&Ss , ++and ++.Fl t ++modes only). ++.It Fl s Ar nettype ++Compile into server-side stubs for all the ++transports belonging to the class ++.Ar nettype . ++The supported classes are ++.Em netpath , ++.Em visible , ++.Em circuit_n , ++.Em circuit_v , ++.Em datagram_n , ++.Em datagram_v , ++.Em tcp , ++and ++.Em udp ++(see ++.Xr rpc 3 ++for the meanings associated with these classes). ++This option may be specified more than once. ++Note: ++the transports are chosen at run time and not at compile time. ++.It Fl \&Sc ++Generate sample client code that uses remote procedure calls. ++.It Fl \&Sm ++Generate a sample ++.Pa Makefile ++which can be used for compiling the application. ++.It Fl \&Ss ++Generate sample server code that uses remote procedure calls. ++.It Fl t ++Compile into ++.Tn RPC ++dispatch table. ++.It Fl T ++Generate the code to support ++.Tn RPC ++dispatch tables. ++.Pp ++The options ++.Fl c , ++.Fl h , ++.Fl l , ++.Fl m , ++.Fl s , ++.Fl \&Sc , ++.Fl \&Sm , ++.Fl \&Ss , ++and ++.Fl t ++are used exclusively to generate a particular type of file, ++while the options ++.Fl D ++and ++.Fl T ++are global and can be used with the other options. ++.It Fl Y Ar pathname ++Give the name of the directory where ++.Nm ++will start looking for the C-preprocessor. ++.El ++.Sh EXAMPLES ++The following example: ++.Dl example% rpcgen -T prot.x ++.Pp ++generates all the five files: ++.Pa prot.h , ++.Pa prot_clnt.c , ++.Pa prot_svc.c , ++.Pa prot_xdr.c ++and ++.Pa prot_tbl.i . ++.Pp ++The following example sends the C data-definitions (header) ++to the standard output. ++.Dl example% rpcgen -h prot.x ++.Pp ++To send the test version of the ++.Fl D Ns Ar TEST , ++server side stubs for ++all the transport belonging to the class ++.Ar datagram_n ++to standard output, use: ++.Dl example% rpcgen -s datagram_n -DTEST prot.x ++.Pp ++To create the server side stubs for the transport indicated ++by ++.Ar netid ++tcp, ++use: ++.Dl example% rpcgen -n tcp -o prot_svc.c prot.x ++.Sh SEE ALSO ++.Xr cc 1 , ++.Xr rpc 3 , ++.Xr syslog 3 , ++.Xr inetd 8 ++.\" .BR rpc_svc_calls (3) ++.Rs ++.%T The rpcgen chapter in the NETP manual ++.Re +--- libtirpc-0.2.3/rpcgen/rpc_hout.c.0005~ 2013-02-11 21:47:03.992289257 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_hout.c 2013-02-11 21:47:03.992289257 +0100 +@@ -0,0 +1,490 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#if 0 ++static char sccsid[] = "@(#)rpc_hout.c 1.12 89/02/22 (C) 1987 SMI"; ++#endif ++ ++/* ++ * rpc_hout.c, Header file outputter for the RPC protocol compiler ++ */ ++#include ++#include ++#include "rpc_parse.h" ++#include "rpc_util.h" ++#include "rpc_output.h" ++ ++ ++static int undefined2(char *type, char *stop); ++static void pxdrfuncdecl(char *name, int pointerp); ++static void pconstdef(definition *def); ++static void pargdef(definition *def); ++static void pstructdef(definition *def); ++static void puniondef(definition *def); ++static void pdefine(char *name, char *num); ++static void puldefine(char *name, char *num); ++static int define_printed(proc_list *stop, version_list *start); ++static void pprogramdef(definition *def); ++static void pprocdef(proc_list *proc, version_list *vp, ++ char *addargtype, int server_p, int mode); ++static void parglist(proc_list *proc, char *addargtype); ++static void penumdef(definition *def); ++static void ptypedef(definition *def); ++ ++/* ++ * Print the C-version of an xdr definition ++ */ ++void ++print_datadef(definition *def) ++{ ++ ++ if (def->def_kind == DEF_PROGRAM ) /* handle data only */ ++ return; ++ ++ if (def->def_kind != DEF_CONST) { ++ f_print(fout, "\n"); ++ } ++ switch (def->def_kind) { ++ case DEF_STRUCT: ++ pstructdef(def); ++ break; ++ case DEF_UNION: ++ puniondef(def); ++ break; ++ case DEF_ENUM: ++ penumdef(def); ++ break; ++ case DEF_TYPEDEF: ++ ptypedef(def); ++ break; ++ case DEF_PROGRAM: ++ pprogramdef(def); ++ break; ++ case DEF_CONST: ++ pconstdef(def); ++ break; ++ } ++ if (def->def_kind != DEF_PROGRAM && def->def_kind != DEF_CONST) { ++ pxdrfuncdecl( def->def_name, ++ def->def_kind != DEF_TYPEDEF || ++ !isvectordef(def->def.ty.old_type, def->def.ty.rel)); ++ ++ } ++} ++ ++ ++void ++print_funcdef(definition *def) ++{ ++ switch (def->def_kind) { ++ case DEF_PROGRAM: ++ f_print(fout, "\n"); ++ pprogramdef(def); ++ break; ++ default: ++ break; ++ } ++} ++ ++static void ++pxdrfuncdecl(char *name, int pointerp) ++{ ++ f_print(fout, ++ "#ifdef __cplusplus \n" ++ "extern \"C\" bool_t xdr_%s(XDR *, %s%s);\n" ++ "#elif __STDC__ \n" ++ "extern bool_t xdr_%s(XDR *, %s%s);\n" ++ "#else /* Old Style C */ \n" ++ "bool_t xdr_%s();\n" ++ "#endif /* Old Style C */ \n\n", ++ name, name, pointerp ? "*" : "", ++ name, name, pointerp ? "*" : "", ++ name); ++} ++ ++ ++static void ++pconstdef(definition *def) ++{ ++ pdefine(def->def_name, def->def.co); ++} ++ ++/* print out the definitions for the arguments of functions in the ++ header file ++*/ ++static void ++pargdef(definition *def) ++{ ++ decl_list *l; ++ version_list *vers; ++ char *name; ++ proc_list *plist; ++ ++ ++ for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) { ++ for(plist = vers->procs; plist != NULL; ++ plist = plist->next) { ++ ++ if (!newstyle || plist->arg_num < 2) { ++ continue; /* old style or single args */ ++ } ++ name = plist->args.argname; ++ f_print(fout, "struct %s {\n", name); ++ for (l = plist->args.decls; ++ l != NULL; l = l->next) { ++ pdeclaration(name, &l->decl, 1, ";\n" ); ++ } ++ f_print(fout, "};\n"); ++ f_print(fout, "typedef struct %s %s;\n", name, name); ++ pxdrfuncdecl(name, 0); ++ f_print( fout, "\n" ); ++ } ++ } ++ ++} ++ ++ ++static void ++pstructdef(definition *def) ++{ ++ decl_list *l; ++ char *name = def->def_name; ++ ++ f_print(fout, "struct %s {\n", name); ++ for (l = def->def.st.decls; l != NULL; l = l->next) { ++ pdeclaration(name, &l->decl, 1, ";\n"); ++ } ++ f_print(fout, "};\n"); ++ f_print(fout, "typedef struct %s %s;\n", name, name); ++} ++ ++static void ++puniondef(definition *def) ++{ ++ case_list *l; ++ char *name = def->def_name; ++ declaration *decl; ++ ++ f_print(fout, "struct %s {\n", name); ++ decl = &def->def.un.enum_decl; ++ if (streq(decl->type, "bool")) { ++ f_print(fout, "\tbool_t %s;\n", decl->name); ++ } else { ++ f_print(fout, "\t%s %s;\n", decl->type, decl->name); ++ } ++ f_print(fout, "\tunion {\n"); ++ for (l = def->def.un.cases; l != NULL; l = l->next) { ++ if (l->contflag == 0) ++ pdeclaration(name, &l->case_decl, 2, ";\n"); ++ } ++ decl = def->def.un.default_decl; ++ if (decl && !streq(decl->type, "void")) { ++ pdeclaration(name, decl, 2, ";\n"); ++ } ++ f_print(fout, "\t} %s_u;\n", name); ++ f_print(fout, "};\n"); ++ f_print(fout, "typedef struct %s %s;\n", name, name); ++} ++ ++static void ++pdefine(char *name, char *num) ++{ ++ f_print(fout, "#define %s %s\n", name, num); ++} ++ ++static void ++puldefine(char *name, char *num) ++{ ++ f_print(fout, "#define %s ((u_int32_t)%s)\n", name, num); ++} ++ ++static int ++define_printed(proc_list *stop, version_list *start) ++{ ++ version_list *vers; ++ proc_list *proc; ++ ++ for (vers = start; vers != NULL; vers = vers->next) { ++ for (proc = vers->procs; proc != NULL; proc = proc->next) { ++ if (proc == stop) { ++ return (0); ++ } else if (streq(proc->proc_name, stop->proc_name)) { ++ return (1); ++ } ++ } ++ } ++ abort(); ++ /* NOTREACHED */ ++} ++ ++static void ++pprogramdef(definition *def) ++{ ++ version_list *vers; ++ proc_list *proc; ++ int i; ++ char *ext; ++ ++ pargdef(def); ++ ++ puldefine(def->def_name, def->def.pr.prog_num); ++ for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) { ++ if (tblflag) { ++ f_print(fout, "extern struct rpcgen_table %s_%s_table[];\n", ++ locase(def->def_name), vers->vers_num); ++ f_print(fout, "extern %s_%s_nproc;\n", ++ locase(def->def_name), vers->vers_num); ++ } ++ puldefine(vers->vers_name, vers->vers_num); ++ ++ /* ++ * Print out 3 definitions, one for ANSI-C, another for C++, ++ * a third for old style C ++ */ ++ ++ for (i = 0; i < 3; i++) { ++ if (i == 0) { ++ f_print(fout, "\n#ifdef __cplusplus\n"); ++ ext = "extern \"C\" "; ++ } else if (i == 1) { ++ f_print(fout, "\n#elif __STDC__\n"); ++ ext = "extern "; ++ } else { ++ f_print(fout, "\n#else /* Old Style C */ \n"); ++ ext = "extern "; ++ } ++ ++ ++ for (proc = vers->procs; proc != NULL; proc = proc->next) { ++ if (!define_printed(proc, def->def.pr.versions)) { ++ puldefine(proc->proc_name, proc->proc_num); ++ } ++ f_print(fout, "%s", ext); ++ pprocdef(proc, vers, "CLIENT *", 0, i); ++ f_print(fout, "%s", ext); ++ pprocdef(proc, vers, "struct svc_req *", 1, i); ++ ++ } ++ ++ } ++ f_print(fout, "#endif /* Old Style C */ \n"); ++ } ++} ++ ++static void ++pprocdef(proc_list *proc, version_list *vp, char *addargtype, ++ int server_p, int mode) ++{ ++ ptype(proc->res_prefix, proc->res_type, 1); ++ f_print(fout, "* "); ++ if (server_p) ++ pvname_svc(proc->proc_name, vp->vers_num); ++ else ++ pvname(proc->proc_name, vp->vers_num); ++ ++ /* ++ * mode 0 == cplusplus, mode 1 = ANSI-C, mode 2 = old style C ++ */ ++ if (mode == 0 || mode == 1) ++ parglist(proc, addargtype); ++ else ++ f_print(fout, "();\n"); ++} ++ ++ ++ ++/* print out argument list of procedure */ ++static void ++parglist(proc_list *proc, char *addargtype) ++{ ++ decl_list *dl; ++ ++ f_print(fout, "("); ++ ++ if (proc->arg_num < 2 && newstyle && ++ streq(proc->args.decls->decl.type, "void")) { ++ /* 0 argument in new style: do nothing */ ++ } else { ++ for (dl = proc->args.decls; dl != NULL; dl = dl->next) { ++ ptype(dl->decl.prefix, dl->decl.type, 1); ++ if (!newstyle) ++ f_print(fout, "*"); /* old style passes by reference */ ++ ++ f_print(fout, ", "); ++ } ++ } ++ ++ f_print(fout, "%s);\n", addargtype); ++} ++ ++static void ++penumdef(definition *def) ++{ ++ char *name = def->def_name; ++ enumval_list *l; ++ char *last = NULL; ++ int count = 0; ++ ++ f_print(fout, "enum %s {\n", name); ++ for (l = def->def.en.vals; l != NULL; l = l->next) { ++ f_print(fout, "\t%s", l->name); ++ if (l->assignment) { ++ f_print(fout, " = %s", l->assignment); ++ last = l->assignment; ++ count = 1; ++ } else { ++ if (last == NULL) { ++ f_print(fout, " = %d", count++); ++ } else { ++ f_print(fout, " = %s + %d", last, count++); ++ } ++ } ++ f_print(fout, ",\n"); ++ } ++ f_print(fout, "};\n"); ++ f_print(fout, "typedef enum %s %s;\n", name, name); ++} ++ ++static void ++ptypedef(definition *def) ++{ ++ char *name = def->def_name; ++ char *old = def->def.ty.old_type; ++ char prefix[8]; /* enough to contain "struct ", including NUL */ ++ relation rel = def->def.ty.rel; ++ ++ ++ if (!streq(name, old)) { ++ if (streq(old, "string")) { ++ old = "char"; ++ rel = REL_POINTER; ++ } else if (streq(old, "opaque")) { ++ old = "char"; ++ } else if (streq(old, "bool")) { ++ old = "bool_t"; ++ } ++ if (undefined2(old, name) && def->def.ty.old_prefix) { ++ s_print(prefix, "%s ", def->def.ty.old_prefix); ++ } else { ++ prefix[0] = 0; ++ } ++ f_print(fout, "typedef "); ++ switch (rel) { ++ case REL_ARRAY: ++ f_print(fout, "struct {\n"); ++ f_print(fout, "\tu_int %s_len;\n", name); ++ f_print(fout, "\t%s%s *%s_val;\n", prefix, old, name); ++ f_print(fout, "} %s", name); ++ break; ++ case REL_POINTER: ++ f_print(fout, "%s%s *%s", prefix, old, name); ++ break; ++ case REL_VECTOR: ++ f_print(fout, "%s%s %s[%s]", prefix, old, name, ++ def->def.ty.array_max); ++ break; ++ case REL_ALIAS: ++ f_print(fout, "%s%s %s", prefix, old, name); ++ break; ++ } ++ f_print(fout, ";\n"); ++ } ++} ++ ++void ++pdeclaration(char *name, declaration *dec, int tab, char *separator) ++{ ++ char buf[8]; /* enough to hold "struct ", include NUL */ ++ char *prefix; ++ char *type; ++ ++ if (streq(dec->type, "void")) { ++ return; ++ } ++ tabify(fout, tab); ++ if (streq(dec->type, name) && !dec->prefix) { ++ f_print(fout, "struct "); ++ } ++ if (streq(dec->type, "string")) { ++ f_print(fout, "char *%s", dec->name); ++ } else { ++ prefix = ""; ++ if (streq(dec->type, "bool")) { ++ type = "bool_t"; ++ } else if (streq(dec->type, "opaque")) { ++ type = "char"; ++ } else { ++ if (dec->prefix) { ++ s_print(buf, "%s ", dec->prefix); ++ prefix = buf; ++ } ++ type = dec->type; ++ } ++ switch (dec->rel) { ++ case REL_ALIAS: ++ f_print(fout, "%s%s %s", prefix, type, dec->name); ++ break; ++ case REL_VECTOR: ++ f_print(fout, "%s%s %s[%s]", prefix, type, dec->name, ++ dec->array_max); ++ break; ++ case REL_POINTER: ++ f_print(fout, "%s%s *%s", prefix, type, dec->name); ++ break; ++ case REL_ARRAY: ++ f_print(fout, "struct {\n"); ++ tabify(fout, tab); ++ f_print(fout, "\tu_int %s_len;\n", dec->name); ++ tabify(fout, tab); ++ f_print(fout, "\t%s%s *%s_val;\n", prefix, type, dec->name); ++ tabify(fout, tab); ++ f_print(fout, "} %s", dec->name); ++ break; ++ } ++ } ++ f_print(fout, separator ); ++} ++ ++static int ++undefined2(char *type, char *stop) ++{ ++ list *l; ++ definition *def; ++ ++ for (l = defined; l != NULL; l = l->next) { ++ def = (definition *) l->val; ++ if (def->def_kind != DEF_PROGRAM) { ++ if (streq(def->def_name, stop)) { ++ return (1); ++ } else if (streq(def->def_name, type)) { ++ return (0); ++ } ++ } ++ } ++ return (1); ++} +--- libtirpc-0.2.3/rpcgen/rpc_main.c.0005~ 2013-02-11 21:47:03.993289269 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_main.c 2013-02-11 21:47:03.993289269 +0100 +@@ -0,0 +1,1067 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#if 0 ++static char sccsid[] = "@(#)rpc_main.c 1.30 89/03/30 (C) 1987 SMI"; ++#endif ++ ++/* ++ * rpc_main.c, Top level of the RPC protocol compiler. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "rpc_parse.h" ++#include "rpc_util.h" ++#include "rpc_scan.h" ++ ++struct commandline { ++ int cflag; /* xdr C routines */ ++ int hflag; /* header file */ ++ int lflag; /* client side stubs */ ++ int mflag; /* server side stubs */ ++ int nflag; /* netid flag */ ++ int sflag; /* server stubs for the given transport */ ++ int tflag; /* dispatch Table file */ ++ int Ssflag; /* produce server sample code */ ++ int Scflag; /* produce client sample code */ ++ char *infile; /* input module name */ ++ char *outfile; /* output module name */ ++}; ++ ++static char * extendfile(char *file, char *ext); ++static void open_output(char *infile, char *outfile); ++static void add_warning(void); ++static void clear_args(void); ++static void open_input(char *infile, char *define); ++static int check_nettype(char *name, char **list_to_check); ++static void c_output(char *infile, char *define, int extend, char *outfile); ++static void c_initialize(void); ++static char * generate_guard(char *pathname); ++static void h_output(char *infile, char *define, int extend, char *outfile); ++static void s_output(int argc, char **argv, char *infile, ++ char *define, int extend, char *outfile, ++ int nomain, int netflag); ++static void l_output(char *infile, char *define, int extend, char *outfile); ++static void t_output(char *infile, char *define, int extend, char *outfile); ++static void svc_output(char *, char *, int, char *); ++static void clnt_output(char *, char *, int, char *); ++static int do_registers(int argc, char **argv); ++static void addarg(char *cp); ++static void putarg(int where, char *cp); ++static void checkfiles(char *infile, char *outfile); ++static int parseargs(int argc, char **argv, struct commandline *cmd); ++static void usage(void); ++static void options_usage(void); ++ ++/* ++extern void write_sample_svc(); ++int write_sample_clnt(); ++void write_sample_clnt_main(); ++ ++static svc_output(); ++ */ ++ ++#define EXTEND 1 /* alias for TRUE */ ++#define DONT_EXTEND 0 /* alias for FALSE */ ++ ++#define SVR4_CPP "/usr/ccs/lib/cpp" ++#define SUNOS_CPP "/lib/cpp" ++static int cppDefined = 0; /* explicit path for C preprocessor */ ++ ++ ++static char *cmdname; ++ ++static char *svcclosetime = "120"; ++static char *CPP = SVR4_CPP; ++static char CPPFLAGS[] = "-C"; ++static char pathbuf[MAXPATHLEN + 1]; ++static char *allv[] = { ++ "rpcgen", "-s", "udp", "-s", "tcp", ++}; ++static int allc = sizeof(allv)/sizeof(allv[0]); ++static char *allnv[] = { ++ "rpcgen", "-s", "netpath", ++}; ++static int allnc = sizeof(allnv)/sizeof(allnv[0]); ++ ++/* ++ * machinations for handling expanding argument list ++ */ ++#if 0 ++static void addarg(); /* add another argument to the list */ ++static void putarg(); /* put argument at specified location */ ++static void clear_args(); /* clear argument list */ ++static void checkfiles(); /* check if out file already exists */ ++#endif ++ ++ ++ ++#define ARGLISTLEN 20 ++#define FIXEDARGS 2 ++ ++static char *arglist[ARGLISTLEN]; ++static int argcount = FIXEDARGS; ++ ++ ++int nonfatalerrors; /* errors */ ++int inetdflag/* = 1*/; /* Support for inetd */ /* is now the default */ ++int pmflag; /* Support for port monitors */ ++int logflag; /* Use syslog instead of fprintf for errors */ ++int tblflag; /* Support for dispatch table file */ ++ ++/* length at which to start doing an inline */ ++#define INLINE 3 ++ ++int Inline = INLINE; /* length at which to start doing an inline. 3 = default ++ * if 0, no xdr_inline code */ ++ ++int indefinitewait; /* If started by port monitors, hang till it wants */ ++int exitnow; /* If started by port monitors, exit after the call */ ++int timerflag; /* TRUE if !indefinite && !exitnow */ ++int newstyle; /* newstyle of passing arguments (by value) */ ++int Cflag = 0 ; /* ANSI C syntax */ ++static int allfiles; /* generate all files */ ++#ifdef linux ++int tirpcflag = 0; /* no tirpc by default */ ++#else ++int tirpcflag = 1; /* generating code for tirpc, by default */ ++#endif ++ ++int ++main(int argc, char **argv) ++{ ++ struct commandline cmd; ++ ++ (void) memset((char *) &cmd, 0, sizeof(struct commandline)); ++ clear_args(); ++ if (!parseargs(argc, argv, &cmd)) ++ usage(); ++ ++ if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag || ++ cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag) { ++ checkfiles(cmd.infile, cmd.outfile); ++ } else ++ checkfiles(cmd.infile, NULL); ++ ++ if (cmd.cflag) { ++ c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile); ++ } else if (cmd.hflag) { ++ h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile); ++ } else if (cmd.lflag) { ++ l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile); ++ } else if (cmd.sflag || cmd.mflag || (cmd.nflag)) { ++ s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND, ++ cmd.outfile, cmd.mflag, cmd.nflag); ++ } else if (cmd.tflag) { ++ t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile); ++ } else if (cmd.Ssflag) { ++ svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile); ++ } else if (cmd.Scflag) { ++ clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile); ++ } else { ++ /* the rescans are required, since cpp may effect input */ ++ c_output(cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c"); ++ reinitialize(); ++ h_output(cmd.infile, "-DRPC_HDR", EXTEND, ".h"); ++ reinitialize(); ++ l_output(cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c"); ++ reinitialize(); ++ if (inetdflag || !tirpcflag) ++ s_output(allc, allv, cmd.infile, "-DRPC_SVC", EXTEND, ++ "_svc.c", cmd.mflag, cmd.nflag); ++ else ++ s_output(allnc, allnv, cmd.infile, "-DRPC_SVC", ++ EXTEND, "_svc.c", cmd.mflag, cmd.nflag); ++ if (tblflag) { ++ reinitialize(); ++ t_output(cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i"); ++ } ++ if (allfiles) { ++ reinitialize(); ++ svc_output(cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c"); ++ } ++ if (allfiles) { ++ reinitialize(); ++ clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c"); ++ } ++ } ++ exit(nonfatalerrors); ++ /* NOTREACHED */ ++} ++ ++/* ++ * add extension to filename ++ */ ++static char * ++extendfile(char *file, char *ext) ++{ ++ char *res; ++ char *p; ++ ++ res = alloc(strlen(file) + strlen(ext) + 1); ++ if (res == NULL) { ++ abort(); ++ } ++ p = strrchr(file, '.'); ++ if (p == NULL) { ++ p = file + strlen(file); ++ } ++ (void) strcpy(res, file); ++ (void) strcpy(res + (p - file), ext); ++ return (res); ++} ++ ++/* ++ * Open output file with given extension ++ */ ++static void ++open_output(char *infile, char *outfile) ++{ ++ ++ if (outfile == NULL) { ++ fout = stdout; ++ return; ++ } ++ ++ if (infile != NULL && streq(outfile, infile)) { ++ f_print(stderr, "%s: output would overwrite %s\n", cmdname, ++ infile); ++ crash(); ++ } ++ fout = fopen(outfile, "w"); ++ if (fout == NULL) { ++ f_print(stderr, "%s: unable to open ", cmdname); ++ perror(outfile); ++ crash(); ++ } ++ record_open(outfile); ++ ++} ++ ++static void ++add_warning(void) ++{ ++ f_print(fout, "/*\n"); ++ f_print(fout, " * Please do not edit this file.\n"); ++ f_print(fout, " * It was generated using rpcgen.\n"); ++ f_print(fout, " */\n\n"); ++} ++ ++/* clear list of arguments */ ++static void ++clear_args(void) ++{ ++ int i; ++ for( i=FIXEDARGS; i" : infile; ++ (void) pipe(pd); ++ switch (fork()) { ++ case 0: ++ putarg(0, "cpp"); ++ putarg(1, CPPFLAGS); ++ addarg(define); ++ addarg(infile); ++ addarg((char *)NULL); ++ (void) close(1); ++ (void) dup2(pd[1], 1); ++ (void) close(pd[0]); ++ if (cppDefined) ++ execv(CPP, arglist); ++ else { ++ execvp("cpp", arglist); ++ if (errno == ENOENT) ++ execvp(SVR4_CPP, arglist); ++ if (errno == ENOENT) ++ execvp(SUNOS_CPP, arglist); ++ } ++ perror("execv"); ++ exit(1); ++ case -1: ++ perror("fork"); ++ exit(1); ++ } ++ (void) close(pd[1]); ++ fin = fdopen(pd[0], "r"); ++ if (fin == NULL) { ++ f_print(stderr, "%s: ", cmdname); ++ perror(infilename); ++ crash(); ++ } ++} ++ ++/* valid tirpc nettypes */ ++static char* valid_ti_nettypes[] = ++{ ++ "netpath", ++ "visible", ++ "circuit_v", ++ "datagram_v", ++ "circuit_n", ++ "datagram_n", ++ "udp", ++ "tcp", ++ "raw", ++ NULL ++}; ++ ++/* valid inetd nettypes */ ++static char* valid_i_nettypes[] = ++{ ++ "udp", ++ "tcp", ++ NULL ++}; ++ ++static int ++check_nettype(char *name, char **list_to_check) ++{ ++ int i; ++ for( i = 0; list_to_check[i] != NULL; i++ ) { ++ if( strcmp( name, list_to_check[i] ) == 0 ) { ++ return 1; ++ } ++ } ++ f_print( stderr, "illegal nettype :\'%s\'\n", name ); ++ return 0; ++} ++ ++/* ++ * Compile into an XDR routine output file ++ */ ++ ++static void ++c_output(char *infile, char *define, int extend, char *outfile) ++{ ++ definition *def; ++ char *include; ++ char *outfilename; ++ long tell; ++ ++ c_initialize(); ++ open_input(infile, define); ++ outfilename = extend ? extendfile(infile, outfile) : outfile; ++ open_output(infile, outfilename); ++ add_warning(); ++ if (infile && (include = extendfile(infile, ".h"))) { ++ f_print(fout, "#include \"%s\"\n", include); ++ free(include); ++ /* .h file already contains rpc/rpc.h */ ++ } else ++ f_print(fout, "#include \n"); ++ tell = ftell(fout); ++ while ((def = get_definition()) != NULL) { ++ emit(def); ++ } ++ if (extend && tell == ftell(fout)) { ++ (void) unlink(outfilename); ++ } ++} ++ ++ ++static void ++c_initialize(void) ++{ ++ ++ /* add all the starting basic types */ ++ ++ add_type(1,"int"); ++ add_type(1,"int32_t"); ++ add_type(1,"short"); ++ add_type(1,"bool"); ++ ++ add_type(1,"u_int"); ++ add_type(1,"u_int32_t"); ++ add_type(1,"u_short"); ++ ++} ++ ++char rpcgen_table_dcl[] = "struct rpcgen_table {\n\ ++ char *(*proc)();\n\ ++ xdrproc_t xdr_arg;\n\ ++ unsigned len_arg;\n\ ++ xdrproc_t xdr_res;\n\ ++ unsigned len_res;\n\ ++};\n"; ++ ++ ++static char * ++generate_guard(char *pathname) ++{ ++ char* filename, *guard, *tmp; ++ ++ filename = strrchr(pathname, '/' ); /* find last component */ ++ filename = ((filename == 0) ? pathname : filename+1); ++ guard = strdup(filename); ++ /* convert to upper case */ ++ tmp = guard; ++ while (*tmp) { ++ if (islower(*tmp)) ++ *tmp = toupper(*tmp); ++ tmp++; ++ } ++ ++ guard = extendfile(guard, "_H_RPCGEN"); ++ return( guard ); ++} ++ ++/* ++ * Compile into an XDR header file ++ */ ++static void ++h_output(char *infile, char *define, int extend, char *outfile) ++{ ++ definition *def; ++ char *outfilename; ++ long tell; ++ char *guard; ++ list *l; ++ ++ open_input(infile, define); ++ outfilename = extend ? extendfile(infile, outfile) : outfile; ++ open_output(infile, outfilename); ++ add_warning(); ++ guard = generate_guard( outfilename ? outfilename: infile ); ++ ++ f_print(fout,"#ifndef _%s\n#define _%s\n\n", guard, ++ guard); ++ ++ f_print(fout, "#include \n\n"); ++ ++ f_print(fout, "#ifndef IXDR_GET_INT32\n"); ++ f_print(fout, "#define IXDR_GET_INT32(buf) IXDR_GET_LONG((buf))\n"); ++ f_print(fout, "#endif\n"); ++ f_print(fout, "#ifndef IXDR_PUT_INT32\n"); ++ f_print(fout, "#define IXDR_PUT_INT32(buf, v) IXDR_PUT_LONG((buf), (v))\n"); ++ f_print(fout, "#endif\n"); ++ f_print(fout, "#ifndef IXDR_GET_U_INT32\n"); ++ f_print(fout, "#define IXDR_GET_U_INT32(buf) IXDR_GET_U_LONG((buf))\n"); ++ f_print(fout, "#endif\n"); ++ f_print(fout, "#ifndef IXDR_PUT_U_INT32\n"); ++ f_print(fout, "#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_U_LONG((buf), (v))\n"); ++ f_print(fout, "#endif\n"); ++ ++ tell = ftell(fout); ++ /* print data definitions */ ++ while ((def = get_definition()) != NULL) { ++ print_datadef(def); ++ } ++ ++ /* print function declarations. ++ Do this after data definitions because they might be used as ++ arguments for functions */ ++ for (l = defined; l != NULL; l = l->next) { ++ print_funcdef(l->val); ++ } ++ if (extend && tell == ftell(fout)) { ++ (void) unlink(outfilename); ++ } else if (tblflag) { ++ f_print(fout, rpcgen_table_dcl); ++ } ++ f_print(fout, "\n#endif /* !_%s */\n", guard); ++} ++ ++/* ++ * Compile into an RPC service ++ */ ++static void ++s_output(int argc, char **argv, char *infile, char *define, int extend, ++ char *outfile, int nomain, int netflag) ++{ ++ char *include; ++ definition *def; ++ int foundprogram = 0; ++ char *outfilename; ++ ++ open_input(infile, define); ++ outfilename = extend ? extendfile(infile, outfile) : outfile; ++ open_output(infile, outfilename); ++ add_warning(); ++ if (infile && (include = extendfile(infile, ".h"))) { ++ f_print(fout, "#include \"%s\"\n", include); ++ free(include); ++ } else ++ f_print(fout, "#include \n"); ++ ++ f_print(fout, "#include \n"); ++ f_print(fout, "#include /* getenv, exit */\n"); ++ if (Cflag) { ++ f_print (fout, "#include /* for pmap_unset */\n"); ++ f_print (fout, "#include /* strcmp */ \n"); ++ } ++ if (strcmp(svcclosetime, "-1") == 0) ++ indefinitewait = 1; ++ else if (strcmp(svcclosetime, "0") == 0) ++ exitnow = 1; ++ else if (inetdflag || pmflag) { ++ f_print(fout, "#include \n"); ++ timerflag = 1; ++ } ++ ++#ifndef linux ++ if( !tirpcflag && inetdflag ) ++ f_print(fout, "#include /* TIOCNOTTY */\n"); ++#else ++ if( !tirpcflag ) ++ f_print(fout, "#include /* TIOCNOTTY */\n"); ++#endif ++ if( Cflag && (inetdflag || pmflag ) ) { ++ f_print(fout, "#ifdef __cplusplus\n"); ++ f_print(fout, "#include /* getdtablesize, open */\n"); ++ f_print(fout, "#endif /* __cplusplus */\n"); ++ ++ if( tirpcflag ) ++ f_print(fout, "#include /* setsid */\n"); ++ } ++ if( tirpcflag ) ++ f_print(fout, "#include \n"); ++ ++ f_print(fout, "#include \n"); ++#ifndef linux ++ f_print(fout, "#include \n"); ++#endif ++ if (inetdflag || !tirpcflag ) { ++ f_print(fout, "#include \n"); ++ f_print(fout, "#include \n"); ++ } ++ ++ if ( (netflag || pmflag) && tirpcflag ) { ++ f_print(fout, "#include \n"); ++ } ++ if (/*timerflag &&*/ tirpcflag) ++ f_print(fout, "#include /* rlimit */\n"); ++ if (logflag || inetdflag || pmflag) { ++#ifdef linux ++ f_print(fout, "#include \n"); ++#else ++ f_print(fout, "#ifdef SYSLOG\n"); ++ f_print(fout, "#include \n"); ++ f_print(fout, "#else\n"); ++ f_print(fout, "#define LOG_ERR 1\n"); ++ f_print(fout, "#define openlog(a, b, c)\n"); ++ f_print(fout, "#endif\n"); ++#endif ++ } ++ ++ /* for ANSI-C */ ++ f_print(fout, "\n#ifdef __STDC__\n#define SIG_PF void(*)(int)\n#endif\n"); ++ ++ f_print(fout, "\n#ifdef DEBUG\n#define RPC_SVC_FG\n#endif\n"); ++ if (timerflag) ++ f_print(fout, "\n#define _RPCSVC_CLOSEDOWN %s\n", svcclosetime); ++ while ((def = get_definition()) != NULL) { ++ foundprogram |= (def->def_kind == DEF_PROGRAM); ++ } ++ if (extend && !foundprogram) { ++ (void) unlink(outfilename); ++ return; ++ } ++ write_most(infile, netflag, nomain); ++ if (!nomain) { ++ if( !do_registers(argc, argv) ) { ++ if (outfilename) ++ (void) unlink(outfilename); ++ usage(); ++ } ++ write_rest(); ++ } ++} ++ ++/* ++ * generate client side stubs ++ */ ++static void ++l_output(char *infile, char *define, int extend, char *outfile) ++{ ++ char *include; ++ definition *def; ++ int foundprogram = 0; ++ char *outfilename; ++ ++ open_input(infile, define); ++ outfilename = extend ? extendfile(infile, outfile) : outfile; ++ open_output(infile, outfilename); ++ add_warning(); ++ if (Cflag) ++ f_print (fout, "#include /* for memset */\n"); ++ if (infile && (include = extendfile(infile, ".h"))) { ++ f_print(fout, "#include \"%s\"\n", include); ++ free(include); ++ } else ++ f_print(fout, "#include \n"); ++ while ((def = get_definition()) != NULL) { ++ foundprogram |= (def->def_kind == DEF_PROGRAM); ++ } ++ if (extend && !foundprogram) { ++ (void) unlink(outfilename); ++ return; ++ } ++ write_stubs(); ++} ++ ++/* ++ * generate the dispatch table ++ */ ++static void ++t_output(char *infile, char *define, int extend, char *outfile) ++{ ++ definition *def; ++ int foundprogram = 0; ++ char *outfilename; ++ ++ open_input(infile, define); ++ outfilename = extend ? extendfile(infile, outfile) : outfile; ++ open_output(infile, outfilename); ++ add_warning(); ++ while ((def = get_definition()) != NULL) { ++ foundprogram |= (def->def_kind == DEF_PROGRAM); ++ } ++ if (extend && !foundprogram) { ++ (void) unlink(outfilename); ++ return; ++ } ++ write_tables(); ++} ++ ++/* sample routine for the server template */ ++static void ++svc_output(char *infile, char *define, int extend, char *outfile) ++{ ++ definition *def; ++ char *include; ++ char *outfilename; ++ long tell; ++ ++ open_input(infile, define); ++ outfilename = extend ? extendfile(infile, outfile) : outfile; ++ checkfiles(infile,outfilename); /*check if outfile already exists. ++ if so, print an error message and exit*/ ++ open_output(infile, outfilename); ++ add_sample_msg(); ++ ++ if (infile && (include = extendfile(infile, ".h"))) { ++ f_print(fout, "#include \"%s\"\n", include); ++ free(include); ++ } else ++ f_print(fout, "#include \n"); ++ ++ tell = ftell(fout); ++ while ((def = get_definition()) != NULL) { ++ write_sample_svc(def); ++ } ++ if (extend && tell == ftell(fout)) { ++ (void) unlink(outfilename); ++ } ++} ++ ++ ++/* sample main routine for client */ ++static void ++clnt_output(char *infile, char *define, int extend, char *outfile) ++{ ++ definition *def; ++ char *include; ++ char *outfilename; ++ long tell; ++ int has_program = 0; ++ ++ open_input(infile, define); ++ outfilename = extend ? extendfile(infile, outfile) : outfile; ++ checkfiles(infile, outfilename); /*check if outfile already exists. ++ if so, print an error message and exit*/ ++ ++ open_output(infile, outfilename); ++ add_sample_msg(); ++ if (infile && (include = extendfile(infile, ".h"))) { ++ f_print(fout, "#include \"%s\"\n", include); ++ free(include); ++ } else ++ f_print(fout, "#include \n"); ++ tell = ftell(fout); ++ while ((def = get_definition()) != NULL) { ++ has_program += write_sample_clnt(def); ++ } ++ ++ if (has_program) ++ write_sample_clnt_main(); ++ ++ if (extend && tell == ftell(fout)) { ++ (void) unlink(outfilename); ++ } ++} ++ ++/* ++ * Perform registrations for service output ++ * Return 0 if failed; 1 otherwise. ++ */ ++static int ++do_registers(int argc, char **argv) ++{ ++ int i; ++ ++ if (inetdflag || !tirpcflag) { ++ for (i = 1; i < argc; i++) { ++ if (streq(argv[i], "-s")) { ++ if (!check_nettype(argv[i + 1], valid_i_nettypes)) ++ return 0; ++ write_inetd_register(argv[i + 1]); ++ i++; ++ } ++ } ++ } else { ++ for (i = 1; i < argc; i++) ++ if (streq(argv[i], "-s")) { ++ if (!check_nettype(argv[i + 1], valid_ti_nettypes)) ++ return 0; ++ write_nettype_register(argv[i + 1]); ++ i++; ++ } else if (streq(argv[i], "-n")) { ++ write_netid_register(argv[i + 1]); ++ i++; ++ } ++ } ++ return 1; ++} ++ ++/* ++ * Add another argument to the arg list ++ */ ++static void ++addarg(char *cp) ++{ ++ if (argcount >= ARGLISTLEN) { ++ f_print(stderr, "rpcgen: too many defines\n"); ++ crash(); ++ /*NOTREACHED*/ ++ } ++ arglist[argcount++] = cp; ++ ++} ++ ++static void ++putarg(int where, char *cp) ++{ ++ if (where >= ARGLISTLEN) { ++ f_print(stderr, "rpcgen: arglist coding error\n"); ++ crash(); ++ /*NOTREACHED*/ ++ } ++ arglist[where] = cp; ++ ++} ++ ++/* ++ * if input file is stdin and an output file is specified then complain ++ * if the file already exists. Otherwise the file may get overwritten ++ * If input file does not exist, exit with an error ++ */ ++ ++static void ++checkfiles(char *infile, char *outfile) ++{ ++ ++ struct stat buf; ++ ++ if(infile) /* infile ! = NULL */ ++ if(stat(infile,&buf) < 0) ++ { ++ perror(infile); ++ crash(); ++ }; ++ if (outfile) { ++ if (stat(outfile, &buf) < 0) ++ return; /* file does not exist */ ++ else { ++ f_print(stderr, ++ "file '%s' already exists and may be overwritten\n", outfile); ++ crash(); ++ } ++ } ++} ++ ++/* ++ * Parse command line arguments ++ */ ++static int ++parseargs(int argc, char **argv, struct commandline *cmd) ++{ ++ int i; ++ int j; ++ char c; ++ char flag[(1 << 8 * sizeof(char))]; ++ int nflags; ++ ++ cmdname = argv[0]; ++ cmd->infile = cmd->outfile = NULL; ++ if (argc < 2) { ++ return (0); ++ } ++ allfiles = 0; ++ flag['c'] = 0; ++ flag['h'] = 0; ++ flag['l'] = 0; ++ flag['m'] = 0; ++ flag['o'] = 0; ++ flag['s'] = 0; ++ flag['n'] = 0; ++ flag['t'] = 0; ++ flag['S'] = 0; ++ flag['C'] = 0; ++ for (i = 1; i < argc; i++) { ++ if (argv[i][0] != '-') { ++ if (cmd->infile) { ++ f_print( stderr, "Cannot specify more than one input file!\n"); ++ ++ return (0); ++ } ++ cmd->infile = argv[i]; ++ } else { ++ for (j = 1; argv[i][j] != 0; j++) { ++ c = argv[i][j]; ++ switch (c) { ++ case 'a': ++ allfiles = 1; ++ break; ++ case 'c': ++ case 'h': ++ case 'l': ++ case 'm': ++ case 't': ++ if (flag[(int) c]) { ++ return (0); ++ } ++ flag[(int) c] = 1; ++ break; ++ case 'S': ++ /* sample flag: Ss or Sc. ++ Ss means set flag['S']; ++ Sc means set flag['C']; */ ++ c = argv[i][++j]; /* get next char */ ++ if( c == 's' ) ++ c = 'S'; ++ else if( c == 'c' ) ++ c = 'C'; ++ else ++ return( 0 ); ++ ++ if (flag[(int) c]) { ++ return (0); ++ } ++ flag[(int) c] = 1; ++ break; ++ case 'C': /* ANSI C syntax */ ++ Cflag = 1; ++ break; ++ ++ case 'b': /* turn TIRPC flag off for ++ generating backward compatible ++ */ ++ tirpcflag = 0; ++ break; ++ ++ case 'I': ++ inetdflag = 1; ++ break; ++ case 'N': ++ newstyle = 1; ++ break; ++ case 'L': ++ logflag = 1; ++ break; ++ case 'K': ++ if (++i == argc) { ++ return (0); ++ } ++ svcclosetime = argv[i]; ++ goto nextarg; ++ case 'T': ++ tblflag = 1; ++ break; ++ case 'i' : ++ if (++i == argc) { ++ return (0); ++ } ++ Inline = atoi(argv[i]); ++ goto nextarg; ++ case 'n': ++ case 'o': ++ case 's': ++ if (argv[i][j - 1] != '-' || ++ argv[i][j + 1] != 0) { ++ return (0); ++ } ++ flag[(int) c] = 1; ++ if (++i == argc) { ++ return (0); ++ } ++ if (c == 's') { ++ if (!streq(argv[i], "udp") && ++ !streq(argv[i], "tcp")) { ++ return (0); ++ } ++ } else if (c == 'o') { ++ if (cmd->outfile) { ++ return (0); ++ } ++ cmd->outfile = argv[i]; ++ } ++ goto nextarg; ++ case 'D': ++ if (argv[i][j - 1] != '-') { ++ return (0); ++ } ++ (void) addarg(argv[i]); ++ goto nextarg; ++ case 'Y': ++ if (++i == argc) { ++ return (0); ++ } ++ (void) strcpy(pathbuf, argv[i]); ++ (void) strcat(pathbuf, "/cpp"); ++ CPP = pathbuf; ++ cppDefined = 1; ++ goto nextarg; ++ ++ ++ ++ default: ++ return (0); ++ } ++ } ++ nextarg: ++ ; ++ } ++ } ++ ++ cmd->cflag = flag['c']; ++ cmd->hflag = flag['h']; ++ cmd->lflag = flag['l']; ++ cmd->mflag = flag['m']; ++ cmd->nflag = flag['n']; ++ cmd->sflag = flag['s']; ++ cmd->tflag = flag['t']; ++ cmd->Ssflag = flag['S']; ++ cmd->Scflag = flag['C']; ++ ++ if( tirpcflag ) { ++ pmflag = inetdflag ? 0 : 1; /* pmflag or inetdflag is always TRUE */ ++ if( (inetdflag && cmd->nflag)) { /* netid not allowed with inetdflag */ ++ f_print(stderr, "Cannot use netid flag with inetd flag!\n"); ++ return (0); ++ } ++ } else { /* 4.1 mode */ ++ pmflag = 0; /* set pmflag only in tirpcmode */ ++ inetdflag = 1; /* inetdflag is TRUE by default */ ++ if( cmd->nflag ) { /* netid needs TIRPC */ ++ f_print( stderr, "Cannot use netid flag without TIRPC!\n"); ++ return( 0 ); ++ } ++ } ++ ++ if( newstyle && ( tblflag || cmd->tflag) ) { ++ f_print( stderr, "Cannot use table flags with newstyle!\n"); ++ return( 0 ); ++ } ++ ++ /* check no conflicts with file generation flags */ ++ nflags = cmd->cflag + cmd->hflag + cmd->lflag + cmd->mflag + ++ cmd->sflag + cmd->nflag + cmd->tflag + cmd->Ssflag + cmd->Scflag; ++ ++ if (nflags == 0) { ++ if (cmd->outfile != NULL || cmd->infile == NULL) { ++ return (0); ++ } ++ } else if (nflags > 1) { ++ f_print( stderr, "Cannot have more than one file generation flag!\n"); ++ return (0); ++ } ++ return (1); ++} ++ ++static void ++usage(void) ++{ ++ f_print(stderr, "usage: %s infile\n", cmdname); ++ f_print(stderr, "\t%s [-a][-b][-C][-Dname[=value]] -i size [-I [-K seconds]] [-L][-N][-T] infile\n", ++ cmdname); ++ f_print(stderr, "\t%s [-c | -h | -l | -m | -t | -Sc | -Ss] [-o outfile] [infile]\n", ++ cmdname); ++ f_print(stderr, "\t%s [-s nettype]* [-o outfile] [infile]\n", cmdname); ++ f_print(stderr, "\t%s [-n netid]* [-o outfile] [infile]\n", cmdname); ++ options_usage(); ++ exit(1); ++} ++ ++static void ++options_usage(void) ++{ ++ f_print(stderr, "options:\n"); ++ f_print(stderr, "-a\t\tgenerate all files, including samples\n"); ++ f_print(stderr, "-b\t\tbackward compatibility mode (generates code for SunOS 4.1)\n"); ++ f_print(stderr, "-c\t\tgenerate XDR routines\n"); ++ f_print(stderr, "-C\t\tANSI C mode\n"); ++ f_print(stderr, "-Dname[=value]\tdefine a symbol (same as #define)\n"); ++ f_print(stderr, "-h\t\tgenerate header file\n"); ++ f_print(stderr, "-i size\t\tsize at which to start generating inline code\n"); ++ f_print(stderr, "-I\t\tgenerate code for inetd support in server (for SunOS 4.1)\n"); ++ f_print(stderr, "-K seconds\tserver exits after K seconds of inactivity\n"); ++ f_print(stderr, "-l\t\tgenerate client side stubs\n"); ++ f_print(stderr, "-L\t\tserver errors will be printed to syslog\n"); ++ f_print(stderr, "-m\t\tgenerate server side stubs\n"); ++ f_print(stderr, "-n netid\tgenerate server code that supports named netid\n"); ++ f_print(stderr, "-N\t\tsupports multiple arguments and call-by-value\n"); ++ f_print(stderr, "-o outfile\tname of the output file\n"); ++ f_print(stderr, "-s nettype\tgenerate server code that supports named nettype\n"); ++ f_print(stderr, "-Sc\t\tgenerate sample client code that uses remote procedures\n"); ++ f_print(stderr, "-Ss\t\tgenerate sample server code that defines remote procedures\n"); ++ f_print(stderr, "-t\t\tgenerate RPC dispatch table\n"); ++ f_print(stderr, "-T\t\tgenerate code to support RPC dispatch tables\n"); ++ f_print(stderr, "-Y path\t\tdirectory name to find C preprocessor (cpp)\n"); ++ ++ exit(1); ++} +--- libtirpc-0.2.3/rpcgen/rpc_output.h.0005~ 2013-02-11 21:47:03.993289269 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_output.h 2013-02-11 21:47:03.993289269 +0100 +@@ -0,0 +1,16 @@ ++/* ++ * rpc_output.h ++ * ++ * Declarations for output functions ++ * ++ */ ++ ++#ifndef RPCGEN_NEW_OUTPUT_H ++#define RPCGEN_NEW_OUTPUT_H ++ ++void write_msg_out(void); ++int nullproc(proc_list *); ++void printarglist(proc_list *, char *, char *); ++void pdeclaration(char *, declaration *, int, char *); ++ ++#endif /* RPCGEN_NEW_OUTPUT_H */ +--- libtirpc-0.2.3/rpcgen/rpc_parse.c.0005~ 2013-02-11 21:47:03.993289269 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_parse.c 2013-02-11 21:47:03.993289269 +0100 +@@ -0,0 +1,609 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#if 0 ++static char sccsid[] = "@(#)rpc_parse.c 1.8 89/02/22 (C) 1987 SMI"; ++#endif ++ ++/* ++ * rpc_parse.c, Parser for the RPC protocol compiler ++ * Copyright (C) 1987 Sun Microsystems, Inc. ++ */ ++#include ++#include ++#include "rpc/types.h" ++#include "rpc_scan.h" ++#include "rpc_parse.h" ++#include "rpc_util.h" ++ ++#define ARGNAME "arg" ++ ++/* ++extern char *make_argname(); ++extern char *strdup(); ++ */ ++ ++static void isdefined(definition *defp); ++static void def_struct(definition *defp); ++static void def_program(definition *defp); ++static void def_enum(definition *defp); ++static void def_const(definition *defp); ++static void def_union(definition *defp); ++static void check_type_name(char *name, int new_type); ++static void def_typedef(definition *defp); ++static void get_declaration(declaration *dec, defkind dkind); ++static void get_prog_declaration(declaration *dec, defkind dkind, int num); ++static void get_type(char **prefixp, char **typep, defkind dkind); ++static void unsigned_dec(char **typep); ++ ++/* ++ * return the next definition you see ++ */ ++definition * ++get_definition(void) ++{ ++ definition *defp; ++ token tok; ++ ++ defp = ALLOC(definition); ++ get_token(&tok); ++ switch (tok.kind) { ++ case TOK_STRUCT: ++ def_struct(defp); ++ break; ++ case TOK_UNION: ++ def_union(defp); ++ break; ++ case TOK_TYPEDEF: ++ def_typedef(defp); ++ break; ++ case TOK_ENUM: ++ def_enum(defp); ++ break; ++ case TOK_PROGRAM: ++ def_program(defp); ++ break; ++ case TOK_CONST: ++ def_const(defp); ++ break; ++ case TOK_EOF: ++ free(defp); ++ return (NULL); ++ default: ++ error("definition keyword expected"); ++ } ++ scan(TOK_SEMICOLON, &tok); ++ isdefined(defp); ++ return (defp); ++} ++ ++static void ++isdefined(definition *defp) ++{ ++ STOREVAL(&defined, defp); ++} ++ ++static void ++def_struct(definition *defp) ++{ ++ token tok; ++ declaration dec; ++ decl_list *decls; ++ decl_list **tailp; ++ ++ defp->def_kind = DEF_STRUCT; ++ ++ scan(TOK_IDENT, &tok); ++ defp->def_name = tok.str; ++ scan(TOK_LBRACE, &tok); ++ tailp = &defp->def.st.decls; ++ do { ++ get_declaration(&dec, DEF_STRUCT); ++ decls = ALLOC(decl_list); ++ decls->decl = dec; ++ *tailp = decls; ++ tailp = &decls->next; ++ scan(TOK_SEMICOLON, &tok); ++ peek(&tok); ++ } while (tok.kind != TOK_RBRACE); ++ get_token(&tok); ++ *tailp = NULL; ++} ++ ++static void ++def_program(definition *defp) ++{ ++ token tok; ++ declaration dec; ++ decl_list *decls; ++ decl_list **tailp; ++ version_list *vlist; ++ version_list **vtailp; ++ proc_list *plist; ++ proc_list **ptailp; ++ int num_args; ++ bool_t isvoid = FALSE; /* whether first argument is void */ ++ defp->def_kind = DEF_PROGRAM; ++ scan(TOK_IDENT, &tok); ++ defp->def_name = tok.str; ++ scan(TOK_LBRACE, &tok); ++ vtailp = &defp->def.pr.versions; ++ tailp = &defp->def.st.decls; ++ scan(TOK_VERSION, &tok); ++ do { ++ scan(TOK_IDENT, &tok); ++ vlist = ALLOC(version_list); ++ vlist->vers_name = tok.str; ++ scan(TOK_LBRACE, &tok); ++ ptailp = &vlist->procs; ++ do { ++ /* get result type */ ++ plist = ALLOC(proc_list); ++ get_type(&plist->res_prefix, &plist->res_type, ++ DEF_PROGRAM); ++ if (streq(plist->res_type, "opaque")) { ++ error("illegal result type"); ++ } ++ scan(TOK_IDENT, &tok); ++ plist->proc_name = tok.str; ++ scan(TOK_LPAREN, &tok); ++ /* get args - first one*/ ++ num_args = 1; ++ isvoid = FALSE; ++ /* type of DEF_PROGRAM in the first ++ * get_prog_declaration and DEF_STURCT in the next ++ * allows void as argument if it is the only argument ++ */ ++ get_prog_declaration(&dec, DEF_PROGRAM, num_args); ++ if (streq(dec.type, "void")) ++ isvoid = TRUE; ++ decls = ALLOC(decl_list); ++ plist->args.decls = decls; ++ decls->decl = dec; ++ tailp = &decls->next; ++ /* get args */ ++ while(peekscan(TOK_COMMA, &tok)) { ++ num_args++; ++ get_prog_declaration(&dec, DEF_STRUCT, ++ num_args); ++ decls = ALLOC(decl_list); ++ decls->decl = dec; ++ *tailp = decls; ++ if (streq(dec.type, "void")) ++ isvoid = TRUE; ++ tailp = &decls->next; ++ } ++ /* multiple arguments are only allowed in newstyle */ ++ if( !newstyle && num_args > 1 ) { ++ error("only one argument is allowed" ); ++ } ++ if (isvoid && num_args > 1) { ++ error("illegal use of void in program definition"); ++ } ++ *tailp = NULL; ++ scan(TOK_RPAREN, &tok); ++ scan(TOK_EQUAL, &tok); ++ scan_num(&tok); ++ scan(TOK_SEMICOLON, &tok); ++ plist->proc_num = tok.str; ++ plist->arg_num = num_args; ++ *ptailp = plist; ++ ptailp = &plist->next; ++ peek(&tok); ++ } while (tok.kind != TOK_RBRACE); ++ *ptailp = NULL; ++ *vtailp = vlist; ++ vtailp = &vlist->next; ++ scan(TOK_RBRACE, &tok); ++ scan(TOK_EQUAL, &tok); ++ scan_num(&tok); ++ vlist->vers_num = tok.str; ++ /* make the argument structure name for each arg*/ ++ for(plist = vlist->procs; plist != NULL; ++ plist = plist->next) { ++ plist->args.argname = make_argname(plist->proc_name, ++ vlist->vers_num); ++ /* free the memory ??*/ ++ } ++ scan(TOK_SEMICOLON, &tok); ++ scan2(TOK_VERSION, TOK_RBRACE, &tok); ++ } while (tok.kind == TOK_VERSION); ++ scan(TOK_EQUAL, &tok); ++ scan_num(&tok); ++ defp->def.pr.prog_num = tok.str; ++ *vtailp = NULL; ++} ++ ++ ++static void ++def_enum(definition *defp) ++{ ++ token tok; ++ enumval_list *elist; ++ enumval_list **tailp; ++ ++ defp->def_kind = DEF_ENUM; ++ scan(TOK_IDENT, &tok); ++ defp->def_name = tok.str; ++ scan(TOK_LBRACE, &tok); ++ tailp = &defp->def.en.vals; ++ do { ++ scan(TOK_IDENT, &tok); ++ elist = ALLOC(enumval_list); ++ elist->name = tok.str; ++ elist->assignment = NULL; ++ scan3(TOK_COMMA, TOK_RBRACE, TOK_EQUAL, &tok); ++ if (tok.kind == TOK_EQUAL) { ++ scan_num(&tok); ++ elist->assignment = tok.str; ++ scan2(TOK_COMMA, TOK_RBRACE, &tok); ++ } ++ *tailp = elist; ++ tailp = &elist->next; ++ } while (tok.kind != TOK_RBRACE); ++ *tailp = NULL; ++} ++ ++static void ++def_const(definition *defp) ++{ ++ token tok; ++ ++ defp->def_kind = DEF_CONST; ++ scan(TOK_IDENT, &tok); ++ defp->def_name = tok.str; ++ scan(TOK_EQUAL, &tok); ++ scan2(TOK_IDENT, TOK_STRCONST, &tok); ++ defp->def.co = tok.str; ++} ++ ++static void ++def_union(definition *defp) ++{ ++ token tok; ++ declaration dec; ++ case_list *cases; ++ case_list **tailp; ++ ++ defp->def_kind = DEF_UNION; ++ scan(TOK_IDENT, &tok); ++ defp->def_name = tok.str; ++ scan(TOK_SWITCH, &tok); ++ scan(TOK_LPAREN, &tok); ++ get_declaration(&dec, DEF_UNION); ++ defp->def.un.enum_decl = dec; ++ tailp = &defp->def.un.cases; ++ scan(TOK_RPAREN, &tok); ++ scan(TOK_LBRACE, &tok); ++ scan(TOK_CASE, &tok); ++ while (tok.kind == TOK_CASE) { ++ scan2(TOK_IDENT, TOK_CHARCONST, &tok); ++ cases = ALLOC(case_list); ++ cases->case_name = tok.str; ++ scan(TOK_COLON, &tok); ++ /* now peek at next token */ ++ if(peekscan(TOK_CASE,&tok)) ++ { ++ ++ do ++ { ++ scan2(TOK_IDENT, TOK_CHARCONST, &tok); ++ cases->contflag=1; /* continued case statement */ ++ *tailp = cases; ++ tailp = &cases->next; ++ cases = ALLOC(case_list); ++ cases->case_name = tok.str; ++ scan(TOK_COLON, &tok); ++ ++ }while(peekscan(TOK_CASE,&tok)); ++ } ++ ++ get_declaration(&dec, DEF_UNION); ++ cases->case_decl = dec; ++ cases->contflag=0; /* no continued case statement */ ++ *tailp = cases; ++ tailp = &cases->next; ++ scan(TOK_SEMICOLON, &tok); ++ ++ scan3(TOK_CASE, TOK_DEFAULT, TOK_RBRACE, &tok); ++ } ++ *tailp = NULL; ++ if (tok.kind == TOK_DEFAULT) { ++ scan(TOK_COLON, &tok); ++ get_declaration(&dec, DEF_UNION); ++ defp->def.un.default_decl = ALLOC(declaration); ++ *defp->def.un.default_decl = dec; ++ scan(TOK_SEMICOLON, &tok); ++ scan(TOK_RBRACE, &tok); ++ } else { ++ defp->def.un.default_decl = NULL; ++ } ++} ++ ++static char* reserved_words[] = ++{ ++ "array", ++ "bytes", ++ "destroy", ++ "free", ++ "getpos", ++ "inline", ++ "pointer", ++ "reference", ++ "setpos", ++ "sizeof", ++ "union", ++ "vector", ++ NULL ++ }; ++ ++static char* reserved_types[] = ++{ ++ "opaque", ++ "string", ++ NULL ++ }; ++ ++/* check that the given name is not one that would eventually result in ++ xdr routines that would conflict with internal XDR routines. */ ++static void ++check_type_name(char *name, int new_type) ++{ ++ int i; ++ char tmp[100]; ++ ++ for( i = 0; reserved_words[i] != NULL; i++ ) { ++ if( strcmp( name, reserved_words[i] ) == 0 ) { ++ sprintf(tmp, ++ "illegal (reserved) name :\'%s\' in type definition", name ); ++ error(tmp); ++ } ++ } ++ if( new_type ) { ++ for( i = 0; reserved_types[i] != NULL; i++ ) { ++ if( strcmp( name, reserved_types[i] ) == 0 ) { ++ sprintf(tmp, ++ "illegal (reserved) name :\'%s\' in type definition", name ); ++ error(tmp); ++ } ++ } ++ } ++} ++ ++static void ++def_typedef(definition *defp) ++{ ++ declaration dec; ++ ++ defp->def_kind = DEF_TYPEDEF; ++ get_declaration(&dec, DEF_TYPEDEF); ++ defp->def_name = dec.name; ++ check_type_name( dec.name, 1 ); ++ defp->def.ty.old_prefix = dec.prefix; ++ defp->def.ty.old_type = dec.type; ++ defp->def.ty.rel = dec.rel; ++ defp->def.ty.array_max = dec.array_max; ++} ++ ++static void ++get_declaration(declaration *dec, defkind dkind) ++{ ++ token tok; ++ ++ get_type(&dec->prefix, &dec->type, dkind); ++ dec->rel = REL_ALIAS; ++ if (streq(dec->type, "void")) { ++ return; ++ } ++ ++ check_type_name( dec->type, 0 ); ++ ++ scan2(TOK_STAR, TOK_IDENT, &tok); ++ if (tok.kind == TOK_STAR) { ++ dec->rel = REL_POINTER; ++ scan(TOK_IDENT, &tok); ++ } ++ dec->name = tok.str; ++ if (peekscan(TOK_LBRACKET, &tok)) { ++ if (dec->rel == REL_POINTER) { ++ error("no array-of-pointer declarations -- use typedef"); ++ } ++ dec->rel = REL_VECTOR; ++ scan_num(&tok); ++ dec->array_max = tok.str; ++ scan(TOK_RBRACKET, &tok); ++ } else if (peekscan(TOK_LANGLE, &tok)) { ++ if (dec->rel == REL_POINTER) { ++ error("no array-of-pointer declarations -- use typedef"); ++ } ++ dec->rel = REL_ARRAY; ++ if (peekscan(TOK_RANGLE, &tok)) { ++ dec->array_max = "~0"; /* unspecified size, use max */ ++ } else { ++ scan_num(&tok); ++ dec->array_max = tok.str; ++ scan(TOK_RANGLE, &tok); ++ } ++ } ++ if (streq(dec->type, "opaque")) { ++ if (dec->rel != REL_ARRAY && dec->rel != REL_VECTOR) { ++ error("array declaration expected"); ++ } ++ } else if (streq(dec->type, "string")) { ++ if (dec->rel != REL_ARRAY) { ++ error("variable-length array declaration expected"); ++ } ++ } ++} ++ ++ ++static void ++get_prog_declaration(declaration *dec, defkind dkind, int num) ++{ ++ token tok; ++ char name[10]; /* argument name */ ++ ++ if (dkind == DEF_PROGRAM) { ++ peek(&tok); ++ if (tok.kind == TOK_RPAREN) { /* no arguments */ ++ dec->rel = REL_ALIAS; ++ dec->type = "void"; ++ dec->prefix = NULL; ++ dec->name = NULL; ++ return; ++ } ++ } ++ get_type(&dec->prefix, &dec->type, dkind); ++ dec->rel = REL_ALIAS; ++ if (peekscan(TOK_IDENT, &tok)) /* optional name of argument */ ++ strcpy(name, tok.str); ++ else ++ sprintf(name, "%s%d", ARGNAME, num); /* default name of argument */ ++ ++ dec->name = (char *) strdup(name); ++ ++ if (streq(dec->type, "void")) { ++ return; ++ } ++ ++ if (streq(dec->type, "opaque")) { ++ error("opaque -- illegal argument type"); ++ } ++ if (peekscan(TOK_STAR, &tok)) { ++ if (streq(dec->type, "string")) { ++ error("pointer to string not allowed in program arguments\n"); ++ } ++ dec->rel = REL_POINTER; ++ if (peekscan(TOK_IDENT, &tok)) /* optional name of argument */ ++ dec->name = strdup(tok.str); ++ } ++ if (peekscan(TOK_LANGLE, &tok)) { ++ if (!streq(dec->type, "string")) { ++ error("arrays cannot be declared as arguments to procedures -- use typedef"); ++ } ++ dec->rel = REL_ARRAY; ++ if (peekscan(TOK_RANGLE, &tok)) { ++ dec->array_max = "~0";/* unspecified size, use max */ ++ } else { ++ scan_num(&tok); ++ dec->array_max = tok.str; ++ scan(TOK_RANGLE, &tok); ++ } ++ } ++ if (streq(dec->type, "string")) { ++ if (dec->rel != REL_ARRAY) { /* .x specifies just string as ++ * type of argument ++ * - make it string<> ++ */ ++ dec->rel = REL_ARRAY; ++ dec->array_max = "~0";/* unspecified size, use max */ ++ } ++ } ++} ++ ++ ++ ++static void ++get_type(char **prefixp, char **typep, defkind dkind) ++{ ++ token tok; ++ ++ *prefixp = NULL; ++ get_token(&tok); ++ switch (tok.kind) { ++ case TOK_IDENT: ++ *typep = tok.str; ++ break; ++ case TOK_STRUCT: ++ case TOK_ENUM: ++ case TOK_UNION: ++ *prefixp = tok.str; ++ scan(TOK_IDENT, &tok); ++ *typep = tok.str; ++ break; ++ case TOK_UNSIGNED: ++ unsigned_dec(typep); ++ break; ++ case TOK_SHORT: ++ *typep = "short"; ++ (void) peekscan(TOK_INT, &tok); ++ break; ++ case TOK_INT32: ++ *typep = "int32_t"; ++ (void) peekscan(TOK_INT, &tok); ++ break; ++ case TOK_VOID: ++ if (dkind != DEF_UNION && dkind != DEF_PROGRAM) { ++ error("voids allowed only inside union and program definitions with one argument"); ++ } ++ *typep = tok.str; ++ break; ++ case TOK_STRING: ++ case TOK_OPAQUE: ++ case TOK_CHAR: ++ case TOK_INT: ++ case TOK_FLOAT: ++ case TOK_DOUBLE: ++ case TOK_BOOL: ++ *typep = tok.str; ++ break; ++ default: ++ error("expected type specifier"); ++ } ++} ++ ++static void ++unsigned_dec(char **typep) ++{ ++ token tok; ++ ++ peek(&tok); ++ switch (tok.kind) { ++ case TOK_CHAR: ++ get_token(&tok); ++ *typep = "u_char"; ++ break; ++ case TOK_SHORT: ++ get_token(&tok); ++ *typep = "u_short"; ++ (void) peekscan(TOK_INT, &tok); ++ break; ++ case TOK_INT32: ++ get_token(&tok); ++ *typep = "u_int32_"; ++ (void) peekscan(TOK_INT, &tok); ++ break; ++ case TOK_INT: ++ get_token(&tok); ++ *typep = "u_int"; ++ break; ++ default: ++ *typep = "u_int"; ++ break; ++ } ++} +--- libtirpc-0.2.3/rpcgen/rpc_parse.h.0005~ 2013-02-11 21:47:03.994289281 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_parse.h 2013-02-11 21:47:03.994289281 +0100 +@@ -0,0 +1,166 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++/* @(#)rpc_parse.h 1.3 90/08/29 (C) 1987 SMI */ ++ ++/* ++ * rpc_parse.h, Definitions for the RPCL parser ++ */ ++ ++enum defkind { ++ DEF_CONST, ++ DEF_STRUCT, ++ DEF_UNION, ++ DEF_ENUM, ++ DEF_TYPEDEF, ++ DEF_PROGRAM ++}; ++typedef enum defkind defkind; ++ ++typedef char *const_def; ++ ++enum relation { ++ REL_VECTOR, /* fixed length array */ ++ REL_ARRAY, /* variable length array */ ++ REL_POINTER, /* pointer */ ++ REL_ALIAS, /* simple */ ++}; ++typedef enum relation relation; ++ ++struct typedef_def { ++ char *old_prefix; ++ char *old_type; ++ relation rel; ++ char *array_max; ++}; ++typedef struct typedef_def typedef_def; ++ ++struct enumval_list { ++ char *name; ++ char *assignment; ++ struct enumval_list *next; ++}; ++typedef struct enumval_list enumval_list; ++ ++struct enum_def { ++ enumval_list *vals; ++}; ++typedef struct enum_def enum_def; ++ ++struct declaration { ++ char *prefix; ++ char *type; ++ char *name; ++ relation rel; ++ char *array_max; ++}; ++typedef struct declaration declaration; ++ ++struct decl_list { ++ declaration decl; ++ struct decl_list *next; ++}; ++typedef struct decl_list decl_list; ++ ++struct struct_def { ++ decl_list *decls; ++}; ++typedef struct struct_def struct_def; ++ ++struct case_list { ++ char *case_name; ++ int contflag; ++ declaration case_decl; ++ struct case_list *next; ++}; ++typedef struct case_list case_list; ++ ++struct union_def { ++ declaration enum_decl; ++ case_list *cases; ++ declaration *default_decl; ++}; ++typedef struct union_def union_def; ++ ++struct arg_list { ++ char *argname; /* name of struct for arg*/ ++ decl_list *decls; ++}; ++ ++typedef struct arg_list arg_list; ++ ++struct proc_list { ++ char *proc_name; ++ char *proc_num; ++ arg_list args; ++ int arg_num; ++ char *res_type; ++ char *res_prefix; ++ struct proc_list *next; ++}; ++typedef struct proc_list proc_list; ++ ++struct version_list { ++ char *vers_name; ++ char *vers_num; ++ proc_list *procs; ++ struct version_list *next; ++}; ++typedef struct version_list version_list; ++ ++struct program_def { ++ char *prog_num; ++ version_list *versions; ++}; ++typedef struct program_def program_def; ++ ++struct definition { ++ char *def_name; ++ defkind def_kind; ++ union { ++ const_def co; ++ struct_def st; ++ union_def un; ++ enum_def en; ++ typedef_def ty; ++ program_def pr; ++ } def; ++}; ++typedef struct definition definition; ++ ++definition *get_definition(); ++ ++ ++struct bas_type ++{ ++ char *name; ++ int length; ++ struct bas_type *next; ++}; ++ ++typedef struct bas_type bas_type; +--- libtirpc-0.2.3/rpcgen/rpc_sample.c.0005~ 2013-02-11 21:47:03.994289281 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_sample.c 2013-02-11 21:47:03.994289281 +0100 +@@ -0,0 +1,247 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#if 0 ++static char sccsid[] = "@(#)rpc_sample.c 1.1 90/08/30 (C) 1987 SMI"; ++ ++#endif ++ ++/* ++ * rpc_sample.c, Sample client-server code outputter for the RPC protocol compiler ++ */ ++ ++#include ++#include ++#include "rpc_parse.h" ++#include "rpc_util.h" ++ ++ ++static char RQSTP[] = "rqstp"; ++ ++static void write_sample_client(char *program_name, version_list *vp); ++static void write_sample_server(definition * def); ++static void return_type(proc_list *plist); ++ ++void ++write_sample_svc(definition *def) ++{ ++ if (def->def_kind != DEF_PROGRAM) ++ return; ++ write_sample_server(def); ++} ++ ++ ++int ++write_sample_clnt(definition *def) ++{ ++ version_list *vp; ++ int count = 0; ++ ++ if (def->def_kind != DEF_PROGRAM) ++ return (0); ++ /* generate sample code for each version */ ++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { ++ write_sample_client(def->def_name, vp); ++ ++count; ++ } ++ return (count); ++} ++ ++ ++static void ++write_sample_client(char *program_name, version_list *vp) ++{ ++ proc_list *proc; ++ int i; ++ decl_list *l; ++ ++ f_print(fout, "\n\nvoid\n"); ++ pvname(program_name, vp->vers_num); ++ if (Cflag) ++ f_print(fout, "( char* host )\n{\n"); ++ else ++ f_print(fout, "(host)\nchar *host;\n{\n"); ++ f_print(fout, "\tCLIENT *clnt;\n"); ++ ++ i = 0; ++ for (proc = vp->procs; proc != NULL; proc = proc->next) { ++ f_print(fout, "\t"); ++ ptype(proc->res_prefix, proc->res_type, 1); ++ f_print(fout, " *result_%d;\n", ++i); ++ /* print out declarations for arguments */ ++ if (proc->arg_num < 2 && !newstyle) { ++ f_print(fout, "\t"); ++ if (!streq(proc->args.decls->decl.type, "void")) ++ ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1); ++ else ++ f_print(fout, "char* "); /* cannot have "void" type */ ++ f_print(fout, " "); ++ pvname(proc->proc_name, vp->vers_num); ++ f_print(fout, "_arg;\n"); ++ } else if (!streq(proc->args.decls->decl.type, "void")) { ++ for (l = proc->args.decls; l != NULL; l = l->next) { ++ f_print(fout, "\t"); ++ ptype(l->decl.prefix, l->decl.type, 1); ++ f_print(fout, " "); ++ pvname(proc->proc_name, vp->vers_num); ++ f_print(fout, "_%s;\n", l->decl.name); ++ /* pdeclaration(proc->args.argname, &l->decl, 1, ";\n" );*/ ++ } ++ } ++ } ++ ++ /* generate creation of client handle */ ++ f_print(fout, "\tclnt = clnt_create(host, %s, %s, \"%s\");\n", ++ program_name, vp->vers_name, tirpcflag ? "netpath" : "udp"); ++ f_print(fout, "\tif (clnt == NULL) {\n"); ++ f_print(fout, "\t\tclnt_pcreateerror(host);\n"); ++ f_print(fout, "\t\texit(1);\n\t}\n"); ++ ++ /* generate calls to procedures */ ++ i = 0; ++ for (proc = vp->procs; proc != NULL; proc = proc->next) { ++ f_print(fout, "\tresult_%d = ", ++i); ++ pvname(proc->proc_name, vp->vers_num); ++ if (proc->arg_num < 2 && !newstyle) { ++ f_print(fout, "("); ++ if (streq(proc->args.decls->decl.type, "void")) /* cast to void* */ ++ f_print(fout, "(void*)"); ++ f_print(fout, "&"); ++ pvname(proc->proc_name, vp->vers_num); ++ f_print(fout, "_arg, clnt);\n"); ++ } else if (streq(proc->args.decls->decl.type, "void")) { ++ f_print(fout, "(clnt);\n"); ++ } else { ++ f_print(fout, "("); ++ for (l = proc->args.decls; l != NULL; l = l->next) { ++ pvname(proc->proc_name, vp->vers_num); ++ f_print(fout, "_%s, ", l->decl.name); ++ } ++ f_print(fout, "clnt);\n"); ++ } ++ f_print(fout, "\tif (result_%d == NULL) {\n", i); ++ f_print(fout, "\t\tclnt_perror(clnt, \"call failed:\");\n"); ++ f_print(fout, "\t}\n"); ++ } ++ ++ f_print(fout, "\tclnt_destroy( clnt );\n"); ++ f_print(fout, "}\n"); ++} ++ ++static void ++write_sample_server(definition * def) ++{ ++ version_list *vp; ++ proc_list *proc; ++ ++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { ++ for (proc = vp->procs; proc != NULL; proc = proc->next) { ++ f_print(fout, "\n"); ++ /* if( Cflag ) ++ f_print( fout, "extern \"C\"{\n"); ++*/ ++ return_type(proc); ++ f_print(fout, "* \n"); ++ if (Cflag) ++ pvname_svc(proc->proc_name, vp->vers_num); ++ else ++ pvname(proc->proc_name, vp->vers_num); ++ printarglist(proc, RQSTP, "struct svc_req *"); ++ ++ f_print(fout, "{\n"); ++ f_print(fout, "\n\tstatic "); ++ if (!streq(proc->res_type, "void")) ++ return_type(proc); ++ else ++ f_print(fout, "char*"); /* cannot have void type */ ++ /* f_print(fout, " result;\n", proc->res_type); */ ++ f_print(fout, " result;\n"); ++ f_print(fout, ++ "\n\t/*\n\t * insert server code here\n\t */\n\n"); ++ if (!streq(proc->res_type, "void")) ++ f_print(fout, "\treturn(&result);\n}\n"); ++ else /* cast back to void * */ ++ f_print(fout, "\treturn((void*) &result);\n}\n"); ++ /* if( Cflag) ++ f_print( fout, "};\n"); ++*/ ++ ++ } ++ } ++} ++ ++ ++ ++static void ++return_type(proc_list *plist) ++{ ++ ptype( plist->res_prefix, plist->res_type, 1 ); ++} ++ ++void ++add_sample_msg(void) ++{ ++ f_print(fout, "/*\n"); ++ f_print(fout, " * This is sample code generated by rpcgen.\n"); ++ f_print(fout, " * These are only templates and you can use them\n"); ++ f_print(fout, " * as a guideline for developing your own functions.\n"); ++ f_print(fout, " */\n\n"); ++} ++ ++void ++write_sample_clnt_main(void) ++{ ++ list *l; ++ definition *def; ++ version_list *vp; ++ ++ f_print(fout, "\n\n" ); ++ if( Cflag ) ++ f_print(fout,"main( int argc, char* argv[] )\n{\n" ); ++ else ++ f_print(fout, "main(argc, argv)\nint argc;\nchar *argv[];\n{\n" ); ++ ++ f_print(fout, "\tchar *host;"); ++ f_print(fout, "\n\n\tif(argc < 2) {"); ++ f_print(fout, "\n\t\tprintf(\"usage: %%s server_host\\n\", argv[0]);\n" ); ++ f_print(fout, "\t\texit(1);\n\t}"); ++ f_print(fout, "\n\thost = argv[1];\n"); ++ ++ for (l = defined; l != NULL; l = l->next) { ++ def = l->val; ++ if (def->def_kind != DEF_PROGRAM) { ++ continue; ++ } ++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { ++ f_print( fout, "\t" ); ++ pvname(def->def_name, vp->vers_num); ++ f_print( fout, "( host );\n" ); ++ } ++ } ++ f_print(fout, "}\n"); ++} +--- libtirpc-0.2.3/rpcgen/rpc_scan.c.0005~ 2013-02-11 21:47:03.995289293 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_scan.c 2013-02-11 21:47:03.995289293 +0100 +@@ -0,0 +1,474 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#if 0 ++static char sccsid[] = "@(#)rpc_scan.c 1.11 89/02/22 (C) 1987 SMI"; ++#endif ++ ++/* ++ * rpc_scan.c, Scanner for the RPC protocol compiler ++ * Copyright (C) 1987, Sun Microsystems, Inc. ++ */ ++#include ++#include ++#include ++#include "rpc_scan.h" ++#include "rpc_parse.h" ++#include "rpc_util.h" ++ ++static void unget_token(token *tokp); ++static void findstrconst(char **str, char **val); ++static void findchrconst(char **str, char **val); ++static void findconst(char **str, char **val); ++static void findkind(char **mark, token *tokp); ++static int cppline(char *line); ++static int directive(char *line); ++static void printdirective(char *line); ++static void docppline(char *line, int *lineno, char **fname); ++ ++#define startcomment(where) (where[0] == '/' && where[1] == '*') ++#define endcomment(where) (where[-1] == '*' && where[0] == '/') ++ ++static int pushed = 0; /* is a token pushed */ ++static token lasttok; /* last token, if pushed */ ++ ++/* ++ * scan expecting 1 given token ++ */ ++void ++scan(tok_kind expect, token *tokp) ++{ ++ get_token(tokp); ++ if (tokp->kind != expect) { ++ expected1(expect); ++ } ++} ++ ++/* ++ * scan expecting any of the 2 given tokens ++ */ ++void ++scan2(tok_kind expect1, tok_kind expect2, token *tokp) ++{ ++ get_token(tokp); ++ if (tokp->kind != expect1 && tokp->kind != expect2) { ++ expected2(expect1, expect2); ++ } ++} ++ ++/* ++ * scan expecting any of the 3 given token ++ */ ++void ++scan3(tok_kind expect1, tok_kind expect2, tok_kind expect3, token *tokp) ++{ ++ get_token(tokp); ++ if (tokp->kind != expect1 && tokp->kind != expect2 ++ && tokp->kind != expect3) { ++ expected3(expect1, expect2, expect3); ++ } ++} ++ ++/* ++ * scan expecting a constant, possibly symbolic ++ */ ++void ++scan_num(token *tokp) ++{ ++ get_token(tokp); ++ switch (tokp->kind) { ++ case TOK_IDENT: ++ break; ++ default: ++ error("constant or identifier expected"); ++ } ++} ++ ++/* ++ * Peek at the next token ++ */ ++void ++peek(token *tokp) ++{ ++ get_token(tokp); ++ unget_token(tokp); ++} ++ ++/* ++ * Peek at the next token and scan it if it matches what you expect ++ */ ++int ++peekscan(tok_kind expect, token *tokp) ++{ ++ peek(tokp); ++ if (tokp->kind == expect) { ++ get_token(tokp); ++ return (1); ++ } ++ return (0); ++} ++ ++/* ++ * Get the next token, printing out any directive that are encountered. ++ */ ++void ++get_token(token *tokp) ++{ ++ int commenting; ++ ++ if (pushed) { ++ pushed = 0; ++ *tokp = lasttok; ++ return; ++ } ++ commenting = 0; ++ for (;;) { ++ if (*where == 0) { ++ for (;;) { ++ if (!fgets(curline, MAXLINESIZE, fin)) { ++ tokp->kind = TOK_EOF; ++ *where = 0; ++ return; ++ } ++ linenum++; ++ if (commenting) { ++ break; ++ } else if (cppline(curline)) { ++ docppline(curline, &linenum, ++ &infilename); ++ } else if (directive(curline)) { ++ printdirective(curline); ++ } else { ++ break; ++ } ++ } ++ where = curline; ++ } else if (isspace(*where)) { ++ while (isspace(*where)) { ++ where++; /* eat */ ++ } ++ } else if (commenting) { ++ for (where++; *where; where++) { ++ if (endcomment(where)) { ++ where++; ++ commenting--; ++ break; ++ } ++ } ++ } else if (startcomment(where)) { ++ where += 2; ++ commenting++; ++ } else { ++ break; ++ } ++ } ++ ++ /* ++ * 'where' is not whitespace, comment or directive Must be a token! ++ */ ++ switch (*where) { ++ case ':': ++ tokp->kind = TOK_COLON; ++ where++; ++ break; ++ case ';': ++ tokp->kind = TOK_SEMICOLON; ++ where++; ++ break; ++ case ',': ++ tokp->kind = TOK_COMMA; ++ where++; ++ break; ++ case '=': ++ tokp->kind = TOK_EQUAL; ++ where++; ++ break; ++ case '*': ++ tokp->kind = TOK_STAR; ++ where++; ++ break; ++ case '[': ++ tokp->kind = TOK_LBRACKET; ++ where++; ++ break; ++ case ']': ++ tokp->kind = TOK_RBRACKET; ++ where++; ++ break; ++ case '{': ++ tokp->kind = TOK_LBRACE; ++ where++; ++ break; ++ case '}': ++ tokp->kind = TOK_RBRACE; ++ where++; ++ break; ++ case '(': ++ tokp->kind = TOK_LPAREN; ++ where++; ++ break; ++ case ')': ++ tokp->kind = TOK_RPAREN; ++ where++; ++ break; ++ case '<': ++ tokp->kind = TOK_LANGLE; ++ where++; ++ break; ++ case '>': ++ tokp->kind = TOK_RANGLE; ++ where++; ++ break; ++ ++ case '"': ++ tokp->kind = TOK_STRCONST; ++ findstrconst(&where, &tokp->str); ++ break; ++ case '\'': ++ tokp->kind = TOK_CHARCONST; ++ findchrconst(&where, &tokp->str); ++ break; ++ ++ case '-': ++ case '0': ++ case '1': ++ case '2': ++ case '3': ++ case '4': ++ case '5': ++ case '6': ++ case '7': ++ case '8': ++ case '9': ++ tokp->kind = TOK_IDENT; ++ findconst(&where, &tokp->str); ++ break; ++ ++ default: ++ if (!(isalpha(*where) || *where == '_')) { ++ char buf[100]; ++ char *p; ++ ++ s_print(buf, "illegal character in file: "); ++ p = buf + strlen(buf); ++ if (isprint(*where)) { ++ s_print(p, "%c", *where); ++ } else { ++ s_print(p, "%d", *where); ++ } ++ error(buf); ++ } ++ findkind(&where, tokp); ++ break; ++ } ++} ++ ++static void ++unget_token(token *tokp) ++{ ++ lasttok = *tokp; ++ pushed = 1; ++} ++ ++static void ++findstrconst(char **str, char **val) ++{ ++ char *p; ++ int size; ++ ++ p = *str; ++ do { ++ *p++; ++ } while (*p && *p != '"'); ++ if (*p == 0) { ++ error("unterminated string constant"); ++ } ++ p++; ++ size = p - *str; ++ *val = alloc(size + 1); ++ (void) strncpy(*val, *str, size); ++ (*val)[size] = 0; ++ *str = p; ++} ++ ++static void ++findchrconst(char **str, char **val) ++{ ++ char *p; ++ int size; ++ ++ p = *str; ++ do { ++ *p++; ++ } while (*p && *p != '\''); ++ if (*p == 0) { ++ error("unterminated string constant"); ++ } ++ p++; ++ size = p - *str; ++ if (size != 3) { ++ error("empty char string"); ++ } ++ *val = alloc(size + 1); ++ (void) strncpy(*val, *str, size); ++ (*val)[size] = 0; ++ *str = p; ++} ++ ++static void ++findconst(char **str, char **val) ++{ ++ char *p; ++ int size; ++ ++ p = *str; ++ if (*p == '0' && *(p + 1) == 'x') { ++ p++; ++ do { ++ p++; ++ } while (isxdigit(*p)); ++ } else { ++ do { ++ p++; ++ } while (isdigit(*p)); ++ } ++ size = p - *str; ++ *val = alloc(size + 1); ++ (void) strncpy(*val, *str, size); ++ (*val)[size] = 0; ++ *str = p; ++} ++ ++static token symbols[] = { ++ {TOK_CONST, "const"}, ++ {TOK_UNION, "union"}, ++ {TOK_SWITCH, "switch"}, ++ {TOK_CASE, "case"}, ++ {TOK_DEFAULT, "default"}, ++ {TOK_STRUCT, "struct"}, ++ {TOK_TYPEDEF, "typedef"}, ++ {TOK_ENUM, "enum"}, ++ {TOK_OPAQUE, "opaque"}, ++ {TOK_BOOL, "bool"}, ++ {TOK_VOID, "void"}, ++ {TOK_CHAR, "char"}, ++ {TOK_INT, "int"}, ++ {TOK_UNSIGNED, "unsigned"}, ++ {TOK_SHORT, "short"}, ++ {TOK_INT32, "int32"}, ++ {TOK_FLOAT, "float"}, ++ {TOK_DOUBLE, "double"}, ++ {TOK_STRING, "string"}, ++ {TOK_PROGRAM, "program"}, ++ {TOK_VERSION, "version"}, ++ {TOK_EOF, "??????"}, ++}; ++ ++static void ++findkind(char **mark, token *tokp) ++{ ++ int len; ++ token *s; ++ char *str; ++ ++ str = *mark; ++ for (s = symbols; s->kind != TOK_EOF; s++) { ++ len = strlen(s->str); ++ if (strncmp(str, s->str, len) == 0) { ++ if (!isalnum(str[len]) && str[len] != '_') { ++ tokp->kind = s->kind; ++ tokp->str = s->str; ++ *mark = str + len; ++ return; ++ } ++ } ++ } ++ tokp->kind = TOK_IDENT; ++ for (len = 0; isalnum(str[len]) || str[len] == '_'; len++); ++ tokp->str = alloc(len + 1); ++ (void) strncpy(tokp->str, str, len); ++ tokp->str[len] = 0; ++ *mark = str + len; ++} ++ ++static int ++cppline(char *line) ++{ ++ return (line == curline && *line == '#'); ++} ++ ++static int ++directive(char *line) ++{ ++ return (line == curline && *line == '%'); ++} ++ ++static void ++printdirective(char *line) ++{ ++ f_print(fout, "%s", line + 1); ++} ++ ++static void ++docppline(char *line, int *lineno, char **fname) ++{ ++ char *file; ++ int num; ++ char *p; ++ ++ line++; ++ while (isspace(*line)) { ++ line++; ++ } ++ num = atoi(line); ++ while (isdigit(*line)) { ++ line++; ++ } ++ while (isspace(*line)) { ++ line++; ++ } ++ if (*line != '"') { ++ error("preprocessor error"); ++ } ++ line++; ++ p = file = alloc(strlen(line) + 1); ++ while (*line && *line != '"') { ++ *p++ = *line++; ++ } ++ if (*line == 0) { ++ error("preprocessor error"); ++ } ++ *p = 0; ++ if (*file == 0) { ++ *fname = NULL; ++ free(file); ++ } else { ++ *fname = file; ++ } ++ *lineno = num - 1; ++} +--- libtirpc-0.2.3/rpcgen/rpc_scan.h.0005~ 2013-02-11 21:47:03.995289293 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_scan.h 2013-02-11 21:47:03.995289293 +0100 +@@ -0,0 +1,103 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++/* @(#)rpc_scan.h 1.3 90/08/29 (C) 1987 SMI */ ++ ++/* ++ * rpc_scan.h, Definitions for the RPCL scanner ++ */ ++ ++/* ++ * kinds of tokens ++ */ ++enum tok_kind { ++ TOK_IDENT, ++ TOK_CHARCONST, ++ TOK_STRCONST, ++ TOK_LPAREN, ++ TOK_RPAREN, ++ TOK_LBRACE, ++ TOK_RBRACE, ++ TOK_LBRACKET, ++ TOK_RBRACKET, ++ TOK_LANGLE, ++ TOK_RANGLE, ++ TOK_STAR, ++ TOK_COMMA, ++ TOK_EQUAL, ++ TOK_COLON, ++ TOK_SEMICOLON, ++ TOK_CONST, ++ TOK_STRUCT, ++ TOK_UNION, ++ TOK_SWITCH, ++ TOK_CASE, ++ TOK_DEFAULT, ++ TOK_ENUM, ++ TOK_TYPEDEF, ++ TOK_INT, ++ TOK_SHORT, ++ TOK_INT32, ++ TOK_UNSIGNED, ++ TOK_FLOAT, ++ TOK_DOUBLE, ++ TOK_OPAQUE, ++ TOK_CHAR, ++ TOK_STRING, ++ TOK_BOOL, ++ TOK_VOID, ++ TOK_PROGRAM, ++ TOK_VERSION, ++ TOK_EOF ++}; ++typedef enum tok_kind tok_kind; ++ ++/* ++ * a token ++ */ ++struct token { ++ tok_kind kind; ++ char *str; ++}; ++typedef struct token token; ++ ++ ++/* ++ * routine interface ++ */ ++void scan(); ++void scan2(); ++void scan3(); ++void scan_num(); ++void peek(); ++int peekscan(); ++void get_token(); ++void expected1(tok_kind); ++void expected2(tok_kind, tok_kind); ++void expected3(tok_kind, tok_kind, tok_kind); ++ +--- libtirpc-0.2.3/rpcgen/rpc_svcout.c.0005~ 2013-02-11 21:47:03.996289305 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_svcout.c 2013-02-11 21:47:03.996289305 +0100 +@@ -0,0 +1,882 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#if 0 ++ static char sccsid[] = "@(#)rpc_svcout.c 1.29 89/03/30 (C) 1987 SMI"; ++#endif ++ ++/* ++ * rpc_svcout.c, Server-skeleton outputter for the RPC protocol compiler ++ */ ++#include ++#include ++#include "rpc_parse.h" ++#include "rpc_util.h" ++#include "rpc_output.h" ++ ++static void write_real_program(definition *def); ++static void write_program(definition *def, char *storage); ++static void printerr(char *err, char *transp); ++static void printif(char *proc, char *transp, char *prefix, char *arg); ++static void write_inetmost(char *infile); ++static void print_return(char *space); ++static void print_pmapunset(char *space); ++static void print_err_message(char *space); ++static void write_timeout_func(void); ++static void write_pm_most(char *infile, int netflag); ++static void write_rpc_svc_fg(char *infile, char *sp); ++static void open_log_file(char *infile, char *sp); ++ ++static char RQSTP[] = "rqstp"; ++static char TRANSP[] = "transp"; ++static char ARG[] = "argument"; ++static char RESULT[] = "result"; ++static char ROUTINE[] = "local"; ++ ++char _errbuf[256]; /* For all messages */ ++ ++static void ++p_xdrfunc(char *rname, char *typename) ++{ ++ if (Cflag) ++ f_print(fout, "\t\txdr_%s = (xdrproc_t) xdr_%s;\n", rname, ++ stringfix(typename)); ++ else ++ f_print(fout, "\t\txdr_%s = xdr_%s;\n", rname, stringfix(typename)); ++} ++ ++void ++internal_proctype(proc_list *plist) ++{ ++ f_print(fout, "static "); ++ ptype( plist->res_prefix, plist->res_type, 1 ); ++ f_print( fout, "*" ); ++} ++ ++ ++/* ++ * write most of the service, that is, everything but the registrations. ++ */ ++void ++write_most(char *infile, int netflag, int nomain) ++{ ++ if (inetdflag || pmflag) { ++ char* var_type; ++ var_type = (nomain? "extern" : "static"); ++ f_print(fout, "%s int _rpcpmstart;", var_type ); ++ f_print(fout, "\t\t/* Started by a port monitor ? */\n"); ++ f_print(fout, "%s int _rpcfdtype;", var_type ); ++ f_print(fout, "\t\t/* Whether Stream or Datagram ? */\n"); ++ if (timerflag) { ++ f_print(fout, "%s int _rpcsvcdirty;", var_type ); ++ f_print(fout, "\t/* Still serving ? */\n"); ++ } ++ write_svc_aux( nomain ); ++ } ++ /* write out dispatcher and stubs */ ++ write_programs( nomain? (char *)NULL : "static" ); ++ ++ if( nomain ) ++ return; ++ ++ f_print(fout, "\nmain()\n"); ++ f_print(fout, "{\n"); ++ if (inetdflag) { ++ write_inetmost(infile); /* Includes call to write_rpc_svc_fg() */ ++ } else { ++ if( tirpcflag ) { ++ if (netflag) { ++ f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP); ++ f_print(fout, "\tstruct netconfig *nconf = NULL;\n"); ++ } ++ f_print(fout, "\tpid_t pid;\n"); ++ f_print(fout, "\tint i;\n"); ++ f_print(fout, "\tchar mname[FMNAMESZ + 1];\n\n"); ++ write_pm_most(infile, netflag); ++ f_print(fout, "\telse {\n"); ++ write_rpc_svc_fg(infile, "\t\t"); ++ f_print(fout, "\t}\n"); ++ } else { ++ f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP); ++ f_print(fout, "\n"); ++ print_pmapunset("\t"); ++ } ++ } ++ ++ if (logflag && !inetdflag) { ++ open_log_file(infile, "\t"); ++ } ++} ++ ++/* ++ * write a registration for the given transport ++ */ ++void ++write_netid_register(char *transp) ++{ ++ list *l; ++ definition *def; ++ version_list *vp; ++ char *sp; ++ char tmpbuf[32]; ++ ++ sp = ""; ++ f_print(fout, "\n"); ++ f_print(fout, "%s\tnconf = getnetconfigent(\"%s\");\n", sp, transp); ++ f_print(fout, "%s\tif (nconf == NULL) {\n", sp); ++ (void) sprintf(_errbuf, "cannot find %s netid.", transp); ++ sprintf(tmpbuf, "%s\t\t", sp); ++ print_err_message(tmpbuf); ++ f_print(fout, "%s\t\texit(1);\n", sp); ++ f_print(fout, "%s\t}\n", sp); ++ f_print(fout, "%s\t%s = svc_tli_create(RPC_ANYFD, nconf, 0, 0, 0);\n", ++ sp, TRANSP); ++ f_print(fout, "%s\tif (%s == NULL) {\n", sp, TRANSP); ++ (void) sprintf(_errbuf, "cannot create %s service.", transp); ++ print_err_message(tmpbuf); ++ f_print(fout, "%s\t\texit(1);\n", sp); ++ f_print(fout, "%s\t}\n", sp); ++ ++ for (l = defined; l != NULL; l = l->next) { ++ def = (definition *) l->val; ++ if (def->def_kind != DEF_PROGRAM) { ++ continue; ++ } ++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { ++ f_print(fout, ++ "%s\t(void) rpcb_unset(%s, %s, nconf);\n", ++ sp, def->def_name, vp->vers_name); ++ f_print(fout, ++ "%s\tif (!svc_reg(%s, %s, %s, ", ++ sp, TRANSP, def->def_name, vp->vers_name); ++ pvname(def->def_name, vp->vers_num); ++ f_print(fout, ", nconf)) {\n"); ++ (void) sprintf(_errbuf, "unable to register (%s, %s, %s).", ++ def->def_name, vp->vers_name, transp); ++ print_err_message(tmpbuf); ++ f_print(fout, "%s\t\texit(1);\n", sp); ++ f_print(fout, "%s\t}\n", sp); ++ } ++ } ++ f_print(fout, "%s\tfreenetconfigent(nconf);\n", sp); ++} ++ ++/* ++ * write a registration for the given transport for TLI ++ */ ++void ++write_nettype_register(char *transp) ++{ ++ list *l; ++ definition *def; ++ version_list *vp; ++ ++ for (l = defined; l != NULL; l = l->next) { ++ def = (definition *) l->val; ++ if (def->def_kind != DEF_PROGRAM) { ++ continue; ++ } ++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { ++ f_print(fout, "\tif (!svc_create("); ++ pvname(def->def_name, vp->vers_num); ++ f_print(fout, ", %s, %s, \"%s\")) {\n ", ++ def->def_name, vp->vers_name, transp); ++ (void) sprintf(_errbuf, ++ "unable to create (%s, %s) for %s.", ++ def->def_name, vp->vers_name, transp); ++ print_err_message("\t\t"); ++ f_print(fout, "\t\texit(1);\n"); ++ f_print(fout, "\t}\n"); ++ } ++ } ++} ++ ++/* ++ * write the rest of the service ++ */ ++void ++write_rest(void) ++{ ++ f_print(fout, "\n"); ++ if (inetdflag) { ++ f_print(fout, "\tif (%s == (SVCXPRT *)NULL) {\n", TRANSP); ++ (void) sprintf(_errbuf, "could not create a handle"); ++ print_err_message("\t\t"); ++ f_print(fout, "\t\texit(1);\n"); ++ f_print(fout, "\t}\n"); ++ if (timerflag) { ++ f_print(fout, "\tif (_rpcpmstart) {\n"); ++ f_print(fout, ++ "\t\t(void) signal(SIGALRM, %s closedown);\n", ++ Cflag? "(SIG_PF)" : "(void(*)())" ); ++ f_print(fout, "\t\t(void) alarm(_RPCSVC_CLOSEDOWN);\n"); ++ f_print(fout, "\t}\n"); ++ } ++ } ++ f_print(fout, "\tsvc_run();\n"); ++ (void) sprintf(_errbuf, "svc_run returned"); ++ print_err_message("\t"); ++ f_print(fout, "\texit(1);\n"); ++ f_print(fout, "\t/* NOTREACHED */\n"); ++ f_print(fout, "}\n"); ++} ++ ++void ++write_programs(char *storage) ++{ ++ list *l; ++ definition *def; ++ ++ /* write out stubs for procedure definitions */ ++ for (l = defined; l != NULL; l = l->next) { ++ def = (definition *) l->val; ++ if (def->def_kind == DEF_PROGRAM) { ++ write_real_program(def); ++ } ++ } ++ ++ /* write out dispatcher for each program */ ++ for (l = defined; l != NULL; l = l->next) { ++ def = (definition *) l->val; ++ if (def->def_kind == DEF_PROGRAM) { ++ write_program(def, storage); ++ } ++ } ++ ++ ++} ++ ++/* write out definition of internal function (e.g. _printmsg_1(...)) ++ which calls server's defintion of actual function (e.g. printmsg_1(...)). ++ Unpacks single user argument of printmsg_1 to call-by-value format ++ expected by printmsg_1. */ ++static void ++write_real_program(definition *def) ++{ ++ version_list *vp; ++ proc_list *proc; ++ decl_list *l; ++ ++ if( !newstyle ) return; /* not needed for old style */ ++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { ++ for (proc = vp->procs; proc != NULL; proc = proc->next) { ++ f_print(fout, "\n"); ++ internal_proctype(proc); ++ f_print(fout, "\n_"); ++ pvname(proc->proc_name, vp->vers_num); ++ if( Cflag ) { ++ f_print(fout, "(" ); ++ /* arg name */ ++ if (proc->arg_num > 1) ++ f_print(fout, proc->args.argname); ++ else ++ ptype(proc->args.decls->decl.prefix, ++ proc->args.decls->decl.type, 0); ++ f_print(fout, " *argp, struct svc_req *%s)\n", ++ RQSTP); ++ } else { ++ f_print(fout, "(argp, %s)\n", RQSTP ); ++ /* arg name */ ++ if (proc->arg_num > 1) ++ f_print(fout, "\t%s *argp;\n", proc->args.argname); ++ else { ++ f_print(fout, "\t"); ++ ptype(proc->args.decls->decl.prefix, ++ proc->args.decls->decl.type, 0); ++ f_print(fout, " *argp;\n"); ++ } ++ f_print(fout, " struct svc_req *%s;\n", RQSTP); ++ } ++ ++ f_print(fout, "{\n"); ++ f_print(fout, "\treturn("); ++ if( Cflag ) ++ pvname_svc(proc->proc_name, vp->vers_num); ++ else ++ pvname(proc->proc_name, vp->vers_num); ++ f_print(fout, "("); ++ if (proc->arg_num < 2) { /* single argument */ ++ if (!streq( proc->args.decls->decl.type, "void")) ++ f_print(fout, "*argp, "); /* non-void */ ++ } else { ++ for (l = proc->args.decls; l != NULL; l = l->next) ++ f_print(fout, "argp->%s, ", l->decl.name); ++ } ++ f_print(fout, "%s));\n}\n", RQSTP); ++ } ++ } ++} ++ ++static void ++write_program(definition *def, char *storage) ++{ ++ version_list *vp; ++ proc_list *proc; ++ int filled; ++ ++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { ++ f_print(fout, "\n"); ++ if (storage != NULL) { ++ f_print(fout, "%s ", storage); ++ } ++ f_print(fout, "void\n"); ++ pvname(def->def_name, vp->vers_num); ++ ++ if (Cflag) { ++ f_print(fout, "(struct svc_req *%s, ", RQSTP); ++ f_print(fout, "register SVCXPRT *%s)\n", TRANSP); ++ } else { ++ f_print(fout, "(%s, %s)\n", RQSTP, TRANSP); ++ f_print(fout, " struct svc_req *%s;\n", RQSTP); ++ f_print(fout, " register SVCXPRT *%s;\n", TRANSP); ++ } ++ ++ f_print(fout, "{\n"); ++ ++ filled = 0; ++ f_print(fout, "\tunion {\n"); ++ for (proc = vp->procs; proc != NULL; proc = proc->next) { ++ if (proc->arg_num < 2) { /* single argument */ ++ if (streq(proc->args.decls->decl.type, ++ "void")) { ++ continue; ++ } ++ filled = 1; ++ f_print(fout, "\t\t"); ++ ptype(proc->args.decls->decl.prefix, ++ proc->args.decls->decl.type, 0); ++ pvname(proc->proc_name, vp->vers_num); ++ f_print(fout, "_arg;\n"); ++ ++ } ++ else { ++ filled = 1; ++ f_print(fout, "\t\t%s", proc->args.argname); ++ f_print(fout, " "); ++ pvname(proc->proc_name, vp->vers_num); ++ f_print(fout, "_arg;\n"); ++ } ++ } ++ if (!filled) { ++ f_print(fout, "\t\tint fill;\n"); ++ } ++ f_print(fout, "\t} %s;\n", ARG); ++ f_print(fout, "\tchar *%s;\n", RESULT); ++ ++ if (Cflag) { ++ f_print(fout, "\txdrproc_t xdr_%s, xdr_%s;\n", ARG, RESULT); ++ f_print(fout, ++ "\tchar *(*%s)(char *, struct svc_req *);\n", ++ ROUTINE); ++ } else { ++ f_print(fout, "\tbool_t (*xdr_%s)(), (*xdr_%s)();\n", ARG, RESULT); ++ f_print(fout, "\tchar *(*%s)();\n", ROUTINE); ++ } ++ ++ f_print(fout, "\n"); ++ ++ if (timerflag) ++ f_print(fout, "\t_rpcsvcdirty = 1;\n"); ++ f_print(fout, "\tswitch (%s->rq_proc) {\n", RQSTP); ++ if (!nullproc(vp->procs)) { ++ f_print(fout, "\tcase NULLPROC:\n"); ++ f_print(fout, ++ "\t\t(void) svc_sendreply(%s, (xdrproc_t) xdr_void, (char *)NULL);\n", ++ TRANSP); ++ print_return("\t\t"); ++ f_print(fout, "\n"); ++ } ++ for (proc = vp->procs; proc != NULL; proc = proc->next) { ++ f_print(fout, "\tcase %s:\n", proc->proc_name); ++ if (proc->arg_num < 2) { /* single argument */ ++ p_xdrfunc( ARG, proc->args.decls->decl.type); ++ } else { ++ p_xdrfunc( ARG, proc->args.argname); ++ } ++ p_xdrfunc( RESULT, proc->res_type); ++ if( Cflag ) ++ f_print(fout, ++ "\t\t%s = (char *(*)(char *, struct svc_req *)) ", ++ ROUTINE); ++ else ++ f_print(fout, "\t\t%s = (char *(*)()) ", ROUTINE); ++ ++ if (newstyle) { /* new style: calls internal routine */ ++ f_print(fout,"_"); ++ } ++ /* Not sure about the following... ++ * rpc_hout always generates foobar_1_svc for ++ * the service procedure, so why should we use ++ * foobar_1 here?! --okir */ ++#if 0 ++ if( Cflag && !newstyle ) ++ pvname_svc(proc->proc_name, vp->vers_num); ++ else ++ pvname(proc->proc_name, vp->vers_num); ++#else ++ pvname_svc(proc->proc_name, vp->vers_num); ++#endif ++ f_print(fout, ";\n"); ++ f_print(fout, "\t\tbreak;\n\n"); ++ } ++ f_print(fout, "\tdefault:\n"); ++ printerr("noproc", TRANSP); ++ print_return("\t\t"); ++ f_print(fout, "\t}\n"); ++ ++ f_print(fout, "\t(void) memset((char *)&%s, 0, sizeof (%s));\n", ARG, ARG); ++ if (Cflag) ++ printif("getargs", TRANSP, "(caddr_t) &", ARG); ++ else ++ printif("getargs", TRANSP, "&", ARG); ++ printerr("decode", TRANSP); ++ print_return("\t\t"); ++ f_print(fout, "\t}\n"); ++ ++ if (Cflag) ++ f_print(fout, "\t%s = (*%s)((char *)&%s, %s);\n", ++ RESULT, ROUTINE, ARG, RQSTP); ++ else ++ f_print(fout, "\t%s = (*%s)(&%s, %s);\n", ++ RESULT, ROUTINE, ARG, RQSTP); ++ f_print(fout, ++ "\tif (%s != NULL && !svc_sendreply(%s, " ++ "(xdrproc_t) xdr_%s, %s)) {\n", ++ RESULT, TRANSP, RESULT, RESULT); ++ printerr("systemerr", TRANSP); ++ f_print(fout, "\t}\n"); ++ ++ if (Cflag) ++ printif("freeargs", TRANSP, "(caddr_t) &", ARG); ++ else ++ printif("freeargs", TRANSP, "&", ARG); ++ (void) sprintf(_errbuf, "unable to free arguments"); ++ print_err_message("\t\t"); ++ f_print(fout, "\t\texit(1);\n"); ++ f_print(fout, "\t}\n"); ++ print_return("\t"); ++ f_print(fout, "}\n"); ++ } ++} ++ ++static void ++printerr(char *err, char *transp) ++{ ++ f_print(fout, "\t\tsvcerr_%s(%s);\n", err, transp); ++} ++ ++static void ++printif(char *proc, char *transp, char *prefix, char *arg) ++{ ++ f_print(fout, "\tif (!svc_%s(%s, (xdrproc_t) xdr_%s, (caddr_t) %s%s)) {\n", ++ proc, transp, arg, prefix, arg); ++} ++ ++int ++nullproc(proc_list *proc) ++{ ++ for (; proc != NULL; proc = proc->next) { ++ if (streq(proc->proc_num, "0")) { ++ return (1); ++ } ++ } ++ return (0); ++} ++ ++static void ++write_inetmost(char *infile) ++{ ++ f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP); ++ f_print(fout, "\tint sock;\n"); ++ f_print(fout, "\tint proto;\n"); ++ f_print(fout, "\tstruct sockaddr_in saddr;\n"); ++ f_print(fout, "\tint asize = sizeof (saddr);\n"); ++ f_print(fout, "\n"); ++ f_print(fout, ++ "\tif (getsockname(0, (struct sockaddr *)&saddr, &asize) == 0) {\n"); ++ f_print(fout, "\t\tint ssize = sizeof (int);\n\n"); ++ f_print(fout, "\t\tif (saddr.sin_family != AF_INET)\n"); ++ f_print(fout, "\t\t\texit(1);\n"); ++ f_print(fout, "\t\tif (getsockopt(0, SOL_SOCKET, SO_TYPE,\n"); ++ f_print(fout, "\t\t\t\t(char *)&_rpcfdtype, &ssize) == -1)\n"); ++ f_print(fout, "\t\t\texit(1);\n"); ++ f_print(fout, "\t\tsock = 0;\n"); ++ f_print(fout, "\t\t_rpcpmstart = 1;\n"); ++ f_print(fout, "\t\tproto = 0;\n"); ++ open_log_file(infile, "\t\t"); ++ f_print(fout, "\t} else {\n"); ++ write_rpc_svc_fg(infile, "\t\t"); ++ f_print(fout, "\t\tsock = RPC_ANYSOCK;\n"); ++ print_pmapunset("\t\t"); ++ f_print(fout, "\t}\n"); ++} ++ ++static void ++print_return(char *space) ++{ ++ if (exitnow) ++ f_print(fout, "%sexit(0);\n", space); ++ else { ++ if (timerflag) ++ f_print(fout, "%s_rpcsvcdirty = 0;\n", space); ++ f_print(fout, "%sreturn;\n", space); ++ } ++} ++ ++static void ++print_pmapunset(char *space) ++{ ++ list *l; ++ definition *def; ++ version_list *vp; ++ ++ for (l = defined; l != NULL; l = l->next) { ++ def = (definition *) l->val; ++ if (def->def_kind == DEF_PROGRAM) { ++ for (vp = def->def.pr.versions; vp != NULL; ++ vp = vp->next) { ++ f_print(fout, "%s(void) pmap_unset(%s, %s);\n", ++ space, def->def_name, vp->vers_name); ++ } ++ } ++ } ++} ++ ++static void ++print_err_message(char *space) ++{ ++ if (logflag) ++ f_print(fout, "%ssyslog(LOG_ERR, \"%s\");\n", space, _errbuf); ++ else if (inetdflag || pmflag) ++ f_print(fout, "%s_msgout(\"%s\");\n", space, _errbuf); ++ else ++ f_print(fout, "%sfprintf(stderr, \"%s\");\n", space, _errbuf); ++} ++ ++/* ++ * Write the server auxiliary function ( _msgout, timeout) ++ */ ++void ++write_svc_aux(int nomain) ++{ ++ if (!logflag) ++ write_msg_out(); ++ if( !nomain ) ++ write_timeout_func(); ++} ++ ++/* ++ * Write the _msgout function ++ */ ++void ++write_msg_out(void) ++{ ++ f_print(fout, "\n"); ++ f_print(fout, "static\n"); ++ if( !Cflag ) { ++ f_print(fout, "void _msgout(msg)\n"); ++ f_print(fout, "\tchar *msg;\n"); ++ } else { ++ f_print(fout, "void _msgout(char* msg)\n"); ++ } ++ f_print(fout, "{\n"); ++ f_print(fout, "#ifdef RPC_SVC_FG\n"); ++ if (inetdflag || pmflag) ++ f_print(fout, "\tif (_rpcpmstart)\n"); ++ f_print(fout, "\t\tsyslog(LOG_ERR, \"%%s\", msg);\n"); ++ f_print(fout, "\telse\n"); ++ f_print(fout, "\t\t(void) fprintf(stderr, \"%%s\\n\", msg);\n"); ++ f_print(fout, "#else\n"); ++ f_print(fout, "\tsyslog(LOG_ERR, \"%%s\", msg);\n"); ++ f_print(fout, "#endif\n"); ++ f_print(fout, "}\n"); ++} ++ ++/* ++ * Write the timeout function ++ */ ++static void ++write_timeout_func(void) ++{ ++ if (!timerflag) ++ return; ++ f_print(fout, "\n"); ++ f_print(fout, "static void\n"); ++ f_print(fout, "closedown()\n"); ++ f_print(fout, "{\n"); ++ f_print(fout, "\tif (_rpcsvcdirty == 0) {\n"); ++ f_print(fout, "\t\tstatic int size;\n"); ++ f_print(fout, "\t\tint i, openfd;\n"); ++ if (tirpcflag && pmflag) { ++ f_print(fout, "\t\tstruct t_info tinfo;\n\n"); ++ f_print(fout, "\t\tif (!t_getinfo(0, &tinfo) && (tinfo.servtype == T_CLTS))\n"); ++ } else { ++ f_print(fout, "\n\t\tif (_rpcfdtype == SOCK_DGRAM)\n"); ++ } ++ f_print(fout, "\t\t\texit(0);\n"); ++ f_print(fout, "\t\tif (size == 0) {\n"); ++ if( tirpcflag ) { ++ f_print(fout, "\t\t\tstruct rlimit rl;\n\n"); ++ f_print(fout, "\t\t\trl.rlim_max = 0;\n"); ++ f_print(fout, "\t\t\tgetrlimit(RLIMIT_NOFILE, &rl);\n"); ++ f_print(fout, "\t\t\tif ((size = rl.rlim_max) == 0)\n"); ++ f_print(fout, "\t\t\t\treturn;\n"); ++ } else { ++ f_print(fout, "\t\t\tsize = getdtablesize();\n"); ++ } ++ f_print(fout, "\t\t}\n"); ++ f_print(fout, "\t\tfor (i = 0, openfd = 0; i < size && openfd < 2; i++)\n"); ++ f_print(fout, "\t\t\tif (FD_ISSET(i, &svc_fdset))\n"); ++ f_print(fout, "\t\t\t\topenfd++;\n"); ++ f_print(fout, "\t\tif (openfd <= 1)\n"); ++ f_print(fout, "\t\t\texit(0);\n"); ++ f_print(fout, "\t}\n"); ++ f_print(fout, "\t(void) alarm(_RPCSVC_CLOSEDOWN);\n"); ++ f_print(fout, "}\n"); ++} ++ ++/* ++ * Write the most of port monitor support ++ */ ++static void ++write_pm_most(char *infile, int netflag) ++{ ++ list *l; ++ definition *def; ++ version_list *vp; ++ ++ f_print(fout, "\tif (!ioctl(0, I_LOOK, mname) &&\n"); ++ f_print(fout, "\t\t(!strcmp(mname, \"sockmod\") ||"); ++ f_print(fout, " !strcmp(mname, \"timod\"))) {\n"); ++ f_print(fout, "\t\tchar *netid;\n"); ++ if (!netflag) { /* Not included by -n option */ ++ f_print(fout, "\t\tstruct netconfig *nconf = NULL;\n"); ++ f_print(fout, "\t\tSVCXPRT *%s;\n", TRANSP); ++ } ++ if( timerflag ) ++ f_print(fout, "\t\tint pmclose;\n"); ++/* not necessary, defined in /usr/include/stdlib */ ++/* f_print(fout, "\t\textern char *getenv();\n");*/ ++ f_print(fout, "\n"); ++ f_print(fout, "\t\t_rpcpmstart = 1;\n"); ++ if (logflag) ++ open_log_file(infile, "\t\t"); ++ f_print(fout, "\t\tif ((netid = getenv(\"NLSPROVIDER\")) == NULL) {\n"); ++ sprintf(_errbuf, "cannot get transport name"); ++ print_err_message("\t\t\t"); ++ f_print(fout, "\t\t} else if ((nconf = getnetconfigent(netid)) == NULL) {\n"); ++ sprintf(_errbuf, "cannot get transport info"); ++ print_err_message("\t\t\t"); ++ f_print(fout, "\t\t}\n"); ++ /* ++ * A kludgy support for inetd services. Inetd only works with ++ * sockmod, and RPC works only with timod, hence all this jugglery ++ */ ++ f_print(fout, "\t\tif (strcmp(mname, \"sockmod\") == 0) {\n"); ++ f_print(fout, "\t\t\tif (ioctl(0, I_POP, 0) || ioctl(0, I_PUSH, \"timod\")) {\n"); ++ sprintf(_errbuf, "could not get the right module"); ++ print_err_message("\t\t\t\t"); ++ f_print(fout, "\t\t\t\texit(1);\n"); ++ f_print(fout, "\t\t\t}\n"); ++ f_print(fout, "\t\t}\n"); ++ if( timerflag ) ++ f_print(fout, "\t\tpmclose = (t_getstate(0) != T_DATAXFER);\n"); ++ f_print(fout, "\t\tif ((%s = svc_tli_create(0, nconf, NULL, 0, 0)) == NULL) {\n", ++ TRANSP); ++ sprintf(_errbuf, "cannot create server handle"); ++ print_err_message("\t\t\t"); ++ f_print(fout, "\t\t\texit(1);\n"); ++ f_print(fout, "\t\t}\n"); ++ f_print(fout, "\t\tif (nconf)\n"); ++ f_print(fout, "\t\t\tfreenetconfigent(nconf);\n"); ++ for (l = defined; l != NULL; l = l->next) { ++ def = (definition *) l->val; ++ if (def->def_kind != DEF_PROGRAM) { ++ continue; ++ } ++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { ++ f_print(fout, ++ "\t\tif (!svc_reg(%s, %s, %s, ", ++ TRANSP, def->def_name, vp->vers_name); ++ pvname(def->def_name, vp->vers_num); ++ f_print(fout, ", 0)) {\n"); ++ (void) sprintf(_errbuf, "unable to register (%s, %s).", ++ def->def_name, vp->vers_name); ++ print_err_message("\t\t\t"); ++ f_print(fout, "\t\t\texit(1);\n"); ++ f_print(fout, "\t\t}\n"); ++ } ++ } ++ if (timerflag) { ++ f_print(fout, "\t\tif (pmclose) {\n"); ++ f_print(fout, "\t\t\t(void) signal(SIGALRM, %s closedown);\n", ++ Cflag? "(SIG_PF)" : "(void(*)())" ); ++ f_print(fout, "\t\t\t(void) alarm(_RPCSVC_CLOSEDOWN);\n"); ++ f_print(fout, "\t\t}\n"); ++ } ++ f_print(fout, "\t\tsvc_run();\n"); ++ f_print(fout, "\t\texit(1);\n"); ++ f_print(fout, "\t\t/* NOTREACHED */\n"); ++ f_print(fout, "\t}\n"); ++} ++ ++/* ++ * Support for backgrounding the server if self started. ++ */ ++static void ++write_rpc_svc_fg(char *infile, char *sp) ++{ ++ f_print(fout, "#ifndef RPC_SVC_FG\n"); ++ f_print(fout, "%sint size;\n", sp); ++ if( tirpcflag ) ++ f_print(fout, "%sstruct rlimit rl;\n", sp); ++ if (inetdflag) ++ f_print(fout, "%sint pid, i;\n\n", sp); ++ f_print(fout, "%spid = fork();\n", sp); ++ f_print(fout, "%sif (pid < 0) {\n", sp); ++ f_print(fout, "%s\tperror(\"cannot fork\");\n", sp); ++ f_print(fout, "%s\texit(1);\n", sp); ++ f_print(fout, "%s}\n", sp); ++ f_print(fout, "%sif (pid)\n", sp); ++ f_print(fout, "%s\texit(0);\n", sp); ++ /* get number of file descriptors */ ++ if( tirpcflag ) { ++ f_print(fout, "%srl.rlim_max = 0;\n", sp); ++ f_print(fout, "%sgetrlimit(RLIMIT_NOFILE, &rl);\n", sp); ++ f_print(fout, "%sif ((size = rl.rlim_max) == 0)\n", sp); ++ f_print(fout, "%s\texit(1);\n", sp); ++ } else { ++ f_print(fout, "%ssize = getdtablesize();\n", sp); ++ } ++ ++ f_print(fout, "%sfor (i = 0; i < size; i++)\n", sp); ++ f_print(fout, "%s\t(void) close(i);\n", sp); ++ /* Redirect stderr and stdout to console */ ++ f_print(fout, "%si = open(\"/dev/console\", 2);\n", sp); ++ f_print(fout, "%s(void) dup2(i, 1);\n", sp); ++ f_print(fout, "%s(void) dup2(i, 2);\n", sp); ++ /* This removes control of the controlling terminal */ ++ if( tirpcflag ) ++ f_print(fout, "%ssetsid();\n", sp); ++ else { ++ f_print(fout, "%si = open(\"/dev/tty\", 2);\n", sp); ++ f_print(fout, "%sif (i >= 0) {\n", sp); ++ f_print(fout, "%s\t(void) ioctl(i, TIOCNOTTY, (char *)NULL);\n", sp);; ++ f_print(fout, "%s\t(void) close(i);\n", sp); ++ f_print(fout, "%s}\n", sp); ++ } ++ if (!logflag) ++ open_log_file(infile, sp); ++ f_print(fout, "#endif\n"); ++ if (logflag) ++ open_log_file(infile, sp); ++} ++ ++static void ++open_log_file(char *infile, char *sp) ++{ ++ char *s; ++ ++ s = strrchr(infile, '.'); ++ if (s) ++ *s = '\0'; ++ f_print(fout,"%sopenlog(\"%s\", LOG_PID, LOG_DAEMON);\n", sp, infile); ++ if (s) ++ *s = '.'; ++} ++ ++ ++ ++ ++/* ++ * write a registration for the given transport for Inetd ++ */ ++void ++write_inetd_register(char *transp) ++{ ++ list *l; ++ definition *def; ++ version_list *vp; ++ char *sp; ++ int isudp; ++ char tmpbuf[32]; ++ ++ if (inetdflag) ++ sp = "\t"; ++ else ++ sp = ""; ++ if (streq(transp, "udp")) ++ isudp = 1; ++ else ++ isudp = 0; ++ f_print(fout, "\n"); ++ if (inetdflag) { ++ f_print(fout, "\tif ((_rpcfdtype == 0) || (_rpcfdtype == %s)) {\n", ++ isudp ? "SOCK_DGRAM" : "SOCK_STREAM"); ++ } ++ f_print(fout, "%s\t%s = svc%s_create(%s", ++ sp, TRANSP, transp, inetdflag? "sock": "RPC_ANYSOCK"); ++ if (!isudp) ++ f_print(fout, ", 0, 0"); ++ f_print(fout, ");\n"); ++ f_print(fout, "%s\tif (%s == NULL) {\n", sp, TRANSP); ++ (void) sprintf(_errbuf, "cannot create %s service.", transp); ++ (void) sprintf(tmpbuf, "%s\t\t", sp); ++ print_err_message(tmpbuf); ++ f_print(fout, "%s\t\texit(1);\n", sp); ++ f_print(fout, "%s\t}\n", sp); ++ ++ if (inetdflag) { ++ f_print(fout, "%s\tif (!_rpcpmstart)\n\t", sp); ++ f_print(fout, "%s\tproto = IPPROTO_%s;\n", ++ sp, isudp ? "UDP": "TCP"); ++ } ++ for (l = defined; l != NULL; l = l->next) { ++ def = (definition *) l->val; ++ if (def->def_kind != DEF_PROGRAM) { ++ continue; ++ } ++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { ++ f_print(fout, "%s\tif (!svc_register(%s, %s, %s, ", ++ sp, TRANSP, def->def_name, vp->vers_name); ++ pvname(def->def_name, vp->vers_num); ++ if (inetdflag) ++ f_print(fout, ", proto)) {\n"); ++ else ++ f_print(fout, ", IPPROTO_%s)) {\n", ++ isudp ? "UDP": "TCP"); ++ (void) sprintf(_errbuf, "unable to register (%s, %s, %s).", ++ def->def_name, vp->vers_name, transp); ++ print_err_message(tmpbuf); ++ f_print(fout, "%s\t\texit(1);\n", sp); ++ f_print(fout, "%s\t}\n", sp); ++ } ++ } ++ if (inetdflag) ++ f_print(fout, "\t}\n"); ++} +--- libtirpc-0.2.3/rpcgen/rpc_tblout.c.0005~ 2013-02-11 21:47:03.996289305 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_tblout.c 2013-02-11 21:47:03.996289305 +0100 +@@ -0,0 +1,165 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#if 0 ++static char sccsid[] = "@(#)rpc_tblout.c 1.4 89/02/22 (C) 1988 SMI"; ++#endif ++ ++/* ++ * rpc_tblout.c, Dispatch table outputter for the RPC protocol compiler ++ */ ++#include ++#include ++#include "rpc_parse.h" ++#include "rpc_util.h" ++#include "rpc_output.h" ++ ++static void write_table(definition *def); ++static void printit(char *prefix, char *type); ++ ++#define TABSIZE 8 ++#define TABCOUNT 5 ++#define TABSTOP (TABSIZE*TABCOUNT) ++ ++static char tabstr[TABCOUNT+1] = "\t\t\t\t\t"; ++ ++static char tbl_hdr[] = "struct rpcgen_table %s_table[] = {\n"; ++static char tbl_end[] = "};\n"; ++ ++static char null_entry[] = "\n\t(char *(*)())0,\n\ ++ \t(xdrproc_t) xdr_void,\t\t\t0,\n\ ++ \t(xdrproc_t) xdr_void,\t\t\t0,\n"; ++ ++ ++static char tbl_nproc[] = "int %s_nproc =\n\tsizeof(%s_table)/sizeof(%s_table[0]);\n\n"; ++ ++void ++write_tables(void) ++{ ++ list *l; ++ definition *def; ++ ++ f_print(fout, "\n"); ++ for (l = defined; l != NULL; l = l->next) { ++ def = (definition *) l->val; ++ if (def->def_kind == DEF_PROGRAM) { ++ write_table(def); ++ } ++ } ++} ++ ++static void ++write_table(definition *def) ++{ ++ version_list *vp; ++ proc_list *proc; ++ int current; ++ int expected; ++ char progvers[100]; ++ int warning; ++ ++ for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { ++ warning = 0; ++ s_print(progvers, "%s_%s", ++ locase(def->def_name), vp->vers_num); ++ /* print the table header */ ++ f_print(fout, tbl_hdr, progvers); ++ ++ if (nullproc(vp->procs)) { ++ expected = 0; ++ } else { ++ expected = 1; ++ f_print(fout, null_entry); ++ } ++ for (proc = vp->procs; proc != NULL; proc = proc->next) { ++ current = atoi(proc->proc_num); ++ if (current != expected++) { ++ f_print(fout, ++ "\n/*\n * WARNING: table out of order\n */\n"); ++ if (warning == 0) { ++ f_print(stderr, ++ "WARNING %s table is out of order\n", ++ progvers); ++ warning = 1; ++ nonfatalerrors = 1; ++ } ++ expected = current + 1; ++ } ++ f_print(fout, "\n\t(char *(*)())RPCGEN_ACTION("); ++ ++ /* routine to invoke */ ++ if( Cflag && !newstyle ) ++ pvname_svc(proc->proc_name, vp->vers_num); ++ else { ++ if( newstyle ) ++ f_print( fout, "_"); /* calls internal func */ ++ pvname(proc->proc_name, vp->vers_num); ++ } ++ f_print(fout, "),\n"); ++ ++ /* argument info */ ++ if( proc->arg_num > 1 ) ++ printit((char*) NULL, proc->args.argname ); ++ else ++ /* do we have to do something special for newstyle */ ++ printit( proc->args.decls->decl.prefix, ++ proc->args.decls->decl.type ); ++ /* result info */ ++ printit(proc->res_prefix, proc->res_type); ++ } ++ ++ /* print the table trailer */ ++ f_print(fout, tbl_end); ++ f_print(fout, tbl_nproc, progvers, progvers, progvers); ++ } ++} ++ ++static void ++printit(char *prefix, char *type) ++{ ++ int len; ++ int tabs; ++ ++ ++ len = fprintf(fout, "\txdr_%s,", stringfix(type)); ++ /* account for leading tab expansion */ ++ len += TABSIZE - 1; ++ /* round up to tabs required */ ++ tabs = (TABSTOP - len + TABSIZE - 1)/TABSIZE; ++ f_print(fout, "%s", &tabstr[TABCOUNT-tabs]); ++ ++ if (streq(type, "void")) { ++ f_print(fout, "0"); ++ } else { ++ f_print(fout, "sizeof ( "); ++ /* XXX: should "follow" be 1 ??? */ ++ ptype(prefix, type, 0); ++ f_print(fout, ")"); ++ } ++ f_print(fout, ",\n"); ++} +--- libtirpc-0.2.3/rpcgen/rpc_util.c.0005~ 2013-02-11 21:47:03.997289317 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_util.c 2013-02-11 21:47:03.997289317 +0100 +@@ -0,0 +1,479 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#if 0 ++static char sccsid[] = "@(#)rpc_util.c 1.11 89/02/22 (C) 1987 SMI"; ++#endif ++ ++/* ++ * rpc_util.c, Utility routines for the RPC protocol compiler ++ */ ++#include ++#include ++#include ++#include ++#include "rpc_scan.h" ++#include "rpc_parse.h" ++#include "rpc_util.h" ++ ++static void printwhere(void); ++ ++ ++#define ARGEXT "argument" ++ ++char curline[MAXLINESIZE]; /* current read line */ ++char *where = curline; /* current point in line */ ++int linenum = 0; /* current line number */ ++ ++char *infilename; /* input filename */ ++ ++#define NFILES 7 ++char *outfiles[NFILES]; /* output file names */ ++int nfiles; ++ ++FILE *fout; /* file pointer of current output */ ++FILE *fin; /* file pointer of current input */ ++ ++list *defined; /* list of defined things */ ++ ++/* ++ * Reinitialize the world ++ */ ++void ++reinitialize(void) ++{ ++ memset(curline, 0, MAXLINESIZE); ++ where = curline; ++ linenum = 0; ++ defined = NULL; ++} ++ ++/* ++ * string equality ++ */ ++int ++streq(char *a, char *b) ++{ ++ return (strcmp(a, b) == 0); ++} ++ ++/* ++ * find a value in a list ++ */ ++definition * ++findval(list *lst, char *val, int (*cmp)(definition *, char *)) ++{ ++ ++ for (; lst != NULL; lst = lst->next) { ++ if ((*cmp) (lst->val, val)) { ++ return (lst->val); ++ } ++ } ++ return (NULL); ++} ++ ++/* ++ * store a value in a list ++ */ ++void ++storeval(lstp, val) ++ list **lstp; ++ definition *val; ++{ ++ list **l; ++ list *lst; ++ ++ ++ for (l = lstp; *l != NULL; l = (list **) & (*l)->next); ++ lst = ALLOC(list); ++ lst->val = val; ++ lst->next = NULL; ++ *l = lst; ++} ++ ++static int ++findit(definition *def, char *type) ++{ ++ return (streq(def->def_name, type)); ++} ++ ++static char * ++fixit(char *type, char *orig) ++{ ++ definition *def; ++ ++ def = (definition *) FINDVAL(defined, type, findit); ++ if (def == NULL || def->def_kind != DEF_TYPEDEF) { ++ return (orig); ++ } ++ switch (def->def.ty.rel) { ++ case REL_VECTOR: ++ return (def->def.ty.old_type); ++ case REL_ALIAS: ++ return (fixit(def->def.ty.old_type, orig)); ++ default: ++ return (orig); ++ } ++} ++ ++char * ++fixtype(char *type) ++{ ++ return (fixit(type, type)); ++} ++ ++char * ++stringfix(char *type) ++{ ++ if (streq(type, "string")) { ++ return ("wrapstring"); ++ } else { ++ return (type); ++ } ++} ++ ++void ++ptype(char *prefix, char *type, int follow) ++{ ++ if (prefix != NULL) { ++ if (streq(prefix, "enum")) { ++ f_print(fout, "enum "); ++ } else { ++ f_print(fout, "struct "); ++ } ++ } ++ if (streq(type, "bool")) { ++ f_print(fout, "bool_t "); ++ } else if (streq(type, "string")) { ++ f_print(fout, "char *"); ++ } else { ++ f_print(fout, "%s ", follow ? fixtype(type) : type); ++ } ++} ++ ++static int ++typedefed(definition *def, char *type) ++{ ++ if (def->def_kind != DEF_TYPEDEF || def->def.ty.old_prefix != NULL) { ++ return (0); ++ } else { ++ return (streq(def->def_name, type)); ++ } ++} ++ ++int ++isvectordef(char *type, relation rel) ++{ ++ definition *def; ++ ++ for (;;) { ++ switch (rel) { ++ case REL_VECTOR: ++ return (!streq(type, "string")); ++ case REL_ARRAY: ++ return (0); ++ case REL_POINTER: ++ return (0); ++ case REL_ALIAS: ++ def = (definition *) FINDVAL(defined, type, typedefed); ++ if (def == NULL) { ++ return (0); ++ } ++ type = def->def.ty.old_type; ++ rel = def->def.ty.rel; ++ } ++ } ++} ++ ++char * ++locase(char *str) ++{ ++ char c; ++ static char buf[100]; ++ char *p = buf; ++ ++ while ((c = *str++) != '\0') { ++ *p++ = (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c; ++ } ++ *p = 0; ++ return (buf); ++} ++ ++void ++pvname_svc(char *pname, char *vnum) ++{ ++ f_print(fout, "%s_%s_svc", locase(pname), vnum); ++} ++ ++void ++pvname(char *pname, char *vnum) ++{ ++ f_print(fout, "%s_%s", locase(pname), vnum); ++} ++ ++/* ++ * print a useful (?) error message, and then die ++ */ ++void ++error(char *msg) ++{ ++ printwhere(); ++ f_print(stderr, "%s, line %d: ", infilename, linenum); ++ f_print(stderr, "%s\n", msg); ++ crash(); ++} ++ ++/* ++ * Something went wrong, unlink any files that we may have created and then ++ * die. ++ */ ++void ++crash(void) ++{ ++ int i; ++ ++ for (i = 0; i < nfiles; i++) { ++ (void) unlink(outfiles[i]); ++ } ++ exit(1); ++} ++ ++void ++record_open(char *file) ++{ ++ if (nfiles < NFILES) { ++ outfiles[nfiles++] = file; ++ } else { ++ f_print(stderr, "too many files!\n"); ++ crash(); ++ } ++} ++ ++static char expectbuf[100]; ++static char *toktostr(); ++ ++/* ++ * error, token encountered was not the expected one ++ */ ++void ++expected1(exp1) ++ tok_kind exp1; ++{ ++ s_print(expectbuf, "expected '%s'", ++ toktostr(exp1)); ++ error(expectbuf); ++} ++ ++/* ++ * error, token encountered was not one of two expected ones ++ */ ++void ++expected2(exp1, exp2) ++ tok_kind exp1, exp2; ++{ ++ s_print(expectbuf, "expected '%s' or '%s'", ++ toktostr(exp1), ++ toktostr(exp2)); ++ error(expectbuf); ++} ++ ++/* ++ * error, token encountered was not one of 3 expected ones ++ */ ++void ++expected3(exp1, exp2, exp3) ++ tok_kind exp1, exp2, exp3; ++{ ++ s_print(expectbuf, "expected '%s', '%s' or '%s'", ++ toktostr(exp1), ++ toktostr(exp2), ++ toktostr(exp3)); ++ error(expectbuf); ++} ++ ++void ++tabify(f, tab) ++ FILE *f; ++ int tab; ++{ ++ while (tab--) { ++ (void) fputc('\t', f); ++ } ++} ++ ++ ++static token tokstrings[] = { ++ {TOK_IDENT, "identifier"}, ++ {TOK_CONST, "const"}, ++ {TOK_RPAREN, ")"}, ++ {TOK_LPAREN, "("}, ++ {TOK_RBRACE, "}"}, ++ {TOK_LBRACE, "{"}, ++ {TOK_LBRACKET, "["}, ++ {TOK_RBRACKET, "]"}, ++ {TOK_STAR, "*"}, ++ {TOK_COMMA, ","}, ++ {TOK_EQUAL, "="}, ++ {TOK_COLON, ":"}, ++ {TOK_SEMICOLON, ";"}, ++ {TOK_UNION, "union"}, ++ {TOK_STRUCT, "struct"}, ++ {TOK_SWITCH, "switch"}, ++ {TOK_CASE, "case"}, ++ {TOK_DEFAULT, "default"}, ++ {TOK_ENUM, "enum"}, ++ {TOK_TYPEDEF, "typedef"}, ++ {TOK_INT, "int"}, ++ {TOK_SHORT, "short"}, ++ {TOK_INT32, "int32"}, ++ {TOK_UNSIGNED, "unsigned"}, ++ {TOK_DOUBLE, "double"}, ++ {TOK_FLOAT, "float"}, ++ {TOK_CHAR, "char"}, ++ {TOK_STRING, "string"}, ++ {TOK_OPAQUE, "opaque"}, ++ {TOK_BOOL, "bool"}, ++ {TOK_VOID, "void"}, ++ {TOK_PROGRAM, "program"}, ++ {TOK_VERSION, "version"}, ++ {TOK_EOF, "??????"} ++}; ++ ++static char * ++toktostr(kind) ++ tok_kind kind; ++{ ++ token *sp; ++ ++ for (sp = tokstrings; sp->kind != TOK_EOF && sp->kind != kind; sp++); ++ return (sp->str); ++} ++ ++static void ++printbuf(void) ++{ ++ char c; ++ int i; ++ int cnt; ++ ++# define TABSIZE 4 ++ ++ for (i = 0; (c = curline[i]) != '\0'; i++) { ++ if (c == '\t') { ++ cnt = 8 - (i % TABSIZE); ++ c = ' '; ++ } else { ++ cnt = 1; ++ } ++ while (cnt--) { ++ (void) fputc(c, stderr); ++ } ++ } ++} ++ ++static void ++printwhere(void) ++{ ++ int i; ++ char c; ++ int cnt; ++ ++ printbuf(); ++ for (i = 0; i < where - curline; i++) { ++ c = curline[i]; ++ if (c == '\t') { ++ cnt = 8 - (i % TABSIZE); ++ } else { ++ cnt = 1; ++ } ++ while (cnt--) { ++ (void) fputc('^', stderr); ++ } ++ } ++ (void) fputc('\n', stderr); ++} ++ ++char * ++make_argname(char *pname, char *vname) ++{ ++ char *name; ++ ++ name = malloc(strlen(pname) + strlen(vname) + strlen(ARGEXT) + 3); ++ if (!name) { ++ fprintf(stderr, "failed in malloc"); ++ exit(1); ++ } ++ sprintf(name, "%s_%s_%s", locase(pname), vname, ARGEXT); ++ return(name); ++} ++ ++bas_type *typ_list_h; ++bas_type *typ_list_t; ++ ++void ++add_type(int len, char *type) ++{ ++ bas_type *ptr; ++ ++ ++ if ((ptr = (bas_type *) malloc(sizeof(bas_type))) == (bas_type *) NULL) { ++ fprintf(stderr, "failed in malloc"); ++ exit(1); ++ } ++ ptr->name = type; ++ ptr->length = len; ++ ptr->next = NULL; ++ if (typ_list_t == NULL) { ++ ++ typ_list_t = ptr; ++ typ_list_h = ptr; ++ } else { ++ ++ typ_list_t->next = ptr; ++ typ_list_t = ptr; ++ } ++} ++ ++ ++bas_type * ++find_type(char *type) ++{ ++ bas_type *ptr; ++ ++ ptr = typ_list_h; ++ ++ ++ while (ptr != NULL) { ++ if (strcmp(ptr->name, type) == 0) ++ return (ptr); ++ else ++ ptr = ptr->next; ++ }; ++ return (NULL); ++} ++ +--- libtirpc-0.2.3/rpcgen/rpc_util.h.0005~ 2013-02-11 21:47:03.997289317 +0100 ++++ libtirpc-0.2.3/rpcgen/rpc_util.h 2013-02-11 21:47:03.997289317 +0100 +@@ -0,0 +1,166 @@ ++/* ++ * Copyright (c) 2009, Sun Microsystems, Inc. ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions are met: ++ * - Redistributions of source code must retain the above copyright notice, ++ * this list of conditions and the following disclaimer. ++ * - Redistributions in binary form must reproduce the above copyright notice, ++ * this list of conditions and the following disclaimer in the documentation ++ * and/or other materials provided with the distribution. ++ * - Neither the name of Sun Microsystems, Inc. nor the names of its ++ * contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE ++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ * POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++/* @(#)rpc_util.h 1.5 90/08/29 (C) 1987 SMI */ ++ ++/* ++ * rpc_util.h, Useful definitions for the RPC protocol compiler ++ */ ++ ++#include ++ ++#define alloc(size) malloc((unsigned)(size)) ++#define ALLOC(object) (object *) malloc(sizeof(object)) ++ ++#define s_print (void) sprintf ++#define f_print (void) fprintf ++ ++struct list { ++ definition *val; ++ struct list *next; ++}; ++typedef struct list list; ++ ++#define PUT 1 ++#define GET 2 ++ ++/* ++ * Global variables ++ */ ++#define MAXLINESIZE 1024 ++extern char curline[MAXLINESIZE]; ++extern char *where; ++extern int linenum; ++ ++extern char *infilename; ++extern FILE *fout; ++extern FILE *fin; ++ ++extern list *defined; ++ ++ ++extern bas_type *typ_list_h; ++extern bas_type *typ_list_t; ++ ++/* ++ * All the option flags ++ */ ++extern int inetdflag; ++extern int pmflag; ++extern int tblflag; ++extern int logflag; ++extern int newstyle; ++extern int Cflag; /* C++ flag */ ++extern int tirpcflag; /* flag for generating tirpc code */ ++extern int Inline; /* if this is 0, then do not generate inline code */ ++ ++/* ++ * Other flags related with inetd jumpstart. ++ */ ++extern int indefinitewait; ++extern int exitnow; ++extern int timerflag; ++ ++extern int nonfatalerrors; ++ ++/* ++ * rpc_util routines ++ */ ++void storeval(); ++ ++#define STOREVAL(list,item) \ ++ storeval(list,item) ++ ++definition *findval(); ++ ++#define FINDVAL(list,item,finder) \ ++ findval(list, item, finder) ++ ++ ++/* ++ * rpc_cout routines ++ */ ++void cprint(void); ++void emit(definition *); ++ ++/* ++ * rpc_hout routines ++ */ ++void print_datadef(definition *); ++void print_funcdef(definition *); ++ ++/* ++ * rpc_svcout routines ++ */ ++void write_most(char *, int, int); ++void write_register(void); ++void write_netid_register(char *); ++void write_nettype_register(char *); ++void write_inetd_register(char *); ++void write_rest(void); ++void write_programs(char *); ++void write_svc_aux(int); ++ ++/* ++ * rpc_clntout routines ++ */ ++void write_stubs(void); ++void printarglist(proc_list *, char *, char *); ++ ++/* ++ * rpc_tblout routines ++ */ ++void write_tables(void); ++ ++/* ++ * rpc_util ++ */ ++void pvname_svc(char *, char *); ++void pvname(char *, char *); ++void ptype(char *, char *, int); ++char * make_argname(char *, char *); ++void add_type(int, char *); ++void reinitialize(void); ++void crash(void); ++void error(char *); ++char *fixtype(char *); ++char *stringfix(char *); ++char *locase(char *); ++int isvectordef(char *, relation); ++int streq(char *, char *); ++void tabify(FILE *, int); ++void record_open(char *); ++bas_type *find_type(char *type); ++ ++/* ++ * rpc_sample ++ */ ++void write_sample_svc(definition *); ++int write_sample_clnt(definition *); ++void write_sample_clnt_main(void); ++void add_sample_msg(void); diff --git a/meta/recipes-extended/libtirpc/libtirpc-0.2.3/nis.h b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/nis.h new file mode 100644 index 0000000000..5c5c7bb41b --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/nis.h @@ -0,0 +1,616 @@ +/* + * Copyright (c) 2010, Oracle America, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials + * provided with the distribution. + * * Neither the name of the "Oracle America, Inc." nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _RPCSVC_NIS_H +#define _RPCSVC_NIS_H 1 + +#include +#include +#include + +__BEGIN_DECLS + +/* + * nis.h + * + * This file is the main include file for NIS clients. It contains + * both the client library function defines and the various data + * structures used by the NIS service. It includes the file nis_tags.h + * which defines the tag values. This allows the tags to change without + * having to change the nis.x file. + * + * NOTE : THIS FILE IS NOT GENERATED WITH RPCGEN ! SO YOU HAVE TO + * ADD ALL THE CHANGES ON nis_*.x FILES HERE AGAIN ! + * + * I have removed all the Solaris internal structs and variables, + * because they are not supported, Sun changed them between various + * releases and they shouldn't be used in user programs. + * + */ + + +#ifndef __nis_object_h +#define __nis_object_h + +#define NIS_MAXSTRINGLEN 255 +#define NIS_MAXNAMELEN 1024 +#define NIS_MAXATTRNAME 32 +#define NIS_MAXATTRVAL 2048 +#define NIS_MAXCOLUMNS 64 +#define NIS_MAXATTR 16 +#define NIS_MAXPATH 1024 +#define NIS_MAXREPLICAS 128 +#define NIS_MAXLINKS 16 +#define NIS_PK_NONE 0 +#define NIS_PK_DH 1 +#define NIS_PK_RSA 2 +#define NIS_PK_KERB 3 +#define NIS_PK_DHEXT 4 + +struct nis_attr { + char *zattr_ndx; + struct { + u_int zattr_val_len; + char *zattr_val_val; + } zattr_val; +}; +typedef struct nis_attr nis_attr; + +typedef char *nis_name; + +enum zotypes { + BOGUS_OBJ = 0, + NO_OBJ = 1, + DIRECTORY_OBJ = 2, + GROUP_OBJ = 3, + TABLE_OBJ = 4, + ENTRY_OBJ = 5, + LINK_OBJ = 6, + PRIVATE_OBJ = 7, + NIS_BOGUS_OBJ = 0, + NIS_NO_OBJ = 1, + NIS_DIRECTORY_OBJ = 2, + NIS_GROUP_OBJ = 3, + NIS_TABLE_OBJ = 4, + NIS_ENTRY_OBJ = 5, + NIS_LINK_OBJ = 6, + NIS_PRIVATE_OBJ = 7 +}; +typedef enum zotypes zotypes; + +enum nstype { + UNKNOWN = 0, + NIS = 1, + SUNYP = 2, + IVY = 3, + DNS = 4, + X500 = 5, + DNANS = 6, + XCHS = 7, + CDS = 8, +}; +typedef enum nstype nstype; + +struct oar_mask { + uint32_t oa_rights; + zotypes oa_otype; +}; +typedef struct oar_mask oar_mask; + +struct endpoint { + char *uaddr; + char *family; + char *proto; +}; +typedef struct endpoint endpoint; + +struct nis_server { + nis_name name; + struct { + u_int ep_len; + endpoint *ep_val; + } ep; + uint32_t key_type; + netobj pkey; +}; +typedef struct nis_server nis_server; + +struct directory_obj { + nis_name do_name; + nstype do_type; + struct { + u_int do_servers_len; + nis_server *do_servers_val; + } do_servers; + uint32_t do_ttl; + struct { + u_int do_armask_len; + oar_mask *do_armask_val; + } do_armask; +}; +typedef struct directory_obj directory_obj; + +#define EN_BINARY 1 +#define EN_CRYPT 2 +#define EN_XDR 4 +#define EN_MODIFIED 8 +#define EN_ASN1 64 + +struct entry_col { + uint32_t ec_flags; + struct { + u_int ec_value_len; + char *ec_value_val; + } ec_value; +}; +typedef struct entry_col entry_col; + +struct entry_obj { + char *en_type; + struct { + u_int en_cols_len; + entry_col *en_cols_val; + } en_cols; +}; +typedef struct entry_obj entry_obj; + +struct group_obj { + uint32_t gr_flags; + struct { + u_int gr_members_len; + nis_name *gr_members_val; + } gr_members; +}; +typedef struct group_obj group_obj; + +struct link_obj { + zotypes li_rtype; + struct { + u_int li_attrs_len; + nis_attr *li_attrs_val; + } li_attrs; + nis_name li_name; +}; +typedef struct link_obj link_obj; + +#define TA_BINARY 1 +#define TA_CRYPT 2 +#define TA_XDR 4 +#define TA_SEARCHABLE 8 +#define TA_CASE 16 +#define TA_MODIFIED 32 +#define TA_ASN1 64 + +struct table_col { + char *tc_name; + uint32_t tc_flags; + uint32_t tc_rights; +}; +typedef struct table_col table_col; + +struct table_obj { + char *ta_type; + int ta_maxcol; + u_char ta_sep; + struct { + u_int ta_cols_len; + table_col *ta_cols_val; + } ta_cols; + char *ta_path; +}; +typedef struct table_obj table_obj; + +struct objdata { + zotypes zo_type; + union { + struct directory_obj di_data; + struct group_obj gr_data; + struct table_obj ta_data; + struct entry_obj en_data; + struct link_obj li_data; + struct { + u_int po_data_len; + char *po_data_val; + } po_data; + } objdata_u; +}; +typedef struct objdata objdata; + +struct nis_oid { + uint32_t ctime; + uint32_t mtime; +}; +typedef struct nis_oid nis_oid; + +struct nis_object { + nis_oid zo_oid; + nis_name zo_name; + nis_name zo_owner; + nis_name zo_group; + nis_name zo_domain; + uint32_t zo_access; + uint32_t zo_ttl; + objdata zo_data; +}; +typedef struct nis_object nis_object; + +#endif /* if __nis_object_h */ + +enum nis_error { + NIS_SUCCESS = 0, + NIS_S_SUCCESS = 1, + NIS_NOTFOUND = 2, + NIS_S_NOTFOUND = 3, + NIS_CACHEEXPIRED = 4, + NIS_NAMEUNREACHABLE = 5, + NIS_UNKNOWNOBJ = 6, + NIS_TRYAGAIN = 7, + NIS_SYSTEMERROR = 8, + NIS_CHAINBROKEN = 9, + NIS_PERMISSION = 10, + NIS_NOTOWNER = 11, + NIS_NOT_ME = 12, + NIS_NOMEMORY = 13, + NIS_NAMEEXISTS = 14, + NIS_NOTMASTER = 15, + NIS_INVALIDOBJ = 16, + NIS_BADNAME = 17, + NIS_NOCALLBACK = 18, + NIS_CBRESULTS = 19, + NIS_NOSUCHNAME = 20, + NIS_NOTUNIQUE = 21, + NIS_IBMODERROR = 22, + NIS_NOSUCHTABLE = 23, + NIS_TYPEMISMATCH = 24, + NIS_LINKNAMEERROR = 25, + NIS_PARTIAL = 26, + NIS_TOOMANYATTRS = 27, + NIS_RPCERROR = 28, + NIS_BADATTRIBUTE = 29, + NIS_NOTSEARCHABLE = 30, + NIS_CBERROR = 31, + NIS_FOREIGNNS = 32, + NIS_BADOBJECT = 33, + NIS_NOTSAMEOBJ = 34, + NIS_MODFAIL = 35, + NIS_BADREQUEST = 36, + NIS_NOTEMPTY = 37, + NIS_COLDSTART_ERR = 38, + NIS_RESYNC = 39, + NIS_FAIL = 40, + NIS_UNAVAIL = 41, + NIS_RES2BIG = 42, + NIS_SRVAUTH = 43, + NIS_CLNTAUTH = 44, + NIS_NOFILESPACE = 45, + NIS_NOPROC = 46, + NIS_DUMPLATER = 47, +}; +typedef enum nis_error nis_error; + +struct nis_result { + nis_error status; + struct { + u_int objects_len; + nis_object *objects_val; + } objects; + netobj cookie; + uint32_t zticks; + uint32_t dticks; + uint32_t aticks; + uint32_t cticks; +}; +typedef struct nis_result nis_result; + +struct ns_request { + nis_name ns_name; + struct { + u_int ns_object_len; + nis_object *ns_object_val; + } ns_object; +}; +typedef struct ns_request ns_request; + +struct ib_request { + nis_name ibr_name; + struct { + u_int ibr_srch_len; + nis_attr *ibr_srch_val; + } ibr_srch; + uint32_t ibr_flags; + struct { + u_int ibr_obj_len; + nis_object *ibr_obj_val; + } ibr_obj; + struct { + u_int ibr_cbhost_len; + nis_server *ibr_cbhost_val; + } ibr_cbhost; + u_int ibr_bufsize; + netobj ibr_cookie; +}; +typedef struct ib_request ib_request; + +struct ping_args { + nis_name dir; + uint32_t stamp; +}; +typedef struct ping_args ping_args; + +enum log_entry_t { + LOG_NOP = 0, + ADD_NAME = 1, + REM_NAME = 2, + MOD_NAME_OLD = 3, + MOD_NAME_NEW = 4, + ADD_IBASE = 5, + REM_IBASE = 6, + MOD_IBASE = 7, + UPD_STAMP = 8, +}; +typedef enum log_entry_t log_entry_t; + +struct log_entry { + uint32_t le_time; + log_entry_t le_type; + nis_name le_princp; + nis_name le_name; + struct { + u_int le_attrs_len; + nis_attr *le_attrs_val; + } le_attrs; + nis_object le_object; +}; +typedef struct log_entry log_entry; + +struct log_result { + nis_error lr_status; + netobj lr_cookie; + struct { + u_int lr_entries_len; + log_entry *lr_entries_val; + } lr_entries; +}; +typedef struct log_result log_result; + +struct cp_result { + nis_error cp_status; + uint32_t cp_zticks; + uint32_t cp_dticks; +}; +typedef struct cp_result cp_result; + +struct nis_tag { + uint32_t tag_type; + char *tag_val; +}; +typedef struct nis_tag nis_tag; + +struct nis_taglist { + struct { + u_int tags_len; + nis_tag *tags_val; + } tags; +}; +typedef struct nis_taglist nis_taglist; + +struct dump_args { + nis_name da_dir; + uint32_t da_time; + struct { + u_int da_cbhost_len; + nis_server *da_cbhost_val; + } da_cbhost; +}; +typedef struct dump_args dump_args; + +struct fd_args { + nis_name dir_name; + nis_name requester; +}; +typedef struct fd_args fd_args; + +struct fd_result { + nis_error status; + nis_name source; + struct { + u_int dir_data_len; + char *dir_data_val; + } dir_data; + struct { + u_int signature_len; + char *signature_val; + } signature; +}; +typedef struct fd_result fd_result; + +/* Generic client creating flags */ +#define ZMH_VC 1 +#define ZMH_DG 2 +#define ZMH_AUTH 4 + +/* Testing Access rights for objects */ + +#define NIS_READ_ACC 1 +#define NIS_MODIFY_ACC 2 +#define NIS_CREATE_ACC 4 +#define NIS_DESTROY_ACC 8 +/* Test macros. a == access rights, m == desired rights. */ +#define NIS_WORLD(a, m) (((a) & (m)) != 0) +#define NIS_GROUP(a, m) (((a) & ((m) << 8)) != 0) +#define NIS_OWNER(a, m) (((a) & ((m) << 16)) != 0) +#define NIS_NOBODY(a, m) (((a) & ((m) << 24)) != 0) +/* + * EOL Alert - The following non-prefixed test macros are + * here for backward compatability, and will be not be present + * in future releases - use the NIS_*() macros above. + */ +#define WORLD(a, m) (((a) & (m)) != 0) +#define GROUP(a, m) (((a) & ((m) << 8)) != 0) +#define OWNER(a, m) (((a) & ((m) << 16)) != 0) +#define NOBODY(a, m) (((a) & ((m) << 24)) != 0) + +#define OATYPE(d, n) (((d)->do_armask.do_armask_val+n)->oa_otype) +#define OARIGHTS(d, n) (((d)->do_armask.do_armask_val+n)->oa_rights) +#define WORLD_DEFAULT (NIS_READ_ACC) +#define GROUP_DEFAULT (NIS_READ_ACC << 8) +#define OWNER_DEFAULT ((NIS_READ_ACC + NIS_MODIFY_ACC + NIS_CREATE_ACC +\ + NIS_DESTROY_ACC) << 16) +#define DEFAULT_RIGHTS (WORLD_DEFAULT | GROUP_DEFAULT | OWNER_DEFAULT) + +/* Result manipulation defines ... */ +#define NIS_RES_NUMOBJ(x) ((x)->objects.objects_len) +#define NIS_RES_OBJECT(x) ((x)->objects.objects_val) +#define NIS_RES_COOKIE(x) ((x)->cookie) +#define NIS_RES_STATUS(x) ((x)->status) + +/* These defines make getting at the variant part of the object easier. */ +#define TA_data zo_data.objdata_u.ta_data +#define EN_data zo_data.objdata_u.en_data +#define DI_data zo_data.objdata_u.di_data +#define LI_data zo_data.objdata_u.li_data +#define GR_data zo_data.objdata_u.gr_data + +#define __type_of(o) ((o)->zo_data.zo_type) + +/* Declarations for the internal subroutines in nislib.c */ +enum name_pos {SAME_NAME, HIGHER_NAME, LOWER_NAME, NOT_SEQUENTIAL, BAD_NAME}; +typedef enum name_pos name_pos; + +/* + * Defines for getting at column data in entry objects. Because RPCGEN + * generates some rather wordy structures, we create some defines that + * collapse the needed keystrokes to access a particular value using + * these definitions they take an nis_object *, and an int and return + * a u_char * for Value, and an int for length. + */ +#define ENTRY_VAL(obj, col) (obj)->EN_data.en_cols.en_cols_val[col].ec_value.ec_value_val +#define ENTRY_LEN(obj, col) (obj)->EN_data.en_cols.en_cols_val[col].ec_value.ec_value_len + + +/* Prototypes, and extern declarations for the NIS library functions. */ +#include +#endif + +/* + * nis_3.h + * + * This file contains definitions that are only of interest to the actual + * service daemon and client stubs. Normal users of NIS will not include + * this file. + * + * NOTE : This include file is automatically created by a combination + * of rpcgen and sed. DO NOT EDIT IT, change the nis.x file instead + * and then remake this file. + */ +#ifndef __nis_3_h +#define __nis_3_h + +#define NIS_PROG 100300 +#define NIS_VERSION 3 + +#define NIS_LOOKUP 1 +extern nis_result * nis_lookup_3 (ns_request *, CLIENT *) __THROW; +extern nis_result * nis_lookup_3_svc (ns_request *, struct svc_req *) __THROW; +#define NIS_ADD 2 +extern nis_result * nis_add_3 (ns_request *, CLIENT *) __THROW; +extern nis_result * nis_add_3_svc (ns_request *, struct svc_req *) __THROW; +#define NIS_MODIFY 3 +extern nis_result * nis_modify_3 (ns_request *, CLIENT *) __THROW; +extern nis_result * nis_modify_3_svc (ns_request *, struct svc_req *) __THROW; +#define NIS_REMOVE 4 +extern nis_result * nis_remove_3 (ns_request *, CLIENT *) __THROW; +extern nis_result * nis_remove_3_svc (ns_request *, struct svc_req *) __THROW; +#define NIS_IBLIST 5 +extern nis_result * nis_iblist_3 (ib_request *, CLIENT *) __THROW; +extern nis_result * nis_iblist_3_svc (ib_request *, struct svc_req *) __THROW; +#define NIS_IBADD 6 +extern nis_result * nis_ibadd_3 (ib_request *, CLIENT *) __THROW; +extern nis_result * nis_ibadd_3_svc (ib_request *, struct svc_req *) __THROW; +#define NIS_IBMODIFY 7 +extern nis_result * nis_ibmodify_3 (ib_request *, CLIENT *) __THROW; +extern nis_result * nis_ibmodify_3_svc (ib_request *, struct svc_req *) + __THROW; +#define NIS_IBREMOVE 8 +extern nis_result * nis_ibremove_3 (ib_request *, CLIENT *) __THROW; +extern nis_result * nis_ibremove_3_svc (ib_request *, struct svc_req *) + __THROW; +#define NIS_IBFIRST 9 +extern nis_result * nis_ibfirst_3 (ib_request *, CLIENT *) __THROW; +extern nis_result * nis_ibfirst_3_svc (ib_request *, struct svc_req *) + __THROW; +#define NIS_IBNEXT 10 +extern nis_result * nis_ibnext_3 (ib_request *, CLIENT *) __THROW; +extern nis_result * nis_ibnext_3_svc (ib_request *, struct svc_req *) __THROW; +#define NIS_FINDDIRECTORY 12 +extern fd_result * nis_finddirectory_3 (fd_args *, CLIENT *) __THROW; +extern fd_result * nis_finddirectory_3_svc (fd_args *, + struct svc_req *) __THROW; +#define NIS_STATUS 14 +extern nis_taglist * nis_status_3 (nis_taglist *, CLIENT *) __THROW; +extern nis_taglist * nis_status_3_svc (nis_taglist *, struct svc_req *) + __THROW; +#define NIS_DUMPLOG 15 +extern log_result * nis_dumplog_3 (dump_args *, CLIENT *) __THROW; +extern log_result * nis_dumplog_3_svc (dump_args *, struct svc_req *) __THROW; +#define NIS_DUMP 16 +extern log_result * nis_dump_3 (dump_args *, CLIENT *) __THROW; +extern log_result * nis_dump_3_svc (dump_args *, struct svc_req *) __THROW; +#define NIS_CALLBACK 17 +extern bool_t * nis_callback_3 (netobj *, CLIENT *) __THROW; +extern bool_t * nis_callback_3_svc (netobj *, struct svc_req *) __THROW; +#define NIS_CPTIME 18 +extern uint32_t * nis_cptime_3 (nis_name *, CLIENT *) __THROW; +extern uint32_t * nis_cptime_3_svc (nis_name *, struct svc_req *) __THROW; +#define NIS_CHECKPOINT 19 +extern cp_result * nis_checkpoint_3 (nis_name *, CLIENT *) __THROW; +extern cp_result * nis_checkpoint_3_svc (nis_name *, struct svc_req *) + __THROW; +#define NIS_PING 20 +extern void * nis_ping_3 (ping_args *, CLIENT *) __THROW; +extern void * nis_ping_3_svc (ping_args *, struct svc_req *) __THROW; +#define NIS_SERVSTATE 21 +extern nis_taglist * nis_servstate_3 (nis_taglist *, CLIENT *) __THROW; +extern nis_taglist * nis_servstate_3_svc (nis_taglist *, + struct svc_req *) __THROW; +#define NIS_MKDIR 22 +extern nis_error * nis_mkdir_3 (nis_name *, CLIENT *) __THROW; +extern nis_error * nis_mkdir_3_svc (nis_name *, struct svc_req *) __THROW; +#define NIS_RMDIR 23 +extern nis_error * nis_rmdir_3 (nis_name *, CLIENT *) __THROW; +extern nis_error * nis_rmdir_3_svc (nis_name *, struct svc_req *) __THROW; +#define NIS_UPDKEYS 24 +extern nis_error * nis_updkeys_3 (nis_name *, CLIENT *) __THROW; +extern nis_error * nis_updkeys_3_svc (nis_name *, struct svc_req *) __THROW; + +__END_DECLS + +#endif /* ! _RPCSVC_NIS_H */ diff --git a/meta/recipes-extended/libtirpc/libtirpc-0.2.3/nis_tags.h b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/nis_tags.h new file mode 100644 index 0000000000..c2dc7fd269 --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/nis_tags.h @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2010, Oracle America, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials + * provided with the distribution. + * * Neither the name of the "Oracle America, Inc." nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * nis_tags.h + * + * This file contains the tags and statistics definitions. It is + * automatically included by nis.h + */ + +#ifndef _RPCSVC_NIS_TAGS_H +#define _RPCSVC_NIS_TAGS_H + +#if 0 +#pragma ident "@(#)nis_tags.h 1.16 96/10/25" +#endif +/* from file: zns_tags.h 1.7 */ + +#ifdef __cplusplus +extern "C" { +#endif + + +#define NIS_DIR "data" + +/* Lookup and List function flags */ +#define FOLLOW_LINKS (1<<0) /* Follow link objects */ +#define FOLLOW_PATH (1<<1) /* Follow the path in a table */ +#define HARD_LOOKUP (1<<2) /* Block until successful */ +#define ALL_RESULTS (1<<3) /* Retrieve all results */ +#define NO_CACHE (1<<4) /* Do not return 'cached' results */ +#define MASTER_ONLY (1<<5) /* Get value only from master server */ +#define EXPAND_NAME (1<<6) /* Expand partitially qualified names */ + +/* Semantic modification for table operations flags */ +#define RETURN_RESULT (1<<7) /* Return resulting object to client */ +#define ADD_OVERWRITE (1<<8) /* Allow overwrites on ADD */ +#define REM_MULTIPLE (1<<9) /* Allow wildcard deletes */ +#define MOD_SAMEOBJ (1<<10) /* Check modified object before write */ +#define ADD_RESERVED (1<<11) /* Spare ADD semantic */ +#define REM_RESERVED (1<<12) /* Spare REM semantic */ +#define MOD_EXCLUSIVE (1<<13) /* Modify no overwrite on modified keys */ + +/* Lookup and List function flags (continued) */ +#define SOFT_LOOKUP (1<<14) /* The "old default" return on failure */ + +/* Transport specific modifications to the operation */ +#define USE_DGRAM (1<<16) /* Use a datagram transport */ +#define NO_AUTHINFO (1<<17) /* Don't bother attaching auth info */ + +/* + * Declarations for "standard" NIS+ tags + * State variable tags have values 0 - 2047 + * Statistic tags have values 2048 - 65535 + * User Tags have values >2^16 + */ +#define TAG_DEBUG 1 /* set debug level */ +#define TAG_STATS 2 /* Enable/disable statistics */ +#define TAG_GCACHE 3 /* Flush the Group Cache */ +#define TAG_GCACHE_ALL TAG_GCACHE +#define TAG_DCACHE 4 /* Flush the directory cache */ +#define TAG_DCACHE_ONE TAG_DCACHE +#define TAG_OCACHE 5 /* Flush the Object Cache */ +#define TAG_SECURE 6 /* Set the security level */ +#define TAG_TCACHE_ONE 7 /* Flush the table cache */ +#define TAG_DCACHE_ALL 8 /* Flush entire directory cache */ +#define TAG_TCACHE_ALL 9 /* Flush entire table cache */ +#define TAG_GCACHE_ONE 10 /* Flush one group object */ +#define TAG_DCACHE_ONE_REFRESH 11 /* Flush and refresh one DO */ +#define TAG_READONLY 12 /* Set read only mode */ +#define TAG_READWRITE 14 /* Reset read-write mode */ + +#define TAG_OPSTATS 2048 /* NIS+ operations statistics */ +#define TAG_THREADS 2049 /* Child process/thread status */ +#define TAG_HEAP 2050 /* Heap usage statistics */ +#define TAG_UPDATES 2051 /* Updates to this service */ +#define TAG_VISIBLE 2052 /* First update that isn't replicated */ +#define TAG_S_DCACHE 2053 /* Directory cache statistics */ +#define TAG_S_OCACHE 2054 /* Object cache statistics */ +#define TAG_S_GCACHE 2055 /* Group cache statistics */ +#define TAG_S_STORAGE 2056 /* Group cache statistics */ +#define TAG_UPTIME 2057 /* Time that server has been up */ +#define TAG_DIRLIST 2058 /* Dir served by this server */ +#define TAG_NISCOMPAT 2059 /* Whether supports NIS compat mode */ +#define TAG_DNSFORWARDING 2060 /* Whether DNS forwarding supported */ +#define TAG_SECURITY_LEVEL 2061 /* Security level of the server */ +#define TAG_ROOTSERVER 2062 /* Whether root server */ + +/* + * Declarations for the Group object flags. Currently + * there are only 3. + */ +#define IMPMEM_GROUPS 1 /* Implicit Membership allowed */ +#define RECURS_GROUPS 2 /* Recursive Groups allowed */ +#define NEGMEM_GROUPS 4 /* Negative Groups allowed */ + +#ifdef __cplusplus +} +#endif + +#endif /* _RPCSVC_NIS_TAGS_H */ diff --git a/meta/recipes-extended/libtirpc/libtirpc-0.2.3/nislib.h b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/nislib.h new file mode 100644 index 0000000000..f3cc2c4c51 --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/nislib.h @@ -0,0 +1,288 @@ +/* Copyright (C) 1997, 1998, 1999, 2006, 2007, 2009 + Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Thorsten Kukuk , 1997. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#ifndef __RPCSVC_NISLIB_H__ +#define __RPCSVC_NISLIB_H__ + +#include + +__BEGIN_DECLS + +typedef const char *const_nis_name; + +/* nis_names: These functions are used to locate and manipulate all NIS+ + * objects except the NIS+ entry objects. + * + * nis_lookup (name, flags) resolves a NIS+ name and returns a copy of + * that object from a NIS+ server. + * const nis_name name: name of the object to be resolved + * unsigned int flags: logically ORing zero or more flags (FOLLOW_LINKS, + * HARD_LOOKUP, [NO_CACHE], MASTER_ONLY, EXPAND_NAME) + * + * nis_add (name, obj) adds objects to the NIS+ namespace. + * const nis_name name: fully qualified NIS+ name. + * const nis_object *obj: object members zo_name and zo_domain will be + * constructed from name. + * + * nis_remove (name, obj) removes objects from the NIS+ namespace. + * const nis_name name: fully qualified NIS+ name. + * const nis_object *obj: if not NULL, it is assumed to point to a copy + * of the object being removed. In this case, if + * the object on the server does not have the same + * object identifier as the object being passed, + * the operation will fail with the NIS_NOTSAMEOBJ + * error. + * + * nis_modify (name, obj) can change specific attributes of an object + * that already exists in the namespace. + */ +extern nis_result *nis_lookup (const_nis_name name, unsigned int flags) + __THROW; +extern nis_result *nis_add (const_nis_name name, const nis_object *obj) + __THROW; +extern nis_result *nis_remove (const_nis_name name, + const nis_object *obj) __THROW; +extern nis_result *nis_modify (const_nis_name name, + const nis_object *obj) __THROW; + +/* nis_tables: These functions are used to search and modify NIS+ tables. + * + * nis_list (table_name, flags, callback(table_name, obj, userdata), userdata) + * search a table in the NIS+ namespace. + * const nis_name table_name: indexed name ([xx=yy],table.dir) + * unsigned int flags: logically ORing one or more flags (FOLLOW_LINKS, + * [FOLLOW_PATH], HARD_LOOKUP, [ALL_RESULTS], [NO_CACHE], + * MASTER_ONLY, EXPAND_NAME, RETURN_RESULT) + * callback(): callback is an optional pointer to a function that will + * process the ENTRY type objects that are returned from the + * search. If this pointer is NULL, then all entries that match + * the search criteria are returned in the nis_result structure, + * otherwise this function will be called once for each + * entry returned. + * void *userdata: passed to callback function along with the returned + * entry object. + * + * nis_add_entry (table_name, obj, flags) will add the NIS+ object to the + * NIS+ table_name. + * const nis_name table_name + * const nis_object *obj + * unsigned int flags: 0, ADD_OVERWRITE, RETURN_RESULT + * + * nis_modify_entry (name, obj, flags) modifies an object identified by name. + * const nis_name name: object identifier + * const nis_object *obj: should point to an entry with the EN_MODIFIED + * flag set in each column that contains new + * information. + * unsigned int flags: 0, MOD_SAMEOBJ, RETURN_RESULT + * + * nis_remove_entry (table_name, obj, flags) removes a set of entries + * identified by table_name from the table. + * const nis_name table_name: indexed NIS+ name + * const nis_object *obj: if obj is non-null, it is presumed to point to + * a cached copy of the entry. When the removal is + * attempted, and the object that would be removed + * is not the same as the cached object pointed to + * by object then the operation will fail with an + * NIS_NOTSAMEOBJ error + * unsigned int flags: 0, REM_MULTIPLE + * + * nis_first_entry (table_name) fetches entries from a table one at a time. + * const nis_name table_name + * + * nis_next_entry (table_name, cookie) retrieves the "next" entry from a + * table specified by table_name. + * const nis_name table_name: + * const netobj *cookie: The value of cookie from the nis_result structure + * form the previous call. + */ +extern nis_result *nis_list (const_nis_name __name, unsigned int __flags, + int (*__callback)(const_nis_name __table_name, + const nis_object *__obj, + const void *__userdata), + const void *__userdata) __THROW; +extern nis_result *nis_add_entry (const_nis_name __table_name, + const nis_object *__obj, + unsigned int __flags) __THROW; +extern nis_result *nis_modify_entry (const_nis_name __name, + const nis_object *__obj, + unsigned int __flags) __THROW; +extern nis_result *nis_remove_entry (const_nis_name __table_name, + const nis_object *__obj, + unsigned int __flags) __THROW; +extern nis_result *nis_first_entry (const_nis_name __table_name) __THROW; +extern nis_result *nis_next_entry (const_nis_name __table_name, + const netobj *__cookie) __THROW; +/* +** nis_server +*/ +extern nis_error nis_mkdir (const_nis_name __dirname, + const nis_server *__machine) __THROW; +extern nis_error nis_rmdir (const_nis_name __dirname, + const nis_server *__machine) __THROW; +extern nis_error nis_servstate (const nis_server *__machine, + const nis_tag *__tags, int __numtags, + nis_tag **__result) __THROW; +extern nis_error nis_stats (const nis_server *__machine, + const nis_tag *__tags, int __numtags, + nis_tag **__result) __THROW; +extern void nis_freetags (nis_tag *__tags, int __numtags) __THROW; +extern nis_server **nis_getservlist (const_nis_name __dirname) __THROW; +extern void nis_freeservlist (nis_server **__machines) __THROW; + +/* +** nis_subr +*/ +extern nis_name nis_leaf_of (const_nis_name __name) __THROW; +extern nis_name nis_leaf_of_r (const_nis_name __name, char *__buffer, + size_t __buflen) __THROW; +extern nis_name nis_name_of (const_nis_name __name) __THROW; +extern nis_name nis_name_of_r (const_nis_name __name, char *__buffer, + size_t __buflen) __THROW; +extern nis_name nis_domain_of (const_nis_name __name) __THROW; +extern nis_name nis_domain_of_r (const_nis_name __name, char *__buffer, + size_t __buflen) __THROW; +extern nis_name *nis_getnames (const_nis_name __name) __THROW; +extern void nis_freenames (nis_name *__namelist) __THROW; +extern name_pos nis_dir_cmp (const_nis_name __n1, const_nis_name __n2) __THROW; +extern nis_object *nis_clone_object (const nis_object *__src, + nis_object *__dest) __THROW; +extern void nis_destroy_object (nis_object *__obj) __THROW; +extern void nis_print_object (const nis_object *__obj) __THROW; + +/* +** nis_local_names +*/ +extern nis_name nis_local_group (void) __THROW; +extern nis_name nis_local_directory (void) __THROW; +extern nis_name nis_local_principal (void) __THROW; +extern nis_name nis_local_host (void) __THROW; + +/* +** nis_error +*/ +extern const char *nis_sperrno (const nis_error __status) __THROW; +extern void nis_perror (const nis_error __status, const char *__label) __THROW; +extern void nis_lerror (const nis_error __status, const char *__label) __THROW; +extern char *nis_sperror (const nis_error status, const char *__label) __THROW; +extern char *nis_sperror_r (const nis_error __status, const char *__label, + char *__buffer, size_t __buflen) __THROW; +/* +** nis_groups +*/ +extern bool_t nis_ismember (const_nis_name __principal, + const_nis_name __group) __THROW; +extern nis_error nis_addmember (const_nis_name __member, + const_nis_name __group) __THROW; +extern nis_error nis_removemember (const_nis_name __member, + const_nis_name __group) __THROW; +extern nis_error nis_creategroup (const_nis_name __group, + unsigned int __flags) __THROW; +extern nis_error nis_destroygroup (const_nis_name __group) __THROW; +extern void nis_print_group_entry (const_nis_name __group) __THROW; +extern nis_error nis_verifygroup (const_nis_name __group) __THROW; + +/* +** nis_ping +*/ +extern void nis_ping (const_nis_name __dirname, uint32_t __utime, + const nis_object *__dirobj) __THROW; +extern nis_result *nis_checkpoint (const_nis_name __dirname) __THROW; + +/* +** nis_print (XXX INTERNAL FUNCTIONS, SHOULD NOT BE USED !!) +*/ +extern void nis_print_result (const nis_result *__result) __THROW; +extern void nis_print_rights (unsigned int __rights) __THROW; +extern void nis_print_directory (const directory_obj *__dirobj) __THROW; +extern void nis_print_group (const group_obj *__grpobj) __THROW; +extern void nis_print_table (const table_obj *__tblobj) __THROW; +extern void nis_print_link (const link_obj *__lnkobj) __THROW; +extern void nis_print_entry (const entry_obj *__enobj) __THROW; + +/* +** nis_file (XXX INTERNAL FUNCTIONS, SHOULD NOT BE USED !!) +*/ +extern directory_obj *readColdStartFile (void) __THROW; +extern bool_t writeColdStartFile (const directory_obj *__dirobj) __THROW; +extern nis_object *nis_read_obj (const char *__obj) __THROW; +extern bool_t nis_write_obj (const char *__file, const nis_object *__obj) __THROW; + +/* +** nis_clone - (XXX INTERNAL FUNCTIONS, SHOULD NOT BE USED !!) +*/ +extern directory_obj *nis_clone_directory (const directory_obj *__src, + directory_obj *__dest) __THROW; +extern nis_result *nis_clone_result (const nis_result *__src, + nis_result *__dest) __THROW; + +/* nis_free - nis_freeresult */ +extern void nis_freeresult (nis_result *__result) __THROW; +/* (XXX THE FOLLOWING ARE INTERNAL FUNCTIONS, SHOULD NOT BE USED !!) */ +extern void nis_free_request (ib_request *__req) __THROW; +extern void nis_free_directory (directory_obj *__dirobj) __THROW; +extern void nis_free_object (nis_object *__obj) __THROW; + +/* (XXX INTERNAL FUNCTIONS, SHOULD NOT BE USED !!) */ +extern nis_name __nis_default_owner (char *) __THROW; +extern nis_name __nis_default_group (char *) __THROW; +extern uint32_t __nis_default_ttl (char *) __THROW; +extern unsigned int __nis_default_access (char *, unsigned int) __THROW; +extern fd_result *__nis_finddirectory (directory_obj *, const_nis_name) __THROW; +extern void __free_fdresult (fd_result *) __THROW; +extern uint32_t __nis_hash (const void *__keyarg, size_t __len) __THROW; + +/* NIS+ cache locking */ +extern int __nis_lock_cache (void) __THROW; +extern int __nis_unlock_cache (void) __THROW; + +/* (XXX INTERNAL FUNCTIONS, ONLY FOR rpc.nisd AND glibc !!) */ +#if defined (NIS_INTERNAL) || defined (_LIBC) + +struct dir_binding +{ + CLIENT *clnt; /* RPC CLIENT handle */ + nis_server *server_val; /* List of servers */ + unsigned int server_len; /* # of servers */ + unsigned int server_used; /* Which server we are bind in the moment ? */ + unsigned int current_ep; /* Which endpoint of the server are in use? */ + unsigned int trys; /* How many server have we tried ? */ + unsigned int class; /* From which class is server_val ? */ + bool_t master_only; /* Is only binded to the master */ + bool_t use_auth; /* Do we use AUTH ? */ + bool_t use_udp; /* Do we use UDP ? */ + struct sockaddr_in addr; /* Server's IP address */ + int socket; /* Server's local socket */ +}; +typedef struct dir_binding dir_binding; + +extern nis_error __nisbind_create (dir_binding *, const nis_server *, + unsigned int, unsigned int, unsigned int, + unsigned int) __THROW; +extern nis_error __nisbind_connect (dir_binding *) __THROW; +extern nis_error __nisbind_next (dir_binding *) __THROW; +extern void __nisbind_destroy (dir_binding *) __THROW; +extern nis_error __nisfind_server (const_nis_name, int, directory_obj **, + dir_binding *, unsigned int) __THROW; + +#endif + +__END_DECLS + +#endif /* __RPCSVC_NISLIB_H__ */ diff --git a/meta/recipes-extended/libtirpc/libtirpc-0.2.3/rpc_des.h b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/rpc_des.h new file mode 100644 index 0000000000..4b3c426c62 --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/rpc_des.h @@ -0,0 +1,71 @@ +/* + * Generic DES driver interface + * Keep this file hardware independent! + * Copyright (c) 2010, Oracle America, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials + * provided with the distribution. + * * Neither the name of the "Oracle America, Inc." nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _DES_H +#define _DES_H + +#include + +#define DES_MAXLEN 65536 /* maximum # of bytes to encrypt */ +#define DES_QUICKLEN 16 /* maximum # of bytes to encrypt quickly */ + +enum desdir + { + ENCRYPT, DECRYPT + }; +enum desmode + { + CBC, ECB + }; + +/* + * parameters to ioctl call + */ +struct desparams + { + u_char des_key[8]; /* key (with low bit parity) */ + enum desdir des_dir; /* direction */ + enum desmode des_mode; /* mode */ + u_char des_ivec[8]; /* input vector */ + unsigned des_len; /* number of bytes to crypt */ + union + { + u_char UDES_data[DES_QUICKLEN]; + u_char *UDES_buf; + } + UDES; +#define des_data UDES.UDES_data /* direct data here if quick */ +#define des_buf UDES.UDES_buf /* otherwise, pointer to data */ + }; + +#endif diff --git a/meta/recipes-extended/libtirpc/libtirpc-0.2.3/yp_prot.h b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/yp_prot.h new file mode 100644 index 0000000000..ae0db3688e --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/yp_prot.h @@ -0,0 +1,366 @@ +/* + * This file contains symbols and structures defining the rpc protocol + * between the NIS clients and the NIS servers. The servers + * are the NIS database servers, and the NIS binders. + */ + +#ifndef _RPCSVC_YP_PROT_H +#define _RPCSVC_YP_PROT_H + +#include + +#include +#include + +__BEGIN_DECLS + +/* + * The following procedures are supported by the protocol: + * + * YPPROC_NULL() returns () takes nothing, returns nothing. This indicates + * that the NIS server is alive. + * + * YPPROC_DOMAIN (char *) returns (bool_t) TRUE. Indicates that the + * responding NIS server does serve the named domain; FALSE indicates no + * support. + * + * YPPROC_DOMAIN_NONACK (char *) returns (TRUE) if the NIS server does serve + * the named domain, otherwise does not return. Used in the broadcast case. + * + * YPPROC_MATCH (struct ypreq_key) returns (struct ypresp_val). Returns the + * right-hand value for a passed left-hand key, within a named map and + * domain. + * + * YPPROC_FIRST (struct ypreq_nokey) returns (struct ypresp_key_val). + * Returns the first key-value pair from a named domain and map. + * + * YPPROC_NEXT (struct ypreq_key) returns (struct ypresp_key_val). Returns + * the key-value pair following a passed key-value pair within a named + * domain and map. + * + * YPPROC_XFR (struct ypreq_xfr) returns nothing. Indicates to a server that + * a map should be updated. + * + * YPPROC_CLEAR takes nothing, returns nothing. Instructs a NIS server to + * close the current map, so that old versions of the disk file don't get + * held open. + * + * YPPROC_ALL (struct ypreq_nokey), returns + * union switch (bool_t more) { + * TRUE: (struct ypresp_key_val); + * FALSE: (struct) {}; + * } + * + * YPPROC_MASTER (struct ypreq_nokey), returns (ypresp_master) + * + * YPPROC_ORDER (struct ypreq_nokey), returns (ypresp_order) + * + * YPPROC_MAPLIST (char *), returns (struct ypmaplist *) + */ + +/* Program and version symbols, magic numbers */ + +#define YPPROG 100004 +#define YPVERS 2 +#define YPVERS_ORIG 1 +#define YPMAXRECORD 1024 +#define YPMAXDOMAIN 64 /* XXX orig. yp_prot.h defines 256 */ +#define YPMAXMAP 64 +#define YPMAXPEER 64 /* XXX orig. yp_prot.h defines 256 */ + +/* byte size of a large NIS packet */ +#define YPMSGSZ 1600 + +typedef struct { + u_int keydat_len; + char *keydat_val; +} keydat_t; + +typedef struct { + u_int valdat_len; + char *valdat_val; +} valdat_t; + +struct ypmap_parms { + char *domain; /* Null string means not available */ + char *map; /* Null string means not available */ + unsigned int ordernum; /* 0 means not available */ + char *owner; /* Null string means not available */ +}; + +/* + * Request parameter structures + */ + +struct ypreq_key { + const char *domain; + const char *map; + keydat_t keydat; +}; + +struct ypreq_nokey { + char *domain; + char *map; +}; + +struct ypreq_xfr { + struct ypmap_parms map_parms; + u_int transid; + u_int proto; + u_int port; +}; + +#define ypxfr_domain map_parms.domain +#define ypxfr_map map_parms.map +#define ypxfr_ordernum map_parms.ordernum +#define ypxfr_owner map_parms.owner + +/* Return status values */ + +enum ypstat { + YP_TRUE = 1, /* General purpose success code */ +#define YP_TRUE YP_TRUE + YP_NOMORE = 2, /* No more entries in map */ +#define YP_NOMORE YP_NOMORE + YP_FALSE = 0, /* General purpose failure code */ +#define YP_FALSE YP_FALSE + YP_NOMAP = -1, /* No such map in domain */ +#define YP_NOMAP YP_NOMAP + YP_NODOM = -2, /* Domain not supported */ +#define YP_NODOM YP_NODOM + YP_NOKEY = -3, /* No such key in map */ +#define YP_NOKEY YP_NOKEY + YP_BADOP = -4, /* Invalid operation */ +#define YP_BADOP YP_BADOP + YP_BADDB = -5, /* Server data base is bad */ +#define YP_BADDB YP_BADDB + YP_YPERR = -6, /* NIS server error */ +#define YP_YPERR YP_YPERR + YP_BADARGS = -7, /* Request arguments bad */ +#define YP_BADARGS YP_BADARGS + YP_VERS = -8, /* NIS server version mismatch - server can't supply + requested service. */ +#define YP_VERS YP_VERS +}; + +/* + * Response parameter structures + */ + +typedef enum ypstat ypstat; + +struct ypresp_val { + ypstat status; + valdat_t valdat; +}; + +struct ypresp_key_val { + ypstat status; +#ifdef STUPID_SUN_BUG + /* This is the form as distributed by Sun. But even the Sun NIS + servers expect the values in the other order. So their + implementation somehow must change the order internally. We + don't want to follow this bad example since the user should be + able to use rpcgen on this file. */ + keydat_t keydat; + valdat_t valdat; +#else + valdat_t valdat; + keydat_t keydat; +#endif +}; + +struct ypresp_master { + ypstat status; + char *master; +}; + +struct ypresp_order { + ypstat status; + u_int ordernum; +}; + +struct ypmaplist { + char *map; +#define ypml_name map + struct ypmaplist *next; +#define ypml_next next +}; + +struct ypresp_maplist { + ypstat status; + struct ypmaplist *list; +}; + +/* + * Procedure symbols. YPPROC_NULL, YPPROC_DOMAIN, and YPPROC_DOMAIN_NONACK + * must keep the same values (0, 1, and 2) that they had in the first version + * of the protocol. + */ + +#define YPPROC_NULL 0 +#define YPPROC_DOMAIN 1 +#define YPPROC_DOMAIN_NONACK 2 +#define YPPROC_MATCH 3 +#define YPPROC_FIRST 4 +#define YPPROC_NEXT 5 +#define YPPROC_XFR 6 +#define YPPROC_CLEAR 7 +#define YPPROC_ALL 8 +#define YPPROC_MASTER 9 +#define YPPROC_ORDER 10 +#define YPPROC_MAPLIST 11 +#define YPPROC_NEWXFR 12 + +/* + * Protocol between clients and NIS binder servers + */ + +/* + * The following procedures are supported by the protocol: + * + * YPBINDPROC_NULL() returns () + * takes nothing, returns nothing + * + * YPBINDPROC_DOMAIN takes (char *) returns (struct ypbind_resp) + * + * YPBINDPROC_SETDOM takes (struct ypbind_setdom) returns nothing + */ + +/* Program and version symbols, magic numbers */ + +#define YPBINDPROG 100007 +#define YPBINDVERS 2 +#define YPBINDVERS_ORIG 1 + +/* Procedure symbols */ + +#define YPBINDPROC_NULL 0 +#define YPBINDPROC_DOMAIN 1 +#define YPBINDPROC_SETDOM 2 +/* + * Response structure and overall result status codes. Success and failure + * represent two separate response message types. + */ + +enum ypbind_resptype {YPBIND_SUCC_VAL = 1, YPBIND_FAIL_VAL = 2}; + +struct ypbind_binding { + struct in_addr ypbind_binding_addr; /* In network order */ + unsigned short int ypbind_binding_port; /* In network order */ +}; + +struct ypbind_resp { + enum ypbind_resptype ypbind_status; + union { + u_int ypbind_error; + struct ypbind_binding ypbind_bindinfo; + } ypbind_respbody; +}; + + +/* Detailed failure reason codes for response field ypbind_error*/ + +#define YPBIND_ERR_ERR 1 /* Internal error */ +#define YPBIND_ERR_NOSERV 2 /* No bound server for passed domain */ +#define YPBIND_ERR_RESC 3 /* System resource allocation failure */ + +/* + * Request data structure for ypbind "Set domain" procedure. + */ +struct ypbind_setdom { + char *ypsetdom_domain; + struct ypbind_binding ypsetdom_binding; + u_int ypsetdom_vers; +}; +#define ypsetdom_addr ypsetdom_binding.ypbind_binding_addr +#define ypsetdom_port ypsetdom_binding.ypbind_binding_port + +/* + * Protocol between clients (ypxfr, only) and yppush + * yppush speaks a protocol in the transient range, which + * is supplied to ypxfr as a command-line parameter when it + * is activated by ypserv. + */ +#define YPPUSHVERS 1 +#define YPPUSHVERS_ORIG 1 + +/* Procedure symbols */ + +#define YPPUSHPROC_NULL 0 +#define YPPUSHPROC_XFRRESP 1 + +/* Status values for yppushresp_xfr.status */ + +enum yppush_status { + YPPUSH_SUCC = 1, /* Success */ +#define YPPUSH_SUCC YPPUSH_SUCC + YPPUSH_AGE = 2, /* Master's version not newer */ +#define YPPUSH_AGE YPPUSH_AGE + YPPUSH_NOMAP = -1, /* Can't find server for map */ +#define YPPUSH_NOMAP YPPUSH_NOMAP + YPPUSH_NODOM = -2, /* Domain not supported */ +#define YPPUSH_NODOM YPPUSH_NODOM + YPPUSH_RSRC = -3, /* Local resouce alloc failure */ +#define YPPUSH_RSRC YPPUSH_RSRC + YPPUSH_RPC = -4, /* RPC failure talking to server */ +#define YPPUSH_RPC YPPUSH_RPC + YPPUSH_MADDR = -5, /* Can't get master address */ +#define YPPUSH_MADDR YPPUSH_MADDR + YPPUSH_YPERR = -6, /* NIS server/map db error */ +#define YPPUSH_YPERR YPPUSH_YPERR + YPPUSH_BADARGS = -7, /* Request arguments bad */ +#define YPPUSH_BADARGS YPPUSH_BADARGS + YPPUSH_DBM = -8, /* Local dbm operation failed */ +#define YPPUSH_DBM YPPUSH_DBM + YPPUSH_FILE = -9, /* Local file I/O operation failed */ +#define YPPUSH_FILE YPPUSH_FILE + YPPUSH_SKEW = -10, /* Map version skew during transfer */ +#define YPPUSH_SKEW YPPUSH_SKEW + YPPUSH_CLEAR = -11, /* Can't send "Clear" req to local ypserv */ +#define YPPUSH_CLEAR YPPUSH_CLEAR + YPPUSH_FORCE = -12, /* No local order number in map - use -f flag*/ +#define YPPUSH_FORCE YPPUSH_FORCE + YPPUSH_XFRERR = -13, /* ypxfr error */ +#define YPPUSH_XFRERR YPPUSH_XFRERR + YPPUSH_REFUSED = -14, /* Transfer request refused by ypserv */ +#define YPPUSH_REFUSED YPPUSH_REFUSED + YPPUSH_NOALIAS = -15 /* Alias not found for map or domain */ +#define YPPUSH_NOALIAS YPPUSH_NOALIAS +}; +typedef enum yppush_status yppush_status; + +struct yppushresp_xfr { + u_int transid; + yppush_status status; +}; + +struct ypresp_all { + bool_t more; + union { + struct ypresp_key_val val; + } ypresp_all_u; +}; + +extern bool_t xdr_ypreq_key (XDR *__xdrs, struct ypreq_key * __objp); +extern bool_t xdr_ypreq_nokey (XDR *__xdrs, struct ypreq_nokey * __objp); +extern bool_t xdr_ypreq_xfr (XDR *__xdrs, struct ypreq_xfr * __objp); +extern bool_t xdr_ypresp_val (XDR *__xdrs, struct ypresp_val * __objp); +extern bool_t xdr_ypresp_key_val (XDR *__xdrs, struct ypresp_key_val * __objp); +extern bool_t xdr_ypbind_resp (XDR *__xdrs, struct ypbind_resp * __objp); +extern bool_t xdr_ypbind_setdom (XDR *__xdrs, struct ypbind_setdom * __objp); +extern bool_t xdr_ypmap_parms (XDR *__xdrs, struct ypmap_parms * __objp); +extern bool_t xdr_yppushresp_xfr (XDR *__xdrs, struct yppushresp_xfr * __objp); +extern bool_t xdr_ypresp_order (XDR *__xdrs, struct ypresp_order * __objp); +extern bool_t xdr_ypresp_master (XDR *__xdrs, struct ypresp_master * __objp); +extern bool_t xdr_ypall (XDR *__xdrs, struct ypall_callback * __objp); +extern bool_t xdr_ypresp_maplist (XDR *__xdrs, struct ypresp_maplist * __objp); +extern bool_t xdr_ypbind_binding (XDR *__xdrs, struct ypbind_binding * __objp); +extern bool_t xdr_ypbind_resptype (XDR *__xdrs, enum ypbind_resptype * __objp); +extern bool_t xdr_ypstat (XDR *__xdrs, enum ypbind_resptype * __objp); +extern bool_t xdr_ypresp_all (XDR *__xdrs, struct ypresp_all * __objp); +extern bool_t xdr_domainname (XDR *__xdrs, char ** __objp); + +__END_DECLS + +#endif /* _RPCSVC_YP_PROT_H */ diff --git a/meta/recipes-extended/libtirpc/libtirpc-0.2.3/ypclnt.h b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/ypclnt.h new file mode 100644 index 0000000000..aa37a29c9b --- /dev/null +++ b/meta/recipes-extended/libtirpc/libtirpc-0.2.3/ypclnt.h @@ -0,0 +1,89 @@ +/* Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Thorsten Kukuk , 1996. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + + +#ifndef __RPCSVC_YPCLNT_H__ +#define __RPCSVC_YPCLNT_H__ + +#include + +/* Some defines */ +#define YPERR_SUCCESS 0 /* There is no error */ +#define YPERR_BADARGS 1 /* Args to function are bad */ +#define YPERR_RPC 2 /* RPC failure */ +#define YPERR_DOMAIN 3 /* Can't bind to a server with this domain */ +#define YPERR_MAP 4 /* No such map in server's domain */ +#define YPERR_KEY 5 /* No such key in map */ +#define YPERR_YPERR 6 /* Internal yp server or client error */ +#define YPERR_RESRC 7 /* Local resource allocation failure */ +#define YPERR_NOMORE 8 /* No more records in map database */ +#define YPERR_PMAP 9 /* Can't communicate with portmapper */ +#define YPERR_YPBIND 10 /* Can't communicate with ypbind */ +#define YPERR_YPSERV 11 /* Can't communicate with ypserv */ +#define YPERR_NODOM 12 /* Local domain name not set */ +#define YPERR_BADDB 13 /* yp data base is bad */ +#define YPERR_VERS 14 /* YP version mismatch */ +#define YPERR_ACCESS 15 /* Access violation */ +#define YPERR_BUSY 16 /* Database is busy */ + +/* Types of update operations */ +#define YPOP_CHANGE 1 /* Change, do not add */ +#define YPOP_INSERT 2 /* Add, do not change */ +#define YPOP_DELETE 3 /* Delete this entry */ +#define YPOP_STORE 4 /* Add, or change */ + +__BEGIN_DECLS + +/* struct ypall_callback * is the arg which must be passed to yp_all. */ +struct ypall_callback + { + int (*foreach) (int __status, char *__key, int __keylen, + char *__val, int __vallen, char *__data); + char *data; + }; + +/* External NIS client function references. */ +extern int yp_bind (__const char *) __THROW; +extern void yp_unbind (__const char *) __THROW; +extern int yp_get_default_domain (char **) __THROW; +extern int yp_match (__const char *, __const char *, __const char *, + __const int, char **, int *) __THROW; +extern int yp_first (__const char *, __const char *, char **, + int *, char **, int *) __THROW; +extern int yp_next (__const char *, __const char *, __const char *, + __const int, char **, int *, char **, int *) __THROW; +extern int yp_master (__const char *, __const char *, char **) __THROW; +extern int yp_order (__const char *, __const char *, unsigned int *) __THROW; +extern int yp_all (__const char *, __const char *, + __const struct ypall_callback *) __THROW; +extern __const char *yperr_string (__const int) __THROW; +extern __const char *ypbinderr_string (__const int) __THROW; +extern int ypprot_err (__const int) __THROW; +extern int yp_update (char *, char *, unsigned int, char *, + int, char *, int) __THROW; +#if 0 +extern int yp_maplist (__const char *, struct ypmaplist **) __THROW; +#endif + +/* This functions exists only under BSD and Linux systems. */ +extern int __yp_check (char **) __THROW; + +__END_DECLS + +#endif /* __RPCSVC_YPCLNT_H__ */ diff --git a/meta/recipes-extended/libtirpc/libtirpc_0.2.3.bb b/meta/recipes-extended/libtirpc/libtirpc_0.2.3.bb index ed838b7545..dda9e054d1 100644 --- a/meta/recipes-extended/libtirpc/libtirpc_0.2.3.bb +++ b/meta/recipes-extended/libtirpc/libtirpc_0.2.3.bb @@ -12,23 +12,50 @@ DEPENDS += "xz-native" PROVIDES = "virtual/librpc" SRC_URI = "${SOURCEFORGE_MIRROR}/${BPN}/${BPN}-${PV}.tar.bz2;name=libtirpc \ - ${GENTOO_MIRROR}/${BPN}-glibc-nfs.tar.xz;name=glibc-nfs \ file://libtirpc-0.2.1-fortify.patch \ file://obsolete_automake_macros.patch \ + file://libtirpc-0.2.3-add-missing-bits-from-glibc.patch \ + file://libtirpc-0.2.3-types.h.patch \ + file://libtirpc-0008-Add-rpcgen-program-from-nfs-utils-sources.patch \ + file://key_prot.h \ + file://nis.h \ + file://nislib.h \ + file://nis_tags.h \ + file://rpc_des.h \ + file://ypclnt.h \ + file://yp_prot.h \ " SRC_URI_append_libc-uclibc = " file://remove-des-uclibc.patch" SRC_URI[libtirpc.md5sum] = "b70e6c12a369a91e69fcc3b9feb23d61" SRC_URI[libtirpc.sha256sum] = "4f29ea0491b4ca4c29f95f3c34191b857757873bbbf4b069f9dd4da01a6a923c" -SRC_URI[glibc-nfs.md5sum] = "5ae500b9d0b6b72cb875bc04944b9445" -SRC_URI[glibc-nfs.sha256sum] = "2677cfedf626f3f5a8f6e507aed5bb8f79a7453b589d684dbbc086e755170d83" + inherit autotools pkgconfig +CFLAGS += "-I${S}/glibc-headers" +EXTRA_OECONF = "--disable-gss" + do_configure_prepend () { - cp -r ${S}/../tirpc ${S} + install -d ${S}/glibc-headers/rpc/ + install -d ${S}/glibc-headers/rpcsvc/ + + install -m 0644 ${WORKDIR}/key_prot.h ${S}/glibc-headers/rpc + install -m 0644 ${WORKDIR}/rpc_des.h ${S}/glibc-headers/rpc + + install -m 0644 ${WORKDIR}/nis.h ${S}/glibc-headers/rpcsvc + install -m 0644 ${WORKDIR}/nislib.h ${S}/glibc-headers/rpcsvc + install -m 0644 ${WORKDIR}/nis_tags.h ${S}/glibc-headers/rpcsvc + install -m 0644 ${WORKDIR}/ypclnt.h ${S}/glibc-headers/rpcsvc + install -m 0644 ${WORKDIR}/yp_prot.h ${S}/glibc-headers/rpcsvc } do_install_append() { chown root:root ${D}${sysconfdir}/netconfig + + install -d ${D}/${includedir}/rpc/ + install -d ${D}/${includedir}/rpcsvc/ + + install -m 0644 ${S}/glibc-headers/rpc/*.h ${D}/${includedir}/rpc/ + install -m 0644 ${S}/glibc-headers/rpcsvc/*.h ${D}/${includedir}/rpcsvc/ } -- cgit 1.2.3-korg