Squelch a Coverity warning.

[tcpdump] / print-nfs.c

diff --git a/print-nfs.c b/print-nfs.c
index e5f081a492b20b8151a8343d8adcb9d3cd8bfaf2..84884aa5a1f439320e231b0abbcb3ae58ac936c7 100644 (file)
--- a/print-nfs.c
+++ b/print-nfs.c
@@ -23,12 +23,12 @@
 #include "config.h"
 #endif
 
 #include "config.h"
 #endif
 

-#include <tcpdump-stdinc.h>
+#include <netdissect-stdinc.h>

 
 #include <stdio.h>
 #include <string.h>
 
 
 #include <stdio.h>
 #include <string.h>
 

-#include "interface.h"
+#include "netdissect.h"

 #include "addrtoname.h"
 #include "extract.h"
 
 #include "addrtoname.h"
 #include "extract.h"
 


@@ -36,9 +36,7 @@
 #include "nfsfh.h"
 
 #include "ip.h"
 #include "nfsfh.h"
 
 #include "ip.h"

-#ifdef INET6

 #include "ip6.h"
 #include "ip6.h"

-#endif

 #include "rpc_auth.h"
 #include "rpc_msg.h"
 
 #include "rpc_auth.h"
 #include "rpc_msg.h"
 


@@ -202,33 +200,24 @@ static void
 print_nfsaddr(netdissect_options *ndo,
               const u_char *bp, const char *s, const char *d)
 {
 print_nfsaddr(netdissect_options *ndo,
               const u_char *bp, const char *s, const char *d)
 {

-       struct ip *ip;
-#ifdef INET6
-       struct ip6_hdr *ip6;
+       const struct ip *ip;
+       const struct ip6_hdr *ip6;

        char srcaddr[INET6_ADDRSTRLEN], dstaddr[INET6_ADDRSTRLEN];
        char srcaddr[INET6_ADDRSTRLEN], dstaddr[INET6_ADDRSTRLEN];

-#else
-#ifndef INET_ADDRSTRLEN
-#define INET_ADDRSTRLEN        16
-#endif
-       char srcaddr[INET_ADDRSTRLEN], dstaddr[INET_ADDRSTRLEN];
-#endif

 
        srcaddr[0] = dstaddr[0] = '\0';
 
        srcaddr[0] = dstaddr[0] = '\0';

-       switch (IP_V((struct ip *)bp)) {
+       switch (IP_V((const struct ip *)bp)) {

        case 4:
        case 4:

-               ip = (struct ip *)bp;
+               ip = (const struct ip *)bp;

                strlcpy(srcaddr, ipaddr_string(ndo, &ip->ip_src), sizeof(srcaddr));
                strlcpy(dstaddr, ipaddr_string(ndo, &ip->ip_dst), sizeof(dstaddr));
                break;
                strlcpy(srcaddr, ipaddr_string(ndo, &ip->ip_src), sizeof(srcaddr));
                strlcpy(dstaddr, ipaddr_string(ndo, &ip->ip_dst), sizeof(dstaddr));
                break;

-#ifdef INET6

        case 6:
        case 6:

-               ip6 = (struct ip6_hdr *)bp;
+               ip6 = (const struct ip6_hdr *)bp;

                strlcpy(srcaddr, ip6addr_string(ndo, &ip6->ip6_src),
                    sizeof(srcaddr));
                strlcpy(dstaddr, ip6addr_string(ndo, &ip6->ip6_dst),
                    sizeof(dstaddr));
                break;
                strlcpy(srcaddr, ip6addr_string(ndo, &ip6->ip6_src),
                    sizeof(srcaddr));
                strlcpy(dstaddr, ip6addr_string(ndo, &ip6->ip6_dst),
                    sizeof(dstaddr));
                break;

-#endif

        default:
                strlcpy(srcaddr, "?", sizeof(srcaddr));
                strlcpy(dstaddr, "?", sizeof(dstaddr));
        default:
                strlcpy(srcaddr, "?", sizeof(srcaddr));
                strlcpy(dstaddr, "?", sizeof(dstaddr));


@@ -433,7 +422,7 @@ parsereq(netdissect_options *ndo,
        /*
         * find the start of the req data (if we captured it)
         */
        /*
         * find the start of the req data (if we captured it)
         */

-       dp = (uint32_t *)&rp->rm_call.cb_cred;
+       dp = (const uint32_t *)&rp->rm_call.cb_cred;

        ND_TCHECK(dp[1]);
        len = EXTRACT_32BITS(&dp[1]);
        if (len < length) {
        ND_TCHECK(dp[1]);
        len = EXTRACT_32BITS(&dp[1]);
        if (len < length) {


@@ -495,7 +484,7 @@ parsefn(netdissect_options *ndo,
 
        ND_TCHECK2(*dp, ((len + 3) & ~3));
 
 
        ND_TCHECK2(*dp, ((len + 3) & ~3));
 

-       cp = (u_char *)dp;
+       cp = (const u_char *)dp;

        /* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */
        dp += ((len + 3) & ~3) / sizeof(*dp);
        ND_PRINT((ndo, "\""));
        /* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */
        dp += ((len + 3) & ~3) / sizeof(*dp);
        ND_PRINT((ndo, "\""));


@@ -850,13 +839,8 @@ nfs_printfh(netdissect_options *ndo,
 struct xid_map_entry {
        uint32_t        xid;            /* transaction ID (net order) */
        int ipver;                      /* IP version (4 or 6) */
 struct xid_map_entry {
        uint32_t        xid;            /* transaction ID (net order) */
        int ipver;                      /* IP version (4 or 6) */

-#ifdef INET6

        struct in6_addr client;         /* client IP address (net order) */
        struct in6_addr server;         /* server IP address (net order) */
        struct in6_addr client;         /* client IP address (net order) */
        struct in6_addr server;         /* server IP address (net order) */

-#else
-       struct in_addr  client;         /* client IP address (net order) */
-       struct in_addr  server;         /* server IP address (net order) */
-#endif

        uint32_t        proc;           /* call proc number (host order) */
        uint32_t        vers;           /* program version (host order) */
 };
        uint32_t        proc;           /* call proc number (host order) */
        uint32_t        vers;           /* program version (host order) */
 };


@@ -878,23 +862,19 @@ static int
 xid_map_enter(netdissect_options *ndo,
               const struct sunrpc_msg *rp, const u_char *bp)
 {
 xid_map_enter(netdissect_options *ndo,
               const struct sunrpc_msg *rp, const u_char *bp)
 {

-       struct ip *ip = NULL;
-#ifdef INET6
-       struct ip6_hdr *ip6 = NULL;
-#endif
+       const struct ip *ip = NULL;
+       const struct ip6_hdr *ip6 = NULL;

        struct xid_map_entry *xmep;
 
        if (!ND_TTEST(rp->rm_call.cb_vers))
                return (0);
        struct xid_map_entry *xmep;
 
        if (!ND_TTEST(rp->rm_call.cb_vers))
                return (0);

-       switch (IP_V((struct ip *)bp)) {
+       switch (IP_V((const struct ip *)bp)) {

        case 4:
        case 4:

-               ip = (struct ip *)bp;
+               ip = (const struct ip *)bp;

                break;
                break;

-#ifdef INET6

        case 6:
        case 6:

-               ip6 = (struct ip6_hdr *)bp;
+               ip6 = (const struct ip6_hdr *)bp;

                break;
                break;

-#endif

        default:
                return (1);
        }
        default:
                return (1);
        }


@@ -910,13 +890,11 @@ xid_map_enter(netdissect_options *ndo,
                UNALIGNED_MEMCPY(&xmep->client, &ip->ip_src, sizeof(ip->ip_src));
                UNALIGNED_MEMCPY(&xmep->server, &ip->ip_dst, sizeof(ip->ip_dst));
        }
                UNALIGNED_MEMCPY(&xmep->client, &ip->ip_src, sizeof(ip->ip_src));
                UNALIGNED_MEMCPY(&xmep->server, &ip->ip_dst, sizeof(ip->ip_dst));
        }

-#ifdef INET6

        else if (ip6) {
                xmep->ipver = 6;
                UNALIGNED_MEMCPY(&xmep->client, &ip6->ip6_src, sizeof(ip6->ip6_src));
                UNALIGNED_MEMCPY(&xmep->server, &ip6->ip6_dst, sizeof(ip6->ip6_dst));
        }
        else if (ip6) {
                xmep->ipver = 6;
                UNALIGNED_MEMCPY(&xmep->client, &ip6->ip6_src, sizeof(ip6->ip6_src));
                UNALIGNED_MEMCPY(&xmep->server, &ip6->ip6_dst, sizeof(ip6->ip6_dst));
        }

-#endif

        xmep->proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);
        xmep->vers = EXTRACT_32BITS(&rp->rm_call.cb_vers);
        return (1);
        xmep->proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);
        xmep->vers = EXTRACT_32BITS(&rp->rm_call.cb_vers);
        return (1);


@@ -932,13 +910,12 @@ xid_map_find(const struct sunrpc_msg *rp, const u_char *bp, uint32_t *proc,
 {
        int i;
        struct xid_map_entry *xmep;
 {
        int i;
        struct xid_map_entry *xmep;

-       uint32_t xid = rp->rm_xid;
-       struct ip *ip = (struct ip *)bp;
-#ifdef INET6
-       struct ip6_hdr *ip6 = (struct ip6_hdr *)bp;
-#endif
+       uint32_t xid;
+       const struct ip *ip = (const struct ip *)bp;
+       const struct ip6_hdr *ip6 = (const struct ip6_hdr *)bp;

        int cmp;
 
        int cmp;
 

+       UNALIGNED_MEMCPY(&xid, &rp->rm_xid, sizeof(xmep->xid));

        /* Start searching from where we last left off */
        i = xid_map_hint;
        do {
        /* Start searching from where we last left off */
        i = xid_map_hint;
        do {


@@ -955,7 +932,6 @@ xid_map_find(const struct sunrpc_msg *rp, const u_char *bp, uint32_t *proc,
                                cmp = 0;
                        }
                        break;
                                cmp = 0;
                        }
                        break;

-#ifdef INET6

                case 6:
                        if (UNALIGNED_MEMCMP(&ip6->ip6_src, &xmep->server,
                                   sizeof(ip6->ip6_src)) != 0 ||
                case 6:
                        if (UNALIGNED_MEMCMP(&ip6->ip6_src, &xmep->server,
                                   sizeof(ip6->ip6_src)) != 0 ||


@@ -964,7 +940,6 @@ xid_map_find(const struct sunrpc_msg *rp, const u_char *bp, uint32_t *proc,
                                cmp = 0;
                        }
                        break;
                                cmp = 0;
                        }
                        break;

-#endif

                default:
                        cmp = 0;
                        break;
                default:
                        cmp = 0;
                        break;


@@ -1038,7 +1013,7 @@ parserep(netdissect_options *ndo,
        }
        /* successful return */
        ND_TCHECK2(*dp, sizeof(astat));
        }
        /* successful return */
        ND_TCHECK2(*dp, sizeof(astat));

-       return ((uint32_t *) (sizeof(astat) + ((char *)dp)));
+       return ((const uint32_t *) (sizeof(astat) + ((const char *)dp)));

 trunc:
        return (0);
 }
 trunc:
        return (0);
 }


@@ -1083,7 +1058,7 @@ parsefattr(netdissect_options *ndo,
                if (v3) {
                        ND_TCHECK(fap->fa3_size);
                        ND_PRINT((ndo, " sz %" PRIu64,
                if (v3) {
                        ND_TCHECK(fap->fa3_size);
                        ND_PRINT((ndo, " sz %" PRIu64,

-                               EXTRACT_64BITS((uint32_t *)&fap->fa3_size)));
+                               EXTRACT_64BITS((const uint32_t *)&fap->fa3_size)));

                } else {
                        ND_TCHECK(fap->fa2_size);
                        ND_PRINT((ndo, " sz %d", EXTRACT_32BITS(&fap->fa2_size)));
                } else {
                        ND_TCHECK(fap->fa2_size);
                        ND_PRINT((ndo, " sz %d", EXTRACT_32BITS(&fap->fa2_size)));


@@ -1098,9 +1073,9 @@ parsefattr(netdissect_options *ndo,
                               EXTRACT_32BITS(&fap->fa3_rdev.specdata1),
                               EXTRACT_32BITS(&fap->fa3_rdev.specdata2)));
                        ND_PRINT((ndo, " fsid %" PRIx64,
                               EXTRACT_32BITS(&fap->fa3_rdev.specdata1),
                               EXTRACT_32BITS(&fap->fa3_rdev.specdata2)));
                        ND_PRINT((ndo, " fsid %" PRIx64,

-                               EXTRACT_64BITS((uint32_t *)&fap->fa3_fsid)));
+                               EXTRACT_64BITS((const uint32_t *)&fap->fa3_fsid)));

                        ND_PRINT((ndo, " fileid %" PRIx64,
                        ND_PRINT((ndo, " fileid %" PRIx64,

-                               EXTRACT_64BITS((uint32_t *)&fap->fa3_fileid)));
+                               EXTRACT_64BITS((const uint32_t *)&fap->fa3_fileid)));

                        ND_PRINT((ndo, " a/m/ctime %u.%06u",
                               EXTRACT_32BITS(&fap->fa3_atime.nfsv3_sec),
                               EXTRACT_32BITS(&fap->fa3_atime.nfsv3_nsec)));
                        ND_PRINT((ndo, " a/m/ctime %u.%06u",
                               EXTRACT_32BITS(&fap->fa3_atime.nfsv3_sec),
                               EXTRACT_32BITS(&fap->fa3_atime.nfsv3_nsec)));


@@ -1128,7 +1103,7 @@ parsefattr(netdissect_options *ndo,
                               EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_usec)));
                }
        }
                               EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_usec)));
                }
        }

-       return ((const uint32_t *)((unsigned char *)dp +
+       return ((const uint32_t *)((const unsigned char *)dp +

                (v3 ? NFSX_V3FATTR : NFSX_V2FATTR)));
 trunc:
        return (NULL);
                (v3 ? NFSX_V3FATTR : NFSX_V2FATTR)));
 trunc:
        return (NULL);


@@ -1213,14 +1188,14 @@ parsestatfs(netdissect_options *ndo,
 
        if (v3) {
                ND_PRINT((ndo, " tbytes %" PRIu64 " fbytes %" PRIu64 " abytes %" PRIu64,
 
        if (v3) {
                ND_PRINT((ndo, " tbytes %" PRIu64 " fbytes %" PRIu64 " abytes %" PRIu64,

-                       EXTRACT_64BITS((uint32_t *)&sfsp->sf_tbytes),
-                       EXTRACT_64BITS((uint32_t *)&sfsp->sf_fbytes),
-                       EXTRACT_64BITS((uint32_t *)&sfsp->sf_abytes)));
+                       EXTRACT_64BITS((const uint32_t *)&sfsp->sf_tbytes),
+                       EXTRACT_64BITS((const uint32_t *)&sfsp->sf_fbytes),
+                       EXTRACT_64BITS((const uint32_t *)&sfsp->sf_abytes)));

                if (ndo->ndo_vflag) {
                        ND_PRINT((ndo, " tfiles %" PRIu64 " ffiles %" PRIu64 " afiles %" PRIu64 " invar %u",
                if (ndo->ndo_vflag) {
                        ND_PRINT((ndo, " tfiles %" PRIu64 " ffiles %" PRIu64 " afiles %" PRIu64 " invar %u",

-                              EXTRACT_64BITS((uint32_t *)&sfsp->sf_tfiles),
-                              EXTRACT_64BITS((uint32_t *)&sfsp->sf_ffiles),
-                              EXTRACT_64BITS((uint32_t *)&sfsp->sf_afiles),
+                              EXTRACT_64BITS((const uint32_t *)&sfsp->sf_tfiles),
+                              EXTRACT_64BITS((const uint32_t *)&sfsp->sf_ffiles),
+                              EXTRACT_64BITS((const uint32_t *)&sfsp->sf_afiles),

                               EXTRACT_32BITS(&sfsp->sf_invarsec)));
                }
        } else {
                               EXTRACT_32BITS(&sfsp->sf_invarsec)));
                }
        } else {


@@ -1398,7 +1373,7 @@ static int
 parsefsinfo(netdissect_options *ndo,
             const uint32_t *dp)
 {
 parsefsinfo(netdissect_options *ndo,
             const uint32_t *dp)
 {

-       struct nfsv3_fsinfo *sfp;
+       const struct nfsv3_fsinfo *sfp;

        int er;
 
        if (!(dp = parsestatus(ndo, dp, &er)))
        int er;
 
        if (!(dp = parsestatus(ndo, dp, &er)))


@@ -1410,7 +1385,7 @@ parsefsinfo(netdissect_options *ndo,
        if (er)
                return (1);
 
        if (er)
                return (1);
 

-       sfp = (struct nfsv3_fsinfo *)dp;
+       sfp = (const struct nfsv3_fsinfo *)dp;

        ND_TCHECK(*sfp);
        ND_PRINT((ndo, " rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u",
               EXTRACT_32BITS(&sfp->fs_rtmax),
        ND_TCHECK(*sfp);
        ND_PRINT((ndo, " rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u",
               EXTRACT_32BITS(&sfp->fs_rtmax),


@@ -1422,7 +1397,7 @@ parsefsinfo(netdissect_options *ndo,
                ND_PRINT((ndo, " rtmult %u wtmult %u maxfsz %" PRIu64,
                       EXTRACT_32BITS(&sfp->fs_rtmult),
                       EXTRACT_32BITS(&sfp->fs_wtmult),
                ND_PRINT((ndo, " rtmult %u wtmult %u maxfsz %" PRIu64,
                       EXTRACT_32BITS(&sfp->fs_rtmult),
                       EXTRACT_32BITS(&sfp->fs_wtmult),

-                      EXTRACT_64BITS((uint32_t *)&sfp->fs_maxfilesize)));
+                      EXTRACT_64BITS((const uint32_t *)&sfp->fs_maxfilesize)));

                ND_PRINT((ndo, " delta %u.%06u ",
                       EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_sec),
                       EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_nsec)));
                ND_PRINT((ndo, " delta %u.%06u ",
                       EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_sec),
                       EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_nsec)));


@@ -1437,7 +1412,7 @@ parsepathconf(netdissect_options *ndo,
               const uint32_t *dp)
 {
        int er;
               const uint32_t *dp)
 {
        int er;

-       struct nfsv3_pathconf *spp;
+       const struct nfsv3_pathconf *spp;

 
        if (!(dp = parsestatus(ndo, dp, &er)))
                return (0);
 
        if (!(dp = parsestatus(ndo, dp, &er)))
                return (0);


@@ -1448,7 +1423,7 @@ parsepathconf(netdissect_options *ndo,
        if (er)
                return (1);
 
        if (er)
                return (1);
 

-       spp = (struct nfsv3_pathconf *)dp;
+       spp = (const struct nfsv3_pathconf *)dp;

        ND_TCHECK(*spp);
 
        ND_PRINT((ndo, " linkmax %u namemax %u %s %s %s %s",
        ND_TCHECK(*spp);
 
        ND_PRINT((ndo, " linkmax %u namemax %u %s %s %s %s",