tech-userlevel archive

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]

xdrproc_t prototype



Hi

I found a problem building NetBSD with pcc, in that the xdrproc_t typedef
in /usr/include/rpc/xdr.h does not provide a complete prototype, which
causes warnings with -Wmissing-prototypes (gcc accepts a partial, for some
reason)

FreeBSD some years ago changed this to a varargs prototype (about the best
option I think), like so

-typedef        bool_t (*xdrproc_t)(/* XDR *, void *, u_int */);
+typedef        bool_t (*xdrproc_t)(XDR *, ...);

and I would like to do that also. It causes no functional change but
requires a bunch of additional casts throughout the codebase (there are
some already, in similar positions), since the functions that are
generally used as xdrproc_t are not actual vararg functions (but they do
have a varying number of arguments), and browsing the FreeBSD cvsweb, they
seem to have made the a similar choice regarding the casts.  As to third
party code, I think that since FreeBSD did this nearly 10 years ago most
problem code has likely been flagged and fixed.

patch attached, any objections?

iain

Index: include/rpc/xdr.h
===================================================================
RCS file: /cvsroot/src/include/rpc/xdr.h,v
retrieving revision 1.26
diff -u -p -r1.26 xdr.h
--- include/rpc/xdr.h   4 Jul 2011 07:54:38 -0000       1.26
+++ include/rpc/xdr.h   24 Aug 2011 08:48:37 -0000
@@ -131,9 +131,9 @@ typedef struct __rpc_xdr {
  * to be decoded.  If this pointer is 0, then the type routines should
  * allocate dynamic storage of the appropriate size and return it.
  *
- * XXX can't actually prototype it, because some take three args!!!
+ * This is prototyped as vararg because some instances use a third argument!
  */
-typedef        bool_t (*xdrproc_t)(/* XDR *, void *, u_int */);
+typedef        bool_t (*xdrproc_t)(XDR *, ...);
 
 /*
  * Operations defined on a XDR handle
Index: lib/libpam/modules/pam_unix/pam_unix.c
===================================================================
RCS file: /cvsroot/src/lib/libpam/modules/pam_unix/pam_unix.c,v
retrieving revision 1.14
diff -u -p -r1.14 pam_unix.c
--- lib/libpam/modules/pam_unix/pam_unix.c      18 Nov 2009 17:06:23 -0000      
1.14
+++ lib/libpam/modules/pam_unix/pam_unix.c      24 Aug 2011 08:48:47 -0000
@@ -320,7 +320,7 @@ yp_set_password(pam_handle_t *pamh, stru
        tv.tv_sec = 2;
        tv.tv_usec = 0;
        r = clnt_call(client, YPPASSWDPROC_UPDATE,
-           xdr_yppasswd, &yppwd, xdr_int, &status, tv);
+           (xdrproc_t)xdr_yppasswd, &yppwd, (xdrproc_t)xdr_int, &status, tv);
        if (r)
                pam_error(pamh, "RPC to yppasswdd failed.");
        else if (status)
Index: lib/libquota/getnfsquota.c
===================================================================
RCS file: /cvsroot/src/lib/libquota/getnfsquota.c,v
retrieving revision 1.1
diff -u -p -r1.1 getnfsquota.c
--- lib/libquota/getnfsquota.c  24 Mar 2011 17:05:43 -0000      1.1
+++ lib/libquota/getnfsquota.c  24 Aug 2011 08:48:47 -0000
@@ -151,15 +151,15 @@ getnfsquota(const char *mp, struct ufs_q
        ext_gq_args.gqa_id = id;
        ext_gq_args.gqa_type = rpcqtype;
        ret = callaurpc(host, RQUOTAPROG, EXT_RQUOTAVERS,
-           RQUOTAPROC_GETQUOTA, xdr_ext_getquota_args, &ext_gq_args,
-           xdr_getquota_rslt, &gq_rslt);
+           RQUOTAPROC_GETQUOTA, (xdrproc_t)xdr_ext_getquota_args,
+           &ext_gq_args, (xdrproc_t)xdr_getquota_rslt, &gq_rslt);
        if (ret == RPC_PROGVERSMISMATCH && rpcqtype == RQUOTA_USRQUOTA) {
                /* try RQUOTAVERS */
                gq_args.gqa_pathp = path;
                gq_args.gqa_uid = id;
                ret = callaurpc(host, RQUOTAPROG, RQUOTAVERS,
-                   RQUOTAPROC_GETQUOTA, xdr_getquota_args, &gq_args,
-                   xdr_getquota_rslt, &gq_rslt);
+                   RQUOTAPROC_GETQUOTA, (xdrproc_t)xdr_getquota_args,
+                   &gq_args, (xdrproc_t)xdr_getquota_rslt, &gq_rslt);
        }
        free(host);
 
Index: lib/librpcsvc/rnusers.x
===================================================================
RCS file: /cvsroot/src/lib/librpcsvc/rnusers.x,v
retrieving revision 1.13
diff -u -p -r1.13 rnusers.x
--- lib/librpcsvc/rnusers.x     11 May 2006 17:11:57 -0000      1.13
+++ lib/librpcsvc/rnusers.x     24 Aug 2011 08:48:47 -0000
@@ -146,7 +146,7 @@
 %{
 %
 %      if (!xdr_reference(xdrs, (char **) objpp, (u_int)sizeof(struct ru_utmp),
-%                         xdr_utmp))
+%                         (xdrproc_t)xdr_utmp))
 %              return (FALSE);
 %      return (TRUE);
 %}
@@ -159,7 +159,7 @@
 %
 %      if (!xdr_array(xdrs, (char **)(void *)&objp->uta_arr,
 %                     (u_int *)&objp->uta_cnt, MAXUSERS,
-%                     (u_int)sizeof(struct utmp *), xdr_utmpptr))
+%                     (u_int)sizeof(struct utmp *), (xdrproc_t)xdr_utmpptr))
 %              return (FALSE);
 %      return (TRUE);
 %}
@@ -184,7 +184,8 @@
 %{
 %
 %      if (!xdr_reference(xdrs, (char **) objpp,
-%                         (u_int)sizeof(struct utmpidle), xdr_utmpidle))
+%                         (u_int)sizeof(struct utmpidle),
+%                         (xdrproc_t)xdr_utmpidle))
 %              return (FALSE);
 %      return (TRUE);
 %}
@@ -197,7 +198,8 @@
 %
 %      if (!xdr_array(xdrs, (char **)(void *)&objp->uia_arr,
 %                     (u_int *)&objp->uia_cnt, MAXUSERS,
-%                     (u_int)sizeof(struct utmpidle *), xdr_utmpidleptr))
+%                     (u_int)sizeof(struct utmpidle *),
+%                     (xdrproc_t)xdr_utmpidleptr))
 %              return (FALSE);
 %      return (TRUE);
 %}
Index: libexec/rpc.rquotad/rquotad.c
===================================================================
RCS file: /cvsroot/src/libexec/rpc.rquotad/rquotad.c,v
retrieving revision 1.27
diff -u -p -r1.27 rquotad.c
--- libexec/rpc.rquotad/rquotad.c       24 Mar 2011 17:05:43 -0000      1.27
+++ libexec/rpc.rquotad/rquotad.c       24 Aug 2011 08:48:47 -0000
@@ -127,7 +127,7 @@ rquota_service(struct svc_req *request, 
 {
        switch (request->rq_proc) {
        case NULLPROC:
-               (void)svc_sendreply(transp, xdr_void, (char *)NULL);
+               (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL);
                break;
 
        case RQUOTAPROC_GETQUOTA:
@@ -148,7 +148,7 @@ ext_rquota_service(struct svc_req *reque
 {
        switch (request->rq_proc) {
        case NULLPROC:
-               (void)svc_sendreply(transp, xdr_void, (char *)NULL);
+               (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL);
                break;
 
        case RQUOTAPROC_GETQUOTA:
@@ -179,7 +179,7 @@ sendquota(struct svc_req *request, int v
        memset((char *)&ext_getq_args, 0, sizeof(ext_getq_args));
        switch (vers) {
        case RQUOTAVERS:
-               if (!svc_getargs(transp, xdr_getquota_args,
+               if (!svc_getargs(transp, (xdrproc_t)xdr_getquota_args,
                    (caddr_t)&getq_args)) {
                        svcerr_decode(transp);
                        return;
@@ -189,7 +189,7 @@ sendquota(struct svc_req *request, int v
                ext_getq_args.gqa_type = RQUOTA_USRQUOTA;
                break;
        case EXT_RQUOTAVERS:
-               if (!svc_getargs(transp, xdr_ext_getquota_args,
+               if (!svc_getargs(transp, (xdrproc_t)xdr_ext_getquota_args,
                    (caddr_t)&ext_getq_args)) {
                        svcerr_decode(transp);
                        return;
@@ -237,9 +237,9 @@ sendquota(struct svc_req *request, int v
                    qe[QUOTA_LIMIT_FILE].ufsqe_time - timev.tv_sec;
        }
 out:
-       if (!svc_sendreply(transp, xdr_getquota_rslt, (char *)&getq_rslt))
+       if (!svc_sendreply(transp, (xdrproc_t)xdr_getquota_rslt, (char 
*)&getq_rslt))
                svcerr_systemerr(transp);
-       if (!svc_freeargs(transp, xdr_getquota_args, (caddr_t)&getq_args)) {
+       if (!svc_freeargs(transp, (xdrproc_t)xdr_getquota_args, 
(caddr_t)&getq_args)) {
                syslog(LOG_ERR, "unable to free arguments");
                exit(1);
        }
Index: libexec/rpc.rstatd/rstat_proc.c
===================================================================
RCS file: /cvsroot/src/libexec/rpc.rstatd/rstat_proc.c,v
retrieving revision 1.44
diff -u -p -r1.44 rstat_proc.c
--- libexec/rpc.rstatd/rstat_proc.c     16 Mar 2009 00:51:06 -0000      1.44
+++ libexec/rpc.rstatd/rstat_proc.c     24 Aug 2011 08:48:47 -0000
@@ -378,7 +378,7 @@ rstat_service(struct svc_req *rqstp, SVC
 
        switch (rqstp->rq_proc) {
        case NULLPROC:
-               (void)svc_sendreply(transp, xdr_void, (char *)NULL);
+               (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL);
                goto leave;
 
        case RSTATPROC_STATS:
Index: libexec/rpc.rusersd/rusers_proc.c
===================================================================
RCS file: /cvsroot/src/libexec/rpc.rusersd/rusers_proc.c,v
retrieving revision 1.26
diff -u -p -r1.26 rusers_proc.c
--- libexec/rpc.rusersd/rusers_proc.c   16 Mar 2009 00:56:16 -0000      1.26
+++ libexec/rpc.rusersd/rusers_proc.c   24 Aug 2011 08:48:49 -0000
@@ -360,7 +360,7 @@ rusers_service(struct svc_req *rqstp, SV
 
        switch (rqstp->rq_proc) {
        case NULLPROC:
-               (void)svc_sendreply(transp, xdr_void, NULL);
+               (void)svc_sendreply(transp, (xdrproc_t)xdr_void, NULL);
                goto leave;
 
        case RUSERSPROC_NUM:
Index: libexec/rpc.rwalld/rwalld.c
===================================================================
RCS file: /cvsroot/src/libexec/rpc.rwalld/rwalld.c,v
retrieving revision 1.20
diff -u -p -r1.20 rwalld.c
--- libexec/rpc.rwalld/rwalld.c 9 May 2006 20:18:07 -0000       1.20
+++ libexec/rpc.rwalld/rwalld.c 24 Aug 2011 08:48:49 -0000
@@ -159,7 +159,7 @@ wallprog_1(struct svc_req *rqstp, SVCXPR
 
        switch (rqstp->rq_proc) {
        case NULLPROC:
-               (void)svc_sendreply(transp, xdr_void, (char *)NULL);
+               (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL);
                goto leave;
 
        case WALLPROC_WALL:
Index: libexec/rpc.sprayd/sprayd.c
===================================================================
RCS file: /cvsroot/src/libexec/rpc.sprayd/sprayd.c,v
retrieving revision 1.15
diff -u -p -r1.15 sprayd.c
--- libexec/rpc.sprayd/sprayd.c 21 Oct 2009 01:07:46 -0000      1.15
+++ libexec/rpc.sprayd/sprayd.c 24 Aug 2011 08:48:49 -0000
@@ -133,7 +133,7 @@ spray_service(struct svc_req *rqstp, SVC
                /*FALLTHROUGH*/
 
        case NULLPROC:
-               (void)svc_sendreply(transp, xdr_void, (char *)NULL);
+               (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL);
                return;
 
        case SPRAYPROC_SPRAY:
@@ -152,7 +152,7 @@ spray_service(struct svc_req *rqstp, SVC
                return;
        }
 
-       if (!svc_sendreply(transp, xdr_spraycumul, (caddr_t)&scum)) {
+       if (!svc_sendreply(transp, (xdrproc_t)xdr_spraycumul, (caddr_t)&scum)) {
                svcerr_systemerr(transp);
                syslog(LOG_WARNING, "bad svc_sendreply");
        }
Index: sbin/mount_nfs/getnfsargs.c
===================================================================
RCS file: /cvsroot/src/sbin/mount_nfs/getnfsargs.c,v
retrieving revision 1.14
diff -u -p -r1.14 getnfsargs.c
--- sbin/mount_nfs/getnfsargs.c 23 Jul 2010 19:25:23 -0000      1.14
+++ sbin/mount_nfs/getnfsargs.c 24 Aug 2011 08:48:50 -0000
@@ -249,7 +249,8 @@ tryagain:
                                nfhret.auth = RPCAUTH_UNIX;
                                nfhret.vers = mntvers;
                                clnt_stat = clnt_call(clp, RPCMNT_MOUNT,
-                                   xdr_dir, spec, xdr_fh, &nfhret, try);
+                                   (xdrproc_t)xdr_dir, spec,
+                                   (xdrproc_t)xdr_fh, &nfhret, try);
                                switch (clnt_stat) {
                                case RPC_PROGVERSMISMATCH:
                                        if (nfsvers == NFS_VER3 && !force3) {
Index: sbin/umount/umount.c
===================================================================
RCS file: /cvsroot/src/sbin/umount/umount.c,v
retrieving revision 1.43
diff -u -p -r1.43 umount.c
--- sbin/umount/umount.c        5 Aug 2008 20:57:45 -0000       1.43
+++ sbin/umount/umount.c        24 Aug 2011 08:48:50 -0000
@@ -281,8 +281,8 @@ umountfs(const char *name, const char **
                clp->cl_auth = authsys_create_default();
                try.tv_sec = 20;
                try.tv_usec = 0;
-               clnt_stat = clnt_call(clp, RPCMNT_UMOUNT, xdr_dir,
-                   __UNCONST(name), xdr_void, NULL, try);
+               clnt_stat = clnt_call(clp, RPCMNT_UMOUNT, (xdrproc_t)xdr_dir,
+                   __UNCONST(name), (xdrproc_t)xdr_void, NULL, try);
                if (clnt_stat != RPC_SUCCESS) {
                        clnt_perror(clp, "Bad MNT RPC");
                        return 1;
Index: tests/fs/nfs/nfsservice/mountd.c
===================================================================
RCS file: /cvsroot/src/tests/fs/nfs/nfsservice/mountd.c,v
retrieving revision 1.5
diff -u -p -r1.5 mountd.c
--- tests/fs/nfs/nfsservice/mountd.c    31 Dec 2010 17:59:24 -0000      1.5
+++ tests/fs/nfs/nfsservice/mountd.c    24 Aug 2011 08:48:53 -0000
@@ -536,14 +536,14 @@ mntsrv(rqstp, transp)
        ret = 0;
        switch (rqstp->rq_proc) {
        case NULLPROC:
-               if (!svc_sendreply(transp, xdr_void, NULL))
+               if (!svc_sendreply(transp, (xdrproc_t)xdr_void, NULL))
                        syslog(LOG_ERR, "Can't send reply");
                return;
        case MOUNTPROC_MNT:
                if (debug)
                        fprintf(stderr,
                            "got mount request from %s\n", numerichost);
-               if (!svc_getargs(transp, xdr_dir, rpcpath)) {
+               if (!svc_getargs(transp, (xdrproc_t)xdr_dir, rpcpath)) {
                        if (debug)
                                fprintf(stderr, "-> garbage args\n");
                        svcerr_decode(transp);
@@ -567,7 +567,7 @@ mntsrv(rqstp, transp)
                        if (debug)
                                (void)fprintf(stderr, "-> stat failed on %s\n",
                                    dpath);
-                       if (!svc_sendreply(transp, xdr_long, (caddr_t) &bad))
+                       if (!svc_sendreply(transp, (xdrproc_t)xdr_long, 
(caddr_t) &bad))
                                syslog(LOG_ERR, "Can't send reply");
                        return;
                }
@@ -603,7 +603,7 @@ mntsrv(rqstp, transp)
                        if (rump_sys_getfh(dpath, &fhr.fhr_fh, &fh_size) < 0) {
                                bad = error;
                                //syslog(LOG_ERR, "Can't get fh for %s %d %d", 
dpath, error, fh_size);
-                               if (!svc_sendreply(transp, xdr_long,
+                               if (!svc_sendreply(transp, (xdrproc_t)xdr_long,
                                    (char *)&bad))
                                        syslog(LOG_ERR, "Can't send reply");
                                goto out;
@@ -611,13 +611,13 @@ mntsrv(rqstp, transp)
                        if ((fhr.fhr_vers == 1 && fh_size > NFSX_V2FH) ||
                            fh_size > NFSX_V3FHMAX) {
                                bad = EINVAL; /* XXX */
-                               if (!svc_sendreply(transp, xdr_long,
+                               if (!svc_sendreply(transp, (xdrproc_t)xdr_long,
                                    (char *)&bad))
                                        syslog(LOG_ERR, "Can't send reply");
                                goto out;
                        }
                        fhr.fhr_fhsize = fh_size;
-                       if (!svc_sendreply(transp, xdr_fhs, (char *) &fhr))
+                       if (!svc_sendreply(transp, (xdrproc_t)xdr_fhs, (char *) 
&fhr))
                                syslog(LOG_ERR, "Can't send reply");
                        if (!lookup_failed)
                                add_mlist(host, dpath, hostset);
@@ -626,18 +626,18 @@ mntsrv(rqstp, transp)
                        if (debug)
                                (void)fprintf(stderr, "Mount successful.\n");
                } else {
-                       if (!svc_sendreply(transp, xdr_long, (caddr_t) &bad))
+                       if (!svc_sendreply(transp, (xdrproc_t)xdr_long, 
(caddr_t) &bad))
                                syslog(LOG_ERR, "Can't send reply");
                }
 out:
                (void)sigprocmask(SIG_UNBLOCK, &sighup_mask, NULL);
                return;
        case MOUNTPROC_DUMP:
-               if (!svc_sendreply(transp, xdr_mlist, NULL))
+               if (!svc_sendreply(transp, (xdrproc_t)xdr_mlist, NULL))
                        syslog(LOG_ERR, "Can't send reply");
                return;
        case MOUNTPROC_UMNT:
-               if (!svc_getargs(transp, xdr_dir, dpath)) {
+               if (!svc_getargs(transp, (xdrproc_t)xdr_dir, dpath)) {
                        svcerr_decode(transp);
                        return;
                }
@@ -648,7 +648,7 @@ out:
                        svcerr_weakauth(transp);
                        return;
                }
-               if (!svc_sendreply(transp, xdr_void, NULL))
+               if (!svc_sendreply(transp, (xdrproc_t)xdr_void, NULL))
                        syslog(LOG_ERR, "Can't send reply");
                return;
        case MOUNTPROC_UMNTALL:
@@ -659,12 +659,12 @@ out:
                        svcerr_weakauth(transp);
                        return;
                }
-               if (!svc_sendreply(transp, xdr_void, NULL))
+               if (!svc_sendreply(transp, (xdrproc_t)xdr_void, NULL))
                        syslog(LOG_ERR, "Can't send reply");
                return;
        case MOUNTPROC_EXPORT:
        case MOUNTPROC_EXPORTALL:
-               if (!svc_sendreply(transp, xdr_explist, NULL))
+               if (!svc_sendreply(transp, (xdrproc_t)xdr_explist, NULL))
                        syslog(LOG_ERR, "Can't send reply");
                return;
 
Index: usr.bin/chpass/pw_yp.c
===================================================================
RCS file: /cvsroot/src/usr.bin/chpass/pw_yp.c,v
retrieving revision 1.22
diff -u -p -r1.22 pw_yp.c
--- usr.bin/chpass/pw_yp.c      11 Apr 2009 12:10:02 -0000      1.22
+++ usr.bin/chpass/pw_yp.c      24 Aug 2011 08:48:53 -0000
@@ -196,7 +196,7 @@ pw_yp(struct passwd *pw, uid_t ypuid)
        tv.tv_sec = 5;
        tv.tv_usec = 0;
        r = clnt_call(client, YPPASSWDPROC_UPDATE,
-           xdr_yppasswd, &yppw, xdr_int, &status, tv);
+           (xdrproc_t)xdr_yppasswd, &yppw, (xdrproc_t)xdr_int, &status, tv);
        if (r) {
                warnx("rpc to yppasswdd failed.");
                return (1);
Index: usr.bin/eject/am_glue.c
===================================================================
RCS file: /cvsroot/src/usr.bin/eject/am_glue.c,v
retrieving revision 1.4
diff -u -p -r1.4 am_glue.c
--- usr.bin/eject/am_glue.c     23 Jun 2010 18:07:59 -0000      1.4
+++ usr.bin/eject/am_glue.c     24 Aug 2011 08:48:53 -0000
@@ -124,8 +124,10 @@ am_unmount(const char *dirname)
        if (clnt == NULL)
                return AMQ_UMNT_FAILED;
 
-       if (clnt_call(clnt, xAMQPROC_SYNC_UMNT, xdr_amq_string, &dirname,
-           xdr_amq_sync_umnt, (void *)&result, timeout) != RPC_SUCCESS)
+       if (clnt_call(clnt, xAMQPROC_SYNC_UMNT,
+           (xdrproc_t)xdr_amq_string, &dirname,
+           (xdrproc_t)xdr_amq_sync_umnt, (void *)&result,
+           timeout) != RPC_SUCCESS)
                return AMQ_UMNT_SERVER;
 
        return result.au_etype;
Index: usr.bin/passwd/yp_passwd.c
===================================================================
RCS file: /cvsroot/src/usr.bin/passwd/yp_passwd.c,v
retrieving revision 1.35
diff -u -p -r1.35 yp_passwd.c
--- usr.bin/passwd/yp_passwd.c  8 Sep 2010 13:58:46 -0000       1.35
+++ usr.bin/passwd/yp_passwd.c  24 Aug 2011 08:48:53 -0000
@@ -313,7 +313,7 @@ pwyp_process(const char *username, int a
        tv.tv_sec = 2;
        tv.tv_usec = 0;
        yr = clnt_call(client, YPPASSWDPROC_UPDATE,
-           xdr_yppasswd, &ypp, xdr_int, &status, tv);
+           (xdrproc_t)xdr_yppasswd, &ypp, (xdrproc_t)xdr_int, &status, tv);
        if (yr != RPC_SUCCESS)
                errx(EXIT_FAILURE, "RPC to yppasswdd failed (%s)",
                    clnt_sperrno(yr));
Index: usr.bin/rup/rup.c
===================================================================
RCS file: /cvsroot/src/usr.bin/rup/rup.c,v
retrieving revision 1.27
diff -u -p -r1.27 rup.c
--- usr.bin/rup/rup.c   15 Dec 2007 19:44:53 -0000      1.27
+++ usr.bin/rup/rup.c   24 Aug 2011 08:48:53 -0000
@@ -298,8 +298,8 @@ onehost(char *host)
        }
 
        (void)memset(&host_stat, 0, sizeof(host_stat));
-       if (clnt_call(rstat_clnt, RSTATPROC_STATS, xdr_void, NULL,
-           xdr_statstime, &host_stat, timeout) != RPC_SUCCESS) {
+       if (clnt_call(rstat_clnt, RSTATPROC_STATS, (xdrproc_t)xdr_void, NULL,
+           (xdrproc_t)xdr_statstime, &host_stat, timeout) != RPC_SUCCESS) {
                warnx("%s",  clnt_sperror(rstat_clnt, host));
                clnt_destroy(rstat_clnt);
                return 1;
@@ -323,7 +323,7 @@ allhosts(void)
        }
 
        clnt_stat = rpc_broadcast(RSTATPROG, RSTATVERS_TIME, RSTATPROC_STATS,
-           xdr_void, NULL, xdr_statstime, (caddr_t)(void *)&host_stat,
+           (xdrproc_t)xdr_void, NULL, (xdrproc_t)xdr_statstime, (caddr_t)(void 
*)&host_stat,
            (resultproc_t)rstat_reply, "udp");
        if (clnt_stat != RPC_SUCCESS && clnt_stat != RPC_TIMEDOUT)
                errx(1, "%s", clnt_sperrno(clnt_stat));
Index: usr.bin/rusers/rusers.c
===================================================================
RCS file: /cvsroot/src/usr.bin/rusers/rusers.c,v
retrieving revision 1.23
diff -u -p -r1.23 rusers.c
--- usr.bin/rusers/rusers.c     11 May 2006 01:25:23 -0000      1.23
+++ usr.bin/rusers/rusers.c     24 Aug 2011 08:48:53 -0000
@@ -244,8 +244,9 @@ onehost(char *host)
                err(1, "%s", gai_strerror(ecode));
 
        memset((char *)&up, 0, sizeof(up));
-       clnt_stat = clnt_call(rusers_clnt, RUSERSPROC_NAMES, xdr_void, NULL,
-           xdr_utmpidlearr, &up, timeout);
+       clnt_stat = clnt_call(rusers_clnt, RUSERSPROC_NAMES,
+           (xdrproc_t)xdr_void, NULL,
+           (xdrproc_t)xdr_utmpidlearr, &up, timeout);
        if (clnt_stat != RPC_SUCCESS)
                errx(1, "%s", clnt_sperrno(clnt_stat));
        nb.buf = ai->ai_addr;
@@ -262,8 +263,9 @@ allhosts(void)
 
        memset((char *)&up, 0, sizeof(up));
        clnt_stat = rpc_broadcast(RUSERSPROG, RUSERSVERS_IDLE,
-           RUSERSPROC_NAMES, xdr_void, NULL, xdr_utmpidlearr,
-           (char *)&up, (resultproc_t)rusers_reply, "udp");
+           RUSERSPROC_NAMES, (xdrproc_t)xdr_void, NULL,
+           (xdrproc_t)xdr_utmpidlearr, (char *)&up,
+           (resultproc_t)rusers_reply, "udp");
        if (clnt_stat != RPC_SUCCESS && clnt_stat != RPC_TIMEDOUT)
                errx(1, "%s", clnt_sperrno(clnt_stat));
 }
Index: usr.bin/rwall/rwall.c
===================================================================
RCS file: /cvsroot/src/usr.bin/rwall/rwall.c,v
retrieving revision 1.17
diff -u -p -r1.17 rwall.c
--- usr.bin/rwall/rwall.c       21 Jul 2008 14:19:25 -0000      1.17
+++ usr.bin/rwall/rwall.c       24 Aug 2011 08:48:54 -0000
@@ -132,8 +132,8 @@ main(int argc, char **argv)
 
        mbuf = makemsg(argv[2]);
 
-       if (clnt_call(cl, WALLPROC_WALL, xdr_wrapstring, (void *)&mbuf,
-           xdr_void, &res, timeout) != RPC_SUCCESS) {
+       if (clnt_call(cl, WALLPROC_WALL, (xdrproc_t)xdr_wrapstring, (void 
*)&mbuf,
+           (xdrproc_t)xdr_void, &res, timeout) != RPC_SUCCESS) {
                free(mbuf);
                /*
                 * An error occurred while calling the server. 
Index: usr.bin/showmount/showmount.c
===================================================================
RCS file: /cvsroot/src/usr.bin/showmount/showmount.c,v
retrieving revision 1.18
diff -u -p -r1.18 showmount.c
--- usr.bin/showmount/showmount.c       27 Feb 2011 10:11:27 -0000      1.18
+++ usr.bin/showmount/showmount.c       24 Aug 2011 08:48:54 -0000
@@ -153,16 +153,16 @@ main(int argc, char **argv)
 
        if (rpcs & DODUMP)
                if ((estat = tcp_callrpc(host, RPCPROG_MNT, mntvers,
-                        RPCMNT_DUMP, xdr_void, (char *)0,
-                        xdr_mntdump, (char *)&mntdump)) != 0) {
+                        RPCMNT_DUMP, (xdrproc_t)xdr_void, (char *)0,
+                        (xdrproc_t)xdr_mntdump, (char *)&mntdump)) != 0) {
                        fprintf(stderr, "showmount: Can't do Mountdump rpc: ");
                        clnt_perrno(estat);
                        exit(1);
                }
        if (rpcs & DOEXPORTS)
                if ((estat = tcp_callrpc(host, RPCPROG_MNT, mntvers,
-                        RPCMNT_EXPORT, xdr_void, (char *)0,
-                        xdr_exports, (char *)&exports)) != 0) {
+                        RPCMNT_EXPORT, (xdrproc_t)xdr_void, (char *)0,
+                        (xdrproc_t)xdr_exports, (char *)&exports)) != 0) {
                        fprintf(stderr, "showmount: Can't do Exports rpc: ");
                        clnt_perrno(estat);
                        exit(1);
Index: usr.bin/ypwhich/ypwhich.c
===================================================================
RCS file: /cvsroot/src/usr.bin/ypwhich/ypwhich.c,v
retrieving revision 1.18
diff -u -p -r1.18 ypwhich.c
--- usr.bin/ypwhich/ypwhich.c   1 Feb 2011 20:58:15 -0000       1.18
+++ usr.bin/ypwhich/ypwhich.c   24 Aug 2011 08:48:54 -0000
@@ -248,8 +248,8 @@ find_server(const char *host, const char
        tv.tv_sec = 5;
        tv.tv_usec = 0;
        retval = clnt_call(ypbind, (unsigned int)YPBINDPROC_DOMAIN,
-           xdr_ypdomain_wrap_string, &domain, xdr_ypbind_resp, &ypbind_resp,
-           tv);
+           (xdrproc_t)xdr_ypdomain_wrap_string, &domain,
+           (xdrproc_t)xdr_ypbind_resp, &ypbind_resp, tv);
        clnt_destroy(ypbind);
        if (retval != RPC_SUCCESS)
                errx(1, "clnt_call: %s: %s", host, clnt_sperrno(retval));
@@ -344,8 +344,8 @@ find_mapmaster(const char *host, const c
                tv.tv_sec = 5;
                tv.tv_usec = 0;
                retval = clnt_call(ypserv, (unsigned int)YPPROC_MAPLIST,
-                   xdr_ypdomain_wrap_string, &domain, xdr_ypresp_maplist,
-                   &yprespmlist, tv);
+                   (xdrproc_t)xdr_ypdomain_wrap_string, &domain,
+                   (xdrproc_t)xdr_ypresp_maplist, &yprespmlist, tv);
                if (retval != RPC_SUCCESS) {
                        warnx("clnt_call MAPLIST: %s: %s", host,
                            clnt_sperrno(retval));
@@ -379,8 +379,8 @@ find_mapmaster(const char *host, const c
                tv.tv_sec = 5;
                tv.tv_usec = 0;
                retval = clnt_call(ypserv, (unsigned int)YPPROC_MASTER,
-                   xdr_ypreq_nokey, &ypreqkey, xdr_ypresp_master,
-                   &yprespmaster, tv);
+                   (xdrproc_t)xdr_ypreq_nokey, &ypreqkey,
+                   (xdrproc_t)xdr_ypresp_master, &yprespmaster, tv);
                if (retval != RPC_SUCCESS) {
                        warnx("clnt_call MASTER: %s: %s", host,
                            clnt_sperrno(retval));
@@ -394,7 +394,7 @@ find_mapmaster(const char *host, const c
                        (void)printf("%s %s\n", ypml->ypml_name,
                            yprespmaster.master);
                }
-               xdr_free(xdr_ypresp_master, (void *)&yprespmaster);
+               xdr_free((xdrproc_t)xdr_ypresp_master, (void *)&yprespmaster);
        }
        clnt_destroy(ypserv);
 
Index: usr.sbin/mountd/mountd.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/mountd/mountd.c,v
retrieving revision 1.120
diff -u -p -r1.120 mountd.c
--- usr.sbin/mountd/mountd.c    11 Oct 2009 16:30:19 -0000      1.120
+++ usr.sbin/mountd/mountd.c    24 Aug 2011 08:48:56 -0000
@@ -522,14 +522,14 @@ mntsrv(rqstp, transp)
        ret = 0;
        switch (rqstp->rq_proc) {
        case NULLPROC:
-               if (!svc_sendreply(transp, xdr_void, NULL))
+               if (!svc_sendreply(transp, (xdrproc_t)xdr_void, NULL))
                        syslog(LOG_ERR, "Can't send reply");
                return;
        case MOUNTPROC_MNT:
                if (debug)
                        fprintf(stderr,
                            "got mount request from %s\n", numerichost);
-               if (!svc_getargs(transp, xdr_dir, rpcpath)) {
+               if (!svc_getargs(transp, (xdrproc_t)xdr_dir, rpcpath)) {
                        if (debug)
                                fprintf(stderr, "-> garbage args\n");
                        svcerr_decode(transp);
@@ -550,7 +550,7 @@ mntsrv(rqstp, transp)
                        if (debug)
                                (void)fprintf(stderr, "-> stat failed on %s\n",
                                    rdirpath);
-                       if (!svc_sendreply(transp, xdr_long, (caddr_t) &bad))
+                       if (!svc_sendreply(transp, (xdrproc_t)xdr_long, 
(caddr_t) &bad))
                                syslog(LOG_ERR, "Can't send reply");
                        return;
                }
@@ -585,7 +585,7 @@ mntsrv(rqstp, transp)
                        if (getfh(rdirpath, &fhr.fhr_fh, &fh_size) < 0) {
                                bad = errno;
                                syslog(LOG_ERR, "Can't get fh for %s", 
rdirpath);
-                               if (!svc_sendreply(transp, xdr_long,
+                               if (!svc_sendreply(transp, (xdrproc_t)xdr_long,
                                    (char *)&bad))
                                        syslog(LOG_ERR, "Can't send reply");
                                goto out;
@@ -593,13 +593,13 @@ mntsrv(rqstp, transp)
                        if ((fhr.fhr_vers == 1 && fh_size > NFSX_V2FH) ||
                            fh_size > NFSX_V3FHMAX) {
                                bad = EINVAL; /* XXX */
-                               if (!svc_sendreply(transp, xdr_long,
+                               if (!svc_sendreply(transp, (xdrproc_t)xdr_long,
                                    (char *)&bad))
                                        syslog(LOG_ERR, "Can't send reply");
                                goto out;
                        }
                        fhr.fhr_fhsize = fh_size;
-                       if (!svc_sendreply(transp, xdr_fhs, (char *) &fhr))
+                       if (!svc_sendreply(transp, (xdrproc_t)xdr_fhs, (char *) 
&fhr))
                                syslog(LOG_ERR, "Can't send reply");
                        if (!lookup_failed)
                                add_mlist(host, rdirpath, hostset);
@@ -608,18 +608,18 @@ mntsrv(rqstp, transp)
                        if (debug)
                                (void)fprintf(stderr, "Mount successful.\n");
                } else {
-                       if (!svc_sendreply(transp, xdr_long, (caddr_t) &bad))
+                       if (!svc_sendreply(transp, (xdrproc_t)xdr_long, 
(caddr_t) &bad))
                                syslog(LOG_ERR, "Can't send reply");
                }
 out:
                (void)sigprocmask(SIG_UNBLOCK, &sighup_mask, NULL);
                return;
        case MOUNTPROC_DUMP:
-               if (!svc_sendreply(transp, xdr_mlist, NULL))
+               if (!svc_sendreply(transp, (xdrproc_t)xdr_mlist, NULL))
                        syslog(LOG_ERR, "Can't send reply");
                return;
        case MOUNTPROC_UMNT:
-               if (!svc_getargs(transp, xdr_dir, rdirpath)) {
+               if (!svc_getargs(transp, (xdrproc_t)xdr_dir, rdirpath)) {
                        svcerr_decode(transp);
                        return;
                }
@@ -630,7 +630,7 @@ out:
                        svcerr_weakauth(transp);
                        return;
                }
-               if (!svc_sendreply(transp, xdr_void, NULL))
+               if (!svc_sendreply(transp, (xdrproc_t)xdr_void, NULL))
                        syslog(LOG_ERR, "Can't send reply");
                return;
        case MOUNTPROC_UMNTALL:
@@ -641,12 +641,12 @@ out:
                        svcerr_weakauth(transp);
                        return;
                }
-               if (!svc_sendreply(transp, xdr_void, NULL))
+               if (!svc_sendreply(transp, (xdrproc_t)xdr_void, NULL))
                        syslog(LOG_ERR, "Can't send reply");
                return;
        case MOUNTPROC_EXPORT:
        case MOUNTPROC_EXPORTALL:
-               if (!svc_sendreply(transp, xdr_explist, NULL))
+               if (!svc_sendreply(transp, (xdrproc_t)xdr_explist, NULL))
                        syslog(LOG_ERR, "Can't send reply");
                return;
 
@@ -2367,7 +2367,8 @@ send_umntall(n)
        int n;
 {
        (void)clnt_broadcast(RPCPROG_MNT, RPCMNT_VER1, RPCMNT_UMNTALL,
-           xdr_void, NULL, xdr_void, NULL, (resultproc_t)umntall_each);
+           (xdrproc_t)xdr_void, NULL, (xdrproc_t)xdr_void, NULL,
+           (resultproc_t)umntall_each);
        exit(0);
 }
 
Index: usr.sbin/rpc.lockd/lock_proc.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/rpc.lockd/lock_proc.c,v
retrieving revision 1.9
diff -u -p -r1.9 lock_proc.c
--- usr.sbin/rpc.lockd/lock_proc.c      4 Nov 2007 23:12:50 -0000       1.9
+++ usr.sbin/rpc.lockd/lock_proc.c      24 Aug 2011 08:48:56 -0000
@@ -270,8 +270,9 @@ transmit_result(int opcode, nlm_res *res
                timeo.tv_sec = 0; /* No timeout - not expecting response */
                timeo.tv_usec = 0;
 
-               success = clnt_call(cli, (rpcproc_t)opcode, xdr_nlm_res,
-                   result, xdr_void, &dummy, timeo);
+               success = clnt_call(cli, (rpcproc_t)opcode,
+                   (xdrproc_t)xdr_nlm_res, result,
+                   (xdrproc_t)xdr_void, &dummy, timeo);
 
                if (debug_level > 2)
                        syslog(LOG_DEBUG, "clnt_call returns %d(%s)",
@@ -298,8 +299,9 @@ transmit4_result(int opcode, nlm4_res *r
                timeo.tv_sec = 0; /* No timeout - not expecting response */
                timeo.tv_usec = 0;
 
-               success = clnt_call(cli, (rpcproc_t)opcode, xdr_nlm4_res,
-                   result, xdr_void, &dummy, timeo);
+               success = clnt_call(cli, (rpcproc_t)opcode,
+                   (xdrproc_t)xdr_nlm4_res, result,
+                   (xdrproc_t)xdr_void, &dummy, timeo);
 
                if (debug_level > 2)
                        syslog(LOG_DEBUG, "clnt_call returns %d(%s)",
@@ -426,8 +428,9 @@ nlm_test_msg_1_svc(nlm_testargs *arg, st
                timeo.tv_sec = 0; /* No timeout - not expecting response */
                timeo.tv_usec = 0;
 
-               success = clnt_call(cli, NLM_TEST_RES, xdr_nlm_testres,
-                   &result, xdr_void, &dummy, timeo);
+               success = clnt_call(cli, NLM_TEST_RES,
+                   (xdrproc_t)xdr_nlm_testres, &result,
+                   (xdrproc_t)xdr_void, &dummy, timeo);
 
                if (debug_level > 2)
                        syslog(LOG_DEBUG, "clnt_call returns %d", success);
@@ -864,8 +867,9 @@ nlm4_test_msg_4_svc(nlm4_testargs *arg, 
                timeo.tv_sec = 0; /* No timeout - not expecting response */
                timeo.tv_usec = 0;
 
-               success = clnt_call(cli, NLM4_TEST_RES, xdr_nlm4_testres,
-                   &result, xdr_void, &dummy, timeo);
+               success = clnt_call(cli, NLM4_TEST_RES,
+                   (xdrproc_t)xdr_nlm4_testres, &result,
+                   (xdrproc_t)xdr_void, &dummy, timeo);
 
                if (debug_level > 2)
                        syslog(LOG_DEBUG, "clnt_call returns %d", success);
Index: usr.sbin/rpc.lockd/lockd_lock.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/rpc.lockd/lockd_lock.c,v
retrieving revision 1.31
diff -u -p -r1.31 lockd_lock.c
--- usr.sbin/rpc.lockd/lockd_lock.c     19 Nov 2009 22:27:26 -0000      1.31
+++ usr.sbin/rpc.lockd/lockd_lock.c     24 Aug 2011 08:48:57 -0000
@@ -646,11 +646,12 @@ send_granted(struct file_lock *fl, int o
                    (fl->flags & LOCK_ASYNC) ? " (async)":"");
                if (fl->flags & LOCK_ASYNC) {
                        success = clnt_call(cli, NLM4_GRANTED_MSG,
-                           xdr_nlm4_testargs, &result, xdr_void, &dummy, 
timeo);
+                           (xdrproc_t)xdr_nlm4_testargs, &result,
+                           (xdrproc_t)xdr_void, &dummy, timeo);
                } else {
                        success = clnt_call(cli, NLM4_GRANTED,
-                           xdr_nlm4_testargs, &result, xdr_nlm4_res,
-                           &retval4, timeo);
+                           (xdrproc_t)xdr_nlm4_testargs, &result,
+                           (xdrproc_t)xdr_nlm4_res, &retval4, timeo);
                }
        } else {
                static nlm_testargs result;
@@ -670,11 +671,12 @@ send_granted(struct file_lock *fl, int o
                    (fl->flags & LOCK_ASYNC) ? " (async)":"");
                if (fl->flags & LOCK_ASYNC) {
                        success = clnt_call(cli, NLM_GRANTED_MSG,
-                           xdr_nlm_testargs, &result, xdr_void, &dummy, timeo);
+                           (xdrproc_t)xdr_nlm_testargs, &result,
+                           (xdrproc_t)xdr_void, &dummy, timeo);
                } else {
                        success = clnt_call(cli, NLM_GRANTED,
-                           xdr_nlm_testargs, &result, xdr_nlm_res,
-                           &retval, timeo);
+                           (xdrproc_t)xdr_nlm_testargs, &result,
+                           (xdrproc_t)xdr_nlm_res, &retval, timeo);
                }
        }
        if (debug_level > 2)
@@ -791,8 +793,9 @@ do_mon(const char *hostname)
        my_mon.mon_id.my_id.my_prog = NLM_PROG;
        my_mon.mon_id.my_id.my_vers = NLM_SM;
        my_mon.mon_id.my_id.my_proc = NLM_SM_NOTIFY;
-       if ((retval = callrpc(localhost, SM_PROG, SM_VERS, SM_MON, xdr_mon,
-           (void *)&my_mon, xdr_sm_stat_res, (void *)&result)) != 0) {
+       if ((retval = callrpc(localhost, SM_PROG, SM_VERS, SM_MON,
+           (xdrproc_t)xdr_mon, (void *)&my_mon,
+           (xdrproc_t)xdr_sm_stat_res, (void *)&result)) != 0) {
                syslog(LOG_WARNING, "rpc to statd failed (%s)",
                    clnt_sperrno((enum clnt_stat)retval));
                free(hp);
Index: usr.sbin/rpc.statd/stat_proc.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/rpc.statd/stat_proc.c,v
retrieving revision 1.8
diff -u -p -r1.8 stat_proc.c
--- usr.sbin/rpc.statd/stat_proc.c      18 Apr 2009 13:04:50 -0000      1.8
+++ usr.sbin/rpc.statd/stat_proc.c      24 Aug 2011 08:48:57 -0000
@@ -357,8 +357,9 @@ sm_notify_1_svc(arg, req)
                        syslog(LOG_ERR, "Failed to contact host %s%s",
                            lp->notifyHost, clnt_spcreateerror(""));
                else {
-                       if (clnt_call(cli, lp->notifyProc, xdr_status, &tx_arg,
-                           xdr_void, &dummy, timeout) != RPC_SUCCESS)
+                       if (clnt_call(cli, lp->notifyProc,
+                           (xdrproc_t)xdr_status, &tx_arg,
+                           (xdrproc_t)xdr_void, &dummy, timeout) != 
RPC_SUCCESS)
                                syslog(LOG_ERR,
                                    "Failed to call rpc.statd client at host 
%s",
                                    lp->notifyHost);
Index: usr.sbin/rpc.statd/statd.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/rpc.statd/statd.c,v
retrieving revision 1.29
diff -u -p -r1.29 statd.c
--- usr.sbin/rpc.statd/statd.c  18 Apr 2009 13:04:50 -0000      1.29
+++ usr.sbin/rpc.statd/statd.c  24 Aug 2011 08:48:57 -0000
@@ -609,8 +609,8 @@ notify_one_host(hostname)
                    clnt_spcreateerror(""));
                return (FALSE);
        }
-       if (clnt_call(cli, SM_NOTIFY, xdr_stat_chge, &arg, xdr_void,
-           &dummy, timeout) != RPC_SUCCESS) {
+       if (clnt_call(cli, SM_NOTIFY, (xdrproc_t)xdr_stat_chge, &arg,
+           (xdrproc_t)xdr_void, &dummy, timeout) != RPC_SUCCESS) {
                syslog(LOG_ERR, "Failed to contact rpc.statd at host %s",
                    hostname);
                clnt_destroy(cli);
Index: usr.sbin/rpc.yppasswdd/rpc.yppasswdd.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/rpc.yppasswdd/rpc.yppasswdd.c,v
retrieving revision 1.14
diff -u -p -r1.14 rpc.yppasswdd.c
--- usr.sbin/rpc.yppasswdd/rpc.yppasswdd.c      24 May 2011 13:27:16 -0000      
1.14
+++ usr.sbin/rpc.yppasswdd/rpc.yppasswdd.c      24 Aug 2011 08:48:57 -0000
@@ -142,7 +142,7 @@ yppasswddprog_1(struct svc_req *rqstp, S
 
        switch (rqstp->rq_proc) {
        case NULLPROC:
-               (void)svc_sendreply(transp, xdr_void, (char *) NULL);
+               (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (char *) NULL);
                return;
 
        case YPPASSWDPROC_UPDATE:
@@ -154,12 +154,12 @@ yppasswddprog_1(struct svc_req *rqstp, S
                 * client.
                 */
                (void)memset(&argument, 0, sizeof(argument));
-               if (!svc_getargs(transp, xdr_yppasswd, (caddr_t) & argument)) {
+               if (!svc_getargs(transp, (xdrproc_t)xdr_yppasswd, (caddr_t) & 
argument)) {
                        svcerr_decode(transp);
                        return;
                }
                make_passwd((yppasswd *)&argument, rqstp, transp);
-               if (!svc_freeargs(transp, xdr_yppasswd, (caddr_t) &argument))
+               if (!svc_freeargs(transp, (xdrproc_t)xdr_yppasswd, (caddr_t) 
&argument))
                        errx(EXIT_FAILURE, "unable to free arguments");
                return;
        }
Index: usr.sbin/rpc.yppasswdd/yppasswdd_mkpw.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/rpc.yppasswdd/yppasswdd_mkpw.c,v
retrieving revision 1.17
diff -u -p -r1.17 yppasswdd_mkpw.c
--- usr.sbin/rpc.yppasswdd/yppasswdd_mkpw.c     20 Oct 2009 00:51:14 -0000      
1.17
+++ usr.sbin/rpc.yppasswdd/yppasswdd_mkpw.c     24 Aug 2011 08:48:57 -0000
@@ -74,7 +74,7 @@ make_passwd(yppasswd *argp, struct svc_r
 
 #define REPLY(val)     do { \
                int res = (val); \
-               if (!svc_sendreply(transp, xdr_int, (caddr_t)&res)) \
+               if (!svc_sendreply(transp, (xdrproc_t)xdr_int, (caddr_t)&res)) \
                        svcerr_systemerr(transp); \
        } while (0)
 
Index: usr.sbin/spray/spray.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/spray/spray.c,v
retrieving revision 1.6
diff -u -p -r1.6 spray.c
--- usr.sbin/spray/spray.c      18 Apr 2009 14:01:37 -0000      1.6
+++ usr.sbin/spray/spray.c      24 Aug 2011 08:48:58 -0000
@@ -145,7 +145,8 @@ main(argc, argv)
 
 
        /* Clear server statistics */
-       if (clnt_call(cl, SPRAYPROC_CLEAR, xdr_void, NULL, xdr_void, NULL, 
TIMEOUT) != RPC_SUCCESS) {
+       if (clnt_call(cl, SPRAYPROC_CLEAR, (xdrproc_t)xdr_void, NULL,
+           (xdrproc_t)xdr_void, NULL, TIMEOUT) != RPC_SUCCESS) {
                clnt_perror(cl, progname);
                exit(1);
        }
@@ -156,7 +157,8 @@ main(argc, argv)
        fflush (stdout);
 
        for (i = 0; i < count; i++) {
-               clnt_call(cl, SPRAYPROC_SPRAY, xdr_sprayarr, &host_array, 
xdr_void, NULL, ONE_WAY);
+               clnt_call(cl, SPRAYPROC_SPRAY, (xdrproc_t)xdr_sprayarr, 
&host_array,
+                   (xdrproc_t)xdr_void, NULL, ONE_WAY);
 
                if (delay) {
                        usleep(delay);
@@ -165,7 +167,8 @@ main(argc, argv)
 
 
        /* Collect statistics from server */
-       if (clnt_call(cl, SPRAYPROC_GET, xdr_void, NULL, xdr_spraycumul, 
&host_stats, TIMEOUT) != RPC_SUCCESS) {
+       if (clnt_call(cl, SPRAYPROC_GET, (xdrproc_t)xdr_void, NULL,
+           (xdrproc_t)xdr_spraycumul, &host_stats, TIMEOUT) != RPC_SUCCESS) {
                clnt_perror(cl, progname);
                exit(1);
        }
Index: usr.sbin/ypbind/ypbind.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/ypbind/ypbind.c,v
retrieving revision 1.88
diff -u -p -r1.88 ypbind.c
--- usr.sbin/ypbind/ypbind.c    25 May 2011 04:59:22 -0000      1.88
+++ usr.sbin/ypbind/ypbind.c    24 Aug 2011 08:48:59 -0000
@@ -576,14 +576,14 @@ ypbindprog_2(struct svc_req *rqstp, regi
 
        switch (rqstp->rq_proc) {
        case YPBINDPROC_NULL:
-               xdr_argument = xdr_void;
-               xdr_result = xdr_void;
+               xdr_argument = (xdrproc_t)xdr_void;
+               xdr_result = (xdrproc_t)xdr_void;
                local = ypbindproc_null_2;
                break;
 
        case YPBINDPROC_DOMAIN:
-               xdr_argument = xdr_ypdomain_wrap_string;
-               xdr_result = xdr_ypbind_resp;
+               xdr_argument = (xdrproc_t)xdr_ypdomain_wrap_string;
+               xdr_result = (xdrproc_t)xdr_ypbind_resp;
                local = ypbindproc_domain_2;
                break;
 
@@ -601,8 +601,8 @@ ypbindprog_2(struct svc_req *rqstp, regi
                        return;
                }
 
-               xdr_argument = xdr_ypbind_setdom;
-               xdr_result = xdr_void;
+               xdr_argument = (xdrproc_t)xdr_ypbind_setdom;
+               xdr_result = (xdrproc_t)xdr_void;
                local = ypbindproc_setdom_2;
                break;
 
@@ -663,7 +663,7 @@ sunrpc_setup(void)
        rmtca.xdr_args = NULL;          /* set at call time */
        rmtca.args_ptr = NULL;          /* set at call time */
        rmtcr.port_ptr = &rmtcr_port;
-       rmtcr.xdr_results = xdr_bool;
+       rmtcr.xdr_results = (xdrproc_t)xdr_bool;
        rmtcr.results_ptr = (caddr_t)(void *)&rmtcr_outval;
 }
 
@@ -874,7 +874,7 @@ recv_again:
        (void)memset(&msg, 0, sizeof(msg));
        msg.acpted_rply.ar_verf = _null_auth;
        msg.acpted_rply.ar_results.where = (caddr_t)(void *)&rmtcr;
-       msg.acpted_rply.ar_results.proc = xdr_rmtcallres;
+       msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_rmtcallres;
 
 try_again:
        fromlen = sizeof(struct sockaddr);
@@ -905,7 +905,7 @@ try_again:
                }
        }
        xdr.x_op = XDR_FREE;
-       msg.acpted_rply.ar_results.proc = xdr_void;
+       msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void;
        xdr_destroy(&xdr);
 
        return RPC_SUCCESS;
@@ -929,7 +929,7 @@ recv_again:
        (void)memset(&msg, 0, sizeof(msg));
        msg.acpted_rply.ar_verf = _null_auth;
        msg.acpted_rply.ar_results.where = (caddr_t)(void *)&res;
-       msg.acpted_rply.ar_results.proc = xdr_bool;
+       msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_bool;
 
 try_again:
        fromlen = sizeof (struct sockaddr);
@@ -959,7 +959,7 @@ try_again:
                }
        }
        xdr.x_op = XDR_FREE;
-       msg.acpted_rply.ar_results.proc = xdr_void;
+       msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void;
        xdr_destroy(&xdr);
 
        return RPC_SUCCESS;
@@ -977,7 +977,7 @@ nag_servers(struct domain *dom)
        XDR xdr;
 
        DPRINTF("nag_servers\n");
-       rmtca.xdr_args = xdr_ypdomain_wrap_string;
+       rmtca.xdr_args = (xdrproc_t)xdr_ypdomain_wrap_string;
        rmtca.args_ptr = (caddr_t)(void *)&dom_name;
 
        (void)memset(&xdr, 0, sizeof xdr);
Index: usr.sbin/yppoll/yppoll.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/yppoll/yppoll.c,v
retrieving revision 1.14
diff -u -p -r1.14 yppoll.c
--- usr.sbin/yppoll/yppoll.c    25 Jan 2008 19:58:54 -0000      1.14
+++ usr.sbin/yppoll/yppoll.c    24 Aug 2011 08:48:59 -0000
@@ -195,26 +195,28 @@ get_remote_info(const char *indomain, co
        tv.tv_sec = 10;
        tv.tv_usec = 0;
 
-       r = clnt_call(client, (unsigned int)YPPROC_ORDER, xdr_ypreq_nokey,
-           &yprnk, xdr_ypresp_order, &ypro, tv);
+       r = clnt_call(client, (unsigned int)YPPROC_ORDER,
+           (xdrproc_t)xdr_ypreq_nokey, &yprnk,
+           (xdrproc_t)xdr_ypresp_order, &ypro, tv);
        if (r != RPC_SUCCESS)
                clnt_perror(client, "yp_order: clnt_call");
 
        *outorder = ypro.ordernum;
-       xdr_free(xdr_ypresp_order, (void *)&ypro);
+       xdr_free((xdrproc_t)xdr_ypresp_order, (void *)&ypro);
 
        r = ypprot_err(ypro.status);
        if (r == RPC_SUCCESS) {
                (void)memset(&yprm, 0, sizeof(yprm));
 
                r = clnt_call(client, (unsigned int)YPPROC_MASTER,
-                   xdr_ypreq_nokey, &yprnk, xdr_ypresp_master, &yprm, tv);
+                   (xdrproc_t)xdr_ypreq_nokey, &yprnk,
+                   (xdrproc_t)xdr_ypresp_master, &yprm, tv);
                if (r != RPC_SUCCESS)
                        clnt_perror(client, "yp_master: clnt_call");
                r = ypprot_err(yprm.status);
                if (r == 0)
                        *outname = (char *)strdup(yprm.master);
-               xdr_free(xdr_ypresp_master, (void *)&yprm);
+               xdr_free((xdrproc_t)xdr_ypresp_master, (void *)&yprm);
        }
        clnt_destroy(client);
        return r;
Index: usr.sbin/ypserv/common/yplib_host.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/ypserv/common/yplib_host.c,v
retrieving revision 1.8
diff -u -p -r1.8 yplib_host.c
--- usr.sbin/ypserv/common/yplib_host.c 19 Apr 2009 06:06:39 -0000      1.8
+++ usr.sbin/ypserv/common/yplib_host.c 24 Aug 2011 08:48:59 -0000
@@ -141,8 +141,8 @@ yp_match_host(CLIENT *client, char *indo
 
        memset(&yprv, 0, sizeof yprv);
 
-       r = clnt_call(client, YPPROC_MATCH, xdr_ypreq_key, &yprk,
-           xdr_ypresp_val, &yprv, _yplib_host_timeout);
+       r = clnt_call(client, YPPROC_MATCH, (xdrproc_t)xdr_ypreq_key, &yprk,
+           (xdrproc_t)xdr_ypresp_val, &yprv, _yplib_host_timeout);
        if(r != RPC_SUCCESS)
                clnt_perror(client, "yp_match_host: clnt_call");
 
@@ -152,7 +152,7 @@ yp_match_host(CLIENT *client, char *indo
                memcpy(*outval, yprv.valdat.dptr, *outvallen);
                (*outval)[*outvallen] = '\0';
        }
-       xdr_free(xdr_ypresp_val, (char *)&yprv);
+       xdr_free((xdrproc_t)xdr_ypresp_val, (char *)&yprv);
        return r;
 }
 
@@ -171,8 +171,8 @@ yp_first_host(CLIENT *client, char *indo
        yprnk.map = inmap;
        memset(&yprkv, 0, sizeof yprkv);
 
-       r = clnt_call(client, YPPROC_FIRST, xdr_ypreq_nokey, &yprnk,
-           xdr_ypresp_key_val, &yprkv, _yplib_host_timeout);
+       r = clnt_call(client, YPPROC_FIRST, (xdrproc_t)xdr_ypreq_nokey, &yprnk,
+           (xdrproc_t)xdr_ypresp_key_val, &yprkv, _yplib_host_timeout);
        if (r != RPC_SUCCESS)
                clnt_perror(client, "yp_first_host: clnt_call");
 
@@ -186,7 +186,7 @@ yp_first_host(CLIENT *client, char *indo
                memcpy(*outval, yprkv.valdat.dptr, *outvallen);
                (*outval)[*outvallen] = '\0';
        }
-       xdr_free(xdr_ypresp_key_val, (char *)&yprkv);
+       xdr_free((xdrproc_t)xdr_ypresp_key_val, (char *)&yprkv);
        return r;
 }
 
@@ -208,8 +208,8 @@ yp_next_host(CLIENT *client, char *indom
        yprk.keydat.dsize = inkeylen;
        memset(&yprkv, 0, sizeof yprkv);
 
-       r = clnt_call(client, YPPROC_NEXT, xdr_ypreq_key, &yprk,
-           xdr_ypresp_key_val, &yprkv, _yplib_host_timeout);
+       r = clnt_call(client, YPPROC_NEXT, (xdrproc_t)xdr_ypreq_key, &yprk,
+           (xdrproc_t)xdr_ypresp_key_val, &yprkv, _yplib_host_timeout);
        if (r != RPC_SUCCESS)
                clnt_perror(client, "yp_next_host: clnt_call");
 
@@ -223,7 +223,7 @@ yp_next_host(CLIENT *client, char *indom
                memcpy(*outval, yprkv.valdat.dptr, *outvallen);
                (*outval)[*outvallen] = '\0';
        }
-       xdr_free(xdr_ypresp_key_val, (char *)&yprkv);
+       xdr_free((xdrproc_t)xdr_ypresp_key_val, (char *)&yprkv);
        return r;
 }
 
@@ -237,8 +237,8 @@ yp_all_host(CLIENT *client, const char *
        yprnk.domain = indomain;
        yprnk.map = inmap;
 
-       status = clnt_call(client, YPPROC_ALL, xdr_ypreq_nokey, &yprnk,
-           xdr_ypall, (char *)incallback, _yplib_host_timeout);
+       status = clnt_call(client, YPPROC_ALL, (xdrproc_t)xdr_ypreq_nokey, 
&yprnk,
+           (xdrproc_t)xdr_ypall, (char *)incallback, _yplib_host_timeout);
 
        if (status != RPC_SUCCESS)
                return YPERR_RPC;
@@ -258,13 +258,13 @@ yp_order_host(CLIENT *client, char *indo
 
        memset(&ypro, 0, sizeof ypro);
 
-       r = clnt_call(client, YPPROC_ORDER, xdr_ypreq_nokey, &yprnk,
-           xdr_ypresp_order, &ypro, _yplib_host_timeout);
+       r = clnt_call(client, YPPROC_ORDER, (xdrproc_t)xdr_ypreq_nokey, &yprnk,
+           (xdrproc_t)xdr_ypresp_order, &ypro, _yplib_host_timeout);
        if (r != RPC_SUCCESS)
                clnt_perror(client, "yp_order_host: clnt_call");
 
        *outorder = ypro.ordernum;
-       xdr_free(xdr_ypresp_order, (char *)&ypro);
+       xdr_free((xdrproc_t)xdr_ypresp_order, (char *)&ypro);
        return ypprot_err(ypro.status);
 }
 
@@ -280,15 +280,15 @@ yp_master_host(CLIENT *client, char *ind
 
        memset(&yprm, 0, sizeof yprm);
 
-       r = clnt_call(client, YPPROC_MASTER, xdr_ypreq_nokey, &yprnk,
-           xdr_ypresp_master, &yprm, _yplib_host_timeout);
+       r = clnt_call(client, YPPROC_MASTER, (xdrproc_t)xdr_ypreq_nokey, &yprnk,
+           (xdrproc_t)xdr_ypresp_master, &yprm, _yplib_host_timeout);
        if (r != RPC_SUCCESS)
                clnt_perror(client, "yp_master: clnt_call");
 
        if (!(r = ypprot_err(yprm.status))) {
                *outname = (char *)strdup(yprm.master);
        }
-       xdr_free(xdr_ypresp_master, (char *)&yprm);
+       xdr_free((xdrproc_t)xdr_ypresp_master, (char *)&yprm);
        return r;
 }
 
@@ -300,8 +300,9 @@ yp_maplist_host(CLIENT *client, char *in
 
        memset(&ypml, 0, sizeof ypml);
 
-       r = clnt_call(client, YPPROC_MAPLIST, xdr_ypdomain_wrap_string,
-           indomain, xdr_ypresp_maplist, &ypml, _yplib_host_timeout);
+       r = clnt_call(client, YPPROC_MAPLIST,
+           (xdrproc_t)xdr_ypdomain_wrap_string, indomain,
+           (xdrproc_t)xdr_ypresp_maplist, &ypml, _yplib_host_timeout);
        if (r != RPC_SUCCESS)
                clnt_perror(client, "yp_maplist: clnt_call");
 
Index: usr.sbin/ypserv/yppush/yppush.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/ypserv/yppush/yppush.c,v
retrieving revision 1.23
diff -u -p -r1.23 yppush.c
--- usr.sbin/ypserv/yppush/yppush.c     1 Feb 2011 20:59:41 -0000       1.23
+++ usr.sbin/ypserv/yppush/yppush.c     24 Aug 2011 08:48:59 -0000
@@ -209,7 +209,8 @@ main(int argc, char *argv[])
        tv.tv_sec = 10;
        tv.tv_usec = 0;
        ypserv = yp_bind_local(YPPROG, YPVERS);
-       retval = clnt_call(ypserv, YPPROC_CLEAR, xdr_void, 0, xdr_void, 0, tv);
+       retval = clnt_call(ypserv, YPPROC_CLEAR, (xdrproc_t)xdr_void, 0,
+           (xdrproc_t)xdr_void, 0, tv);
        if (retval != RPC_SUCCESS)
                errx(1, "clnt_call CLEAR to local ypserv: %s",
                    clnt_sperrno(retval));
@@ -394,8 +395,8 @@ push(char *host, int hostlen, struct ypp
                printf("asking host %s to transfer map (xid=%d)\n", target,
                    req.transid);
 
-       rv = clnt_call(ypserv, YPPROC_XFR, xdr_ypreq_xfr, &req,
-                       xdr_void, NULL, tv);                    /* do it! */
+       rv = clnt_call(ypserv, YPPROC_XFR, (xdrproc_t)xdr_ypreq_xfr, &req,
+           (xdrproc_t)xdr_void, NULL, tv);             /* do it! */
 
        if (rv != RPC_SUCCESS && rv != RPC_TIMEDOUT) {
                warnx("unable to xfr to host %s: %s", target, clnt_sperrno(rv));
Index: usr.sbin/ypserv/yppush/yppush_svc.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/ypserv/yppush/yppush_svc.c,v
retrieving revision 1.9
diff -u -p -r1.9 yppush_svc.c
--- usr.sbin/ypserv/yppush/yppush_svc.c 21 Oct 2009 00:01:57 -0000      1.9
+++ usr.sbin/ypserv/yppush/yppush_svc.c 24 Aug 2011 08:48:59 -0000
@@ -92,14 +92,14 @@ yppush_xfrrespprog_1(struct svc_req *rqs
        _rpcsvcdirty = 1;
        switch (rqstp->rq_proc) {
        case YPPUSHPROC_NULL:
-               xdr_argument = xdr_void;
-               xdr_result = xdr_void;
+               xdr_argument = (xdrproc_t)xdr_void;
+               xdr_result = (xdrproc_t)xdr_void;
                local = yppushproc_null_1_svc;
                break;
 
        case YPPUSHPROC_XFRRESP:
-               xdr_argument = xdr_yppushresp_xfr;
-               xdr_result = xdr_void;
+               xdr_argument = (xdrproc_t)xdr_yppushresp_xfr;
+               xdr_result = (xdrproc_t)xdr_void;
                local = yppushproc_xfrresp_1_svc;
                break;
 
Index: usr.sbin/ypserv/ypserv/ypserv.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/ypserv/ypserv/ypserv.c,v
retrieving revision 1.24
diff -u -p -r1.24 ypserv.c
--- usr.sbin/ypserv/ypserv/ypserv.c     25 Apr 2011 22:54:05 -0000      1.24
+++ usr.sbin/ypserv/ypserv/ypserv.c     24 Aug 2011 08:48:59 -0000
@@ -155,85 +155,85 @@ ypprog_2(struct svc_req *rqstp, SVCXPRT 
 
        switch (rqstp->rq_proc) {
        case YPPROC_NULL:
-               xdr_argument = xdr_void;
-               xdr_result = xdr_void;
+               xdr_argument = (xdrproc_t)xdr_void;
+               xdr_result = (xdrproc_t)xdr_void;
                local = ypproc_null_2_svc;
                SVCNAME("null_2");
                break;
 
        case YPPROC_DOMAIN:
-               xdr_argument = xdr_ypdomain_wrap_string;
-               xdr_result = xdr_bool;
+               xdr_argument = (xdrproc_t)xdr_ypdomain_wrap_string;
+               xdr_result = (xdrproc_t)xdr_bool;
                local = ypproc_domain_2_svc;
                SVCNAME("domain_2");
                break;
 
        case YPPROC_DOMAIN_NONACK:
-               xdr_argument = xdr_ypdomain_wrap_string;
-               xdr_result = xdr_bool;
+               xdr_argument = (xdrproc_t)xdr_ypdomain_wrap_string;
+               xdr_result = (xdrproc_t)xdr_bool;
                local = ypproc_domain_nonack_2_svc;
                SVCNAME("domain_nonack_2");
                break;
 
        case YPPROC_MATCH:
-               xdr_argument = xdr_ypreq_key;
-               xdr_result = xdr_ypresp_val;
+               xdr_argument = (xdrproc_t)xdr_ypreq_key;
+               xdr_result = (xdrproc_t)xdr_ypresp_val;
                local = ypproc_match_2_svc;
                SVCNAME("match_2");
                break;
 
        case YPPROC_FIRST:
-               xdr_argument = xdr_ypreq_nokey;
-               xdr_result = xdr_ypresp_key_val;
+               xdr_argument = (xdrproc_t)xdr_ypreq_nokey;
+               xdr_result = (xdrproc_t)xdr_ypresp_key_val;
                local = ypproc_first_2_svc;
                SVCNAME("first_2");
                break;
 
        case YPPROC_NEXT:
-               xdr_argument = xdr_ypreq_key;
-               xdr_result = xdr_ypresp_key_val;
+               xdr_argument = (xdrproc_t)xdr_ypreq_key;
+               xdr_result = (xdrproc_t)xdr_ypresp_key_val;
                local = ypproc_next_2_svc;
                SVCNAME("next_2");
                break;
 
        case YPPROC_XFR:
-               xdr_argument = xdr_ypreq_xfr;
-               xdr_result = xdr_ypresp_xfr;
+               xdr_argument = (xdrproc_t)xdr_ypreq_xfr;
+               xdr_result = (xdrproc_t)xdr_ypresp_xfr;
                local = ypproc_xfr_2_svc;
                SVCNAME("xfer_2");
                break;
 
        case YPPROC_CLEAR:
-               xdr_argument = xdr_void;
-               xdr_result = xdr_void;
+               xdr_argument = (xdrproc_t)xdr_void;
+               xdr_result = (xdrproc_t)xdr_void;
                local = ypproc_clear_2_svc;
                SVCNAME("clear_2");
                break;
 
        case YPPROC_ALL:
-               xdr_argument = xdr_ypreq_nokey;
-               xdr_result = xdr_ypresp_all;
+               xdr_argument = (xdrproc_t)xdr_ypreq_nokey;
+               xdr_result = (xdrproc_t)xdr_ypresp_all;
                local = ypproc_all_2_svc;
                SVCNAME("all_2");
                break;
 
        case YPPROC_MASTER:
-               xdr_argument = xdr_ypreq_nokey;
-               xdr_result = xdr_ypresp_master;
+               xdr_argument = (xdrproc_t)xdr_ypreq_nokey;
+               xdr_result = (xdrproc_t)xdr_ypresp_master;
                local = ypproc_master_2_svc;
                SVCNAME("master_2");
                break;
 
        case YPPROC_ORDER:
-               xdr_argument = xdr_ypreq_nokey;
-               xdr_result = xdr_ypresp_order;
+               xdr_argument = (xdrproc_t)xdr_ypreq_nokey;
+               xdr_result = (xdrproc_t)xdr_ypresp_order;
                local = ypproc_order_2_svc;
                SVCNAME("order_2");
                break;
 
        case YPPROC_MAPLIST:
-               xdr_argument = xdr_ypdomain_wrap_string;
-               xdr_result = xdr_ypresp_maplist;
+               xdr_argument = (xdrproc_t)xdr_ypdomain_wrap_string;
+               xdr_result = (xdrproc_t)xdr_ypresp_maplist;
                local = ypproc_maplist_2_svc;
                SVCNAME("maplist_2");
                break;
Index: usr.sbin/ypserv/ypserv/ypserv_proc.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/ypserv/ypserv/ypserv_proc.c,v
retrieving revision 1.15
diff -u -p -r1.15 ypserv_proc.c
--- usr.sbin/ypserv/ypserv/ypserv_proc.c        1 Jul 2011 03:09:29 -0000       
1.15
+++ usr.sbin/ypserv/ypserv/ypserv_proc.c        24 Aug 2011 08:49:00 -0000
@@ -337,7 +337,7 @@ ypproc_all_2_svc(void *argp, struct svc_
 
        case 0:
                /* CHILD: send result, then exit */
-               if (!svc_sendreply(rqstp->rq_xprt, ypdb_xdr_get_all, (void *)k))
+               if (!svc_sendreply(rqstp->rq_xprt, (xdrproc_t)ypdb_xdr_get_all, 
(void *)k))
                        svcerr_systemerr(rqstp->rq_xprt);
 
                /* Note: no need to free args; we're exiting. */
Index: usr.sbin/ypserv/ypxfr/ypxfr.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/ypserv/ypxfr/ypxfr.c,v
retrieving revision 1.20
diff -u -p -r1.20 ypxfr.c
--- usr.sbin/ypserv/ypxfr/ypxfr.c       25 Apr 2011 22:51:26 -0000      1.20
+++ usr.sbin/ypserv/ypxfr/ypxfr.c       24 Aug 2011 08:49:00 -0000
@@ -592,7 +592,8 @@ send_clear(CLIENT *client)
        tv.tv_usec = 0;
 
        /* Send CLEAR */
-       r = clnt_call(client, YPPROC_CLEAR, xdr_void, 0, xdr_void, 0, tv);
+       r = clnt_call(client, YPPROC_CLEAR, (xdrproc_t)xdr_void, 0,
+           (xdrproc_t)xdr_void, 0, tv);
        if (r != RPC_SUCCESS) {
                clnt_perror(client, "yp_clear: clnt_call");
                status = YPPUSH_RPC;
@@ -615,8 +616,8 @@ send_reply(CLIENT *client, int status, i
        resp.xfrstat = status;
 
        /* Send XFRRESP */
-       r = clnt_call(client, YPPUSHPROC_XFRRESP, xdr_ypresp_xfr, &resp,
-           xdr_void, 0, tv);
+       r = clnt_call(client, YPPUSHPROC_XFRRESP, (xdrproc_t)xdr_ypresp_xfr,
+           &resp, (xdrproc_t)xdr_void, 0, tv);
        if (r != RPC_SUCCESS) {
                clnt_perror(client, "yppushresp_xdr: clnt_call");
                status = YPPUSH_RPC;
Index: usr.sbin/ypset/ypset.c
===================================================================
RCS file: /cvsroot/src/usr.sbin/ypset/ypset.c,v
retrieving revision 1.16
diff -u -p -r1.16 ypset.c
--- usr.sbin/ypset/ypset.c      7 Sep 2004 13:20:41 -0000       1.16
+++ usr.sbin/ypset/ypset.c      24 Aug 2011 08:49:00 -0000
@@ -146,7 +146,7 @@ bind_tohost(sin, dom, server)
        client->cl_auth = authunix_create_default();
 
        r = clnt_call(client, YPBINDPROC_SETDOM,
-           xdr_ypbind_setdom, &ypsd, xdr_void, NULL, tv);
+           (xdrproc_t)xdr_ypbind_setdom, &ypsd, (xdrproc_t)xdr_void, NULL, tv);
        if (r) {
                warnx("Cannot ypset for domain %s on host %s: %s.",
                    dom, server, clnt_sperrno(r));


Home | Main Index | Thread Index | Old Index